Hiilgavus ja vaesus atomic swaps

Miks on atomaarsetel vahetustel puudusi ning kuidas saavad kanalid abiks olla, mis olulist juhtus Constantinople'i hard fork'is ja kuidas käituda, kui gaasi eest maksmiseks pole midagi.

Igale turbeeksperdile peamine motivatsioon — soov vältida vastutust.

Saatus oli armuline, jätsin ICO-ta ära, oodates esimeseid pöördumatuid tehinguid, aga leidsin end peagi krüptobörsi arendamisel.

Mina — ei ole mitte mingil juhul Malchish Kibalchish ja üksainus range pilk on piisav, et ma annaksin kõik võtmed ja paroolid üles. Seetõttu oli minu põhieesmärgiks, kui arhitekt, paigutada kuum krüptoanalüüsi nõel nii kaugele kui võimalik mulle kallite infrastruktuuri elementide juurest.

Ei sinu võtmed, ei sinu probleemid

Ehitusme oleme aktiivide vahetussüsteemi ja soovime välistada nende aktiivide vahehoidmise enda juures, kuid peame tagama tehingu turvalisuse.

Võib mängida kohtuniku rolli vaidlusalustes olukordades ja teostada tehingud rahakottide vahel, mis nõuavad kolme alt kahe allkirja: ostja, müüja ja deponeerija.

Kuid kui osaleja edukalt ründab deponeerijat, siis ta saab soovitud kaks allkirja.

Atomaarne vahetus — vahetuse skeem, kus garanteerijaks on nutileping, mis lubab ainult ausat käitumist.

Nagu mõistatuses, kus on hunt, kits ja kapsas, saad tegutseda ainult ühe ainulaadse õige stsenaariumi järgi ja kannatada kaotusi, kui sellest kõrvale kalduda.

Aga ahnete loomade asemel tagab korra häsifunktsioon, milles on nii keeruline leida kollisiooni, et pole vähematki mõtet alustada.

Esimene samm: mõistatus

Oletame, et Alice soovib ühel ilusal hommikul Bobile bitcoini edastada hunniku "krüptojuani" eest.

• Ta mõtleb välja suure salajase
• Saab temalt häsši
• Edastab bitcoine nutilepingusse, kust Bob saab raha välja võtta, esitades salajase numbri (häsš peab olema lepingus märgitud).
• Kui Bob ei tule oma bitcoine õhtuks, võib Alice need tagasi võtta.

Teine samm: ahvatlus

Mängu astub Bob ja edastab "krüpto-eurod" oma lepingusse, mis on kirjutatud nii, et:

• Alice võib "krüpto-jenid" tagasi võtta, esitades salajase arvu
• Hiljemalt lõuna ajal võib Bob, kui Alice ei ilmu, tagasi saada oma deposiidi

Kolmas samm: mõistatuse lahendamine ahvatluses

Alice tuleb oma raha järele ja võtab Bobi lepingust raha, paljastades samal ajal oma saladuse.

Viimane samm: mõistatus on lahendatud

Transaktsiooni näeb Bob ja tema kotkasilm eraldab sellest Alice'i lepingule esitatud saladuse. Seda saladust kasutab ta, et juba enda bitcoine tagasi võtta.

Kui midagi läheb valesti

Kui Alice äkki osutub surmatu, võtab Bob lõunaks oma jüaani.

Omakorda tagastab Alice õhtuks bitcoini, kui reeturlik Bob otsustab raha paremaid aegu ootama jätta.

Kui eelistate pilti tekstile, on Habras teile põhjalikum ja visuaalsem selgitus aatomite vahetuste toimimise kohta.

Ajavahed, mis on ette nähtud, et kaitsta meid kurja Alice'i eest, kes Bobi raha viib viimasel hetkel, ja ajavahemik lõppeb, samal ajal kui ta värisevate sõrmedega hex-koodi transaktsiooni sisestab.

Osalejad ei saa oma raha kaotada, maksimum on vaid ootamine tagastamise osas.

Toetamine plokiahelatesSee on lihtne nagu sokk skeem, mis nõuab vastastikku suhtlevatelt plokiahelatelt vaid vähe:

• Toetamine nutilepingutele, millel on vähemalt üks haru
• Mõlemad plokiahelad peavad toetama samu hash-algoritme (ärge unustage kontrollida saladuse pikkust)
• Aja lukud.

Esmapilgul võib juba öelda börsile „head aega, meie kohtumine oli eksitus”, aga ei ole ikka nii lihtne.

Kuna kõik oma eelised ja atomic swap lahendustel puudub likviidsus. Peamiselt seetõttu, et kõige populaarsemas paaris BTC-USD ei olnud fiat-osa päris tokenizeeritud.
USDT edu on sünnitanud terve laine stabiilseid münte ERC20 formaadis, alates väga hoitud USDC-st kuni algoritmilise DAI-ni.

Seega lihtsuse huvides arutame edaspidi, et Alice müüb Bobile bitcoine mõne ERC20 tokeni eest, lootes stabiliseerijate õnne, küllap on meil veel palju tehnilisi probleeme.

Kiirus

Bitcoin ja Ethereum eraldi ei ole eriti kiired ning siin peame ootama kõigepealt ühe sissemakse kõigi kinnitustega, seejärel teise.

Kõik see on tingitud sellest, et esmalt sisendab raha osaleja, kellele saladus on tuntud, ja vastane ootab lõplikkust ning siis alles kannab oma osa üle.

Lisaks tegeleme me väga volatiilse varaga, nii et selle aja jooksul võib kurss märkimisväärselt muutuda ning tingimuste muutmine on juba keeruline.

Privaatsus

Iga vahetus jätab jälgi mõlemale plokiahelale. Tähelepanelik vaataja võib märgata sama hash-koodi nutilepingutes ja teha loogilisi järeldusi, mida seal on tehing toimunud, mille põhjal saab teha palju järeldusi kursiväärtustest maksudeni.

Kui börsil on teadlik sinu toimingutest – on see äärmiselt ebameeldiv, aga kui sellest on teadlik igaüks, on see kahekordselt ebameeldiv.

Kasutusmugavus

Plokiahela ja eriti Ethereumi eripära. Vaatame, milliseid samme peab müüja ja ostja ette võtma.

Müüja jaoks on kõik suhteliselt lihtne: tuleb lihtsalt Bitcoin p2sh aadressile üle kanda. Ethereumiga on kõik palju keerulisem.

LepingVaatame keskmist GitHubi lepingut vahetuseks:

contract iERC20 {
    function totalSupply() public view returns (uint256);
    function transfer(address receiver, uint numTokens) public returns (bool);
    function balanceOf(address tokenOwner) public view returns (uint);
    function approve(address delegate, uint numTokens) public returns (bool);
    function allowance(address owner, address delegate) public view returns (uint);
    function transferFrom(address owner, address buyer, uint numTokens) public returns (bool);
}

contract Swapper {

    struct Swap {
        iERC20 token;
        bytes32 hash;
        uint amount;
        uint refundTime;
        bytes32 secret;
    }

    mapping (address => mapping(address => Swap)) swaps;

    function create(iERC20 token, bytes32 hash, address receiver, uint amount, uint refundTime) public {
        require(swaps[msg.sender][receiver].amount == 0); // check if swap with given hash already exists
        require(token.transferFrom(msg.sender, address(this), amount)); // transfer locked tokens to swap contract
        swaps[msg.sender][receiver] = Swap(token, hash, amount, refundTime, 0x00); // create swap
    }
    
    function hashOf(bytes32 secret) public pure returns(bytes32) {
        return sha256(abi.encodePacked(secret));
    }


    function withdraw(address owner, bytes32 secret) public {
        Swap memory swap = swaps[owner][msg.sender];
        require(swap.secret == bytes32(0));
        require(swap.hash == sha256(abi.encodePacked(secret))); // swap exists
        swaps[owner][msg.sender].secret = secret;
        swap.token.transfer(msg.sender, swap.amount);
    }

    function refund(address receiver) public {
        Swap memory swap = swaps[msg.sender][receiver];
        require(now > swap.refundTime);
        delete swaps[msg.sender][receiver];
        swap.token.transfer(msg.sender, swap.amount);
    }
}

Tähelepanu! Ärge kasutage seda ja muid artiklis olevaid lepinguid tootmises, need on kirjutatud ainult demonstreerimiseks. Eriti see.

• Bob peab kutsuma tokeni lepingu meetodi approve, andes swap-lepingu oma tokenitele juurdepääsu
• Bob loob swap-i ja lepingu meetodi abil transferFrom võtab saatjalt tokensid oma aadressile
• Alice on withdraw paljastab saladuse ja leping kutsub esile ülekandmine

Enamik rahakotte ja krüptobörse ei toeta approve tokenite jaoks, ja pole ka ime.

Kasutajad teevad sageli vigu ja lihtsalt kannavad tokenid lepingule, pärast mida tokenid lihtsalt kaovad. Etherscani kommentaarid on täis õnnetute kaebusi.

Lepingu kutseks on vaja maksta komisjonitasu ETH-s, mis tähendab, et mõlemal osalejal peab olema seda enne tehingu alustamist, ja sellega ei taha keegi tegeleda.

Gaasihoidla

Alustuseks tuleks eemaldada saatja kontroll kõikjal, kus see vaid võimalik, ja eeldada, et meil on keegi, kes kannatab gaasi ülejäägi käes ja kutsub lepingut kõigile soovijatele.

Uuendatud leping

contract Swapper {

    struct Swap {
        iERC20 token;
        address receiver;
        uint amount;
        address refundAddress;
        uint refundTime;
    }

    mapping (bytes32 => Swap) swaps;

    function create(iERC20 token, bytes32 hash, address receiver, uint amount, address refundAddress, uint refundTime) public {
        require(swaps[hash].amount == 0); // kasuta hash'i ainult ühte korda
        require(token.transferFrom(msg.sender, address(this), amount));
        swaps[hash] = Swap(token, receiver, amount, refundAddress, refundTime);
    }


    function withdraw(bytes memory secret) public {
        bytes32 hash = sha256(secret);
        Swap memory swap = swaps[hash];
        require(swap.amount > 0);
        delete swaps[hash];
        swap.token.transfer(swap.receiver, swap.amount);
    }

    function refund(bytes32 hash) public {
        Swap memory swap = swaps[hash];
        require(now > swap.refundTime);
        delete swaps[hash];
        swap.token.transfer(swap.refundAddress, swap.amount);
    }
}

Leping- võtme dualism ja EIP 712

Kuidas me teame, et aadress Ethereumis võib olla leping või subjekti, st võti.
Peamine tegevus võtmel on allkirjastada mingeid teateid.

Me võime saatjana kasutada Bob- lepingut, mis teeb kõik vajalikud ülekanded, kontrollides eelnevalt Bob-võtme allkirja.

Nüüd võib keegi sponsoreerida osalise tasu, kuid otsuse langetab ainult see, kellel on teada võti.

Bob-leping

library EIP712ProxyLibrary {
    function hashCommand(address sender, iERC20 token, Swapper swapper, bytes32 hash, address receiver, uint amount, address refundAddress, uint refundTime) public view returns(bytes32);
}

contract ProxyBob {
    address owner;

    constructor(address _owner) public {
        owner = _owner;
    }

    function createSwap(Swapper swapper, iERC20 token, bytes32 hash, address receiver, uint amount, address refundAddress, uint refundTime, uint8 v, bytes32 r, bytes32 s) public {
        require(owner == ecrecover(EIP712ProxyLibrary.hashCommand(address(this), token, swapper, hash, receiver, amount, refundAddress, refundTime), v, r, s));
        token.approve(address(swapper), amount);
        swapper.create(token, hash, receiver, amount, refundAddress, refundTime);
    }
}

Allkirjade töötlemiseks keerukate andmestruktuuride kohta Ethereumis on standard EIP 712, rohkem saate sellest lugeda Metamaski rahakoti blogis

Jaga ja valitse

Sageli näeb Ethereum'i lepingu häkkimise stsenaarium välja järgmiselt:

• Osaleja paneb vahendid lepingusse
• Siis võtab vahendid välja
• Midagi läheb valesti
• Kurjategija võtab raha järjest uuesti ja uuesti

Kui me naaseme meie esimese näite juurde, siis midagi läheb valesti, kui mõistatus on tühi baitide kogus.

Kuidas varastada miljonLoo swap hashiga 0x66687aadf862bd776c8fc18b8e9f8e20089714856ee233b3902a591d0d5f2925
See on sha256 0x0000000000000000000000000000000000000000000000000000000000000000
Edastame saladuse ja võtame oma tokenid
Edastame veelkord ja võtame teiste omad, kõik seetõttu, et 0 = 0

Loodes iga tehingu jaoks eraldi leping, saame isoleerida lepingud EVM tasemel.

Aga see ei ole veel kõik: nüüd on igal tehingul oma aadress, kuhu saab tokenid edastada igast rahakotist või börsilt.

Hüljatud lepingud ja create2

Aga nüüd peame igaks tehinguks looma leping ja ootama, kuni ostja kannab sinna tööjõu "krüptorahad". Skeemis "hommikul lepingud, õhtul raha" on alati oht, et ostja loobub, ja eteerium lepingute loomiseks on juba kulutatud.

Kas ei võiks seda teha nii, et hommikul raha ja õhtul baitide?

Harde fork Constantinople'i arendajad EIP 1014 lisasid käsu create2, mis loob uue lepingu määratletud aadressil

keccak256( 0xff ++ address ++ salt ++ keccak256(init_code))[12:]

Kus

• address — tehase lepingute aadress
• salt — mingi number, mille tähenduse saame teada järgmises osas
• init_code — lepingu baitkood ja konstruktori parameetrid.

TehasKäsk toimib ainult läbi assembly, seega näeb tehas välja veidi hirmutav:

contract Factory {
  event Deployed(address addr, uint256 salt);

  function create2(bytes memory code, uint256 salt) public {
    address addr;
    assembly {

      addr := create2(0, add(code, 0x20), mload(code), salt)
    }

    emit Deployed(addr, salt);
  }
}

Teie lepingu koodi saab hankida web3 abil:

const MyContract = new web3.eth.Contract(ABI, {})
const сode = MyContract.deploy({
    data: BYTECODE,
    arguments: contructorArgs  
}).encodeABI();
const factory = new web3.eth.Contract(FACTORY_ABI, factoryAddress);
tx = factory.methods.create2(сode, salt);

Oma piiratud toetuse tõttu solidity's, võib lepingu gaasi arvutada valesti mõningate eetri nüansside tõttu.

Eriti armas on, et gaasi puudumise korral tõuseb leping sisemise veaga, andmata teada, et gaasi ei jätku, nagu võiks oodata.

Nüüd saame tõlkida tokenid lepinguteks, neid eelnevalt loomata, ja enne kui me need võrku avaldame, ei oska keegi aimata, mida leping täpselt teeb.

Võrdub, et vares vareselt silma ei kaeva.

Selge on, et tõsist analüütikut, kes on saanud head investeeringud režiimi vaenlastele rahapesus võitlemiseks, sellised lapsikud nipid ei peata ning pärast lepingu loomist näeb ta ikkagi hash'i.

Kuidas teha nii, et hash ei lekiks?

Swap'i viime off-chain: osalised vahetavad allkirju swap-lepingule ülemineku jaoks ning seejärel paljastatakse saladus privaatselt.

Samm-sammultLoodud on kaks "multisig'i", mille tõttu saab varad välja võtta, kui Alice'i ja Bob'i allkirjad on olemas.

Kuna kellegi osaleja offline minek ei tohi olla tragöödia, lisame vana hea aegumise.

Alice ja Bob teevad samal ajal deposiidid

• Alice mõtleb välja salajase ja edastab Bob'ile salajase hash'i ning tehingu allkirja, mis viib bitcoine swap'a aadressile.
• Bob edastab Alice'ile allkirja, et tühjendada tokenid swap-lepingule, kasutades mõeldud hash'i.
• Alice ütleb Bob'ile saladuse.

Sel hetkel toimub harmoonia: nii Alice kui Bob saavad igal momendil tehingu lõpetada. Selles sõbralikus keskkonnas saavad nad vahetada allkirju raha väljavõtmiseks lõppaadressidele.

Kolmandale vaatlejale näib, nagu oleks raha läbinud 2/2 multisig leping.

Ja see skeem võimaldab mõlemal osapoolel samaaegselt deposiidi teha, kuna saladus mõeldakse välja pärast kõiki kinnitusi.

Tase 2

Kuna me saame raha kanda ühele aadressile ja ei avalda vahepealset tehingut, ei takista meid midagi raha väljamaksmine mitmele aadressile ja piiramatu arvu vahetehingute tegemine. See ei ole mitte vajalike päringute kogum vahetamiseks, kuid kui oled swap'i kogumisega alustanud, on raske peatuda.

Nüüd saavad Alice ja Bob täielikult välja minna. Näiteks automaatselt arvutada keskmist hinda, vahetades satoshis sekundi kohta, või lihtsalt otse ühendada turu tegija ja likviidsuse saaja.

Samm-sammult

• Müüja mõtleb välja saladuse ja annab ostjale salajase hash'i ning tehingu allkirja, kus osa vahenditest kantakse p2sh swap'a aadressile ja ülejäänud tagastatakse müüja aadressile.
• Kliendilt saadud allkiri, mis võimaldab tokenite ja tagasimaksete väljavõtmist saaja aadressile.
• Müüja paljastab saladuse
• Ajaloos kordub uus saladus, mille käigus lisanduvad swapile ja tagasimaksele ka varem ostetud ja müüjale makstud välja tõmbamine ostja aadressile.

Nüüd on meil juurdepääs kiirele p2p kaubandusele, peamine on jälgida aega ja tehing lõpetada enne tähtaega.

Kuid natuke muudates meie lepinguid, saame kinkida meie kanalitele surematuse, mis lihtsustab meie võrgu loomist.

Kuid sellest räägime järgmises osas.

Allikas: habr.com