Helyi Cserekereskedelmi Rendszer Az Ergo Alapján

A helyi cserekereskedelmi rendszer (LETS) egy helyi kölcsönös hitel társulás, amelynek tagjai közösen
hozhatnak létre közös hitelpénzt, a rendszerben végzett összes tranzakciót egy közös főkönyvbe írják.
Például tegyük fel, hogy Alice, akinek nulla egyenlege van, hajlandó vásárolni egy liter nyers tejet Bobtól.
Először megállapodnak egy árban, például tegyük fel, hogy az ár körülbelül 2 Euro (mivel Alice és Bob
Írországban élnek). Miután a tranzakciót beírták a főkönyvbe, Alice egyenlege -2 (mínusz
kettő) Euro lesz, Bob egyenlege pedig 2 Euro. Ezután Bob elköltheti a 2 Euroját, például
házi sörre Charlie-tól. Gyakran az ilyen rendszerek korlátozásokat szabnak a negatív egyenlegekre, és néha
még a pozitívokra is, hogy elősegítsék a közösségen belüli cserét.

Történelmileg az ilyen rendszerek válságidőszakokban váltak népszerűvé. Az első rendszert Michael Linton alapította
a kanadai városban, amely a depresszióval küzdött 1981-ben. A helyi cserekereskedelmi rendszerek rendkívül népszerűek voltak
a 1998-2002-es argentin nagy depresszió alatt. A legtöbb LETS csoport 50 és 250 tag között mozog, papíralapú hiteljegyekkel és
főkönyvvel, amelyet egy magbizottság tart fenn. Azonban a papíralapú LETS valuták néhány problémát mutattak, mint például
hamisítványok, a rendszerkezelők lehetséges rosszindulatú viselkedése, és így tovább. Ezért a blokklánc-alapú LETS
túlmutathat a régi rendszereken. További információk a LETS-ről találhatók a
"A Pénz Ökológiája" könyvben (Richard Douthwaite) és
a Wikipédián.

Ebben a cikkben bemutatjuk, hogyan lehet a LETS-t az Ergo alapjára építeni. Tudomásunk szerint ez az
első ilyen közösségi valuta megvalósítása blokklánc alapú rendszeren.
Referencia megvalósításunk
simple és két szerződésből áll, nevezetesen egy menedzsment szerződésből és egy csere szerződésből.
Átugorjuk az Ergo előkészületeit, ezért kérjük, olvassa el
a ICO cikket és
az ErgoScript oktatóanyagokat (alap és
haladó) kezdőknek.
Mindazonáltal be fogunk vezetni néhány új kifejezést a következő mondatokban.
Ha egy tokent egyenlő mennyiségben bocsátanak ki, azt singleton tokennek nevezzük. Hasonlóképpen,
a dobozt, amely tartalmazza a singleton tokent, singleton doboznak nevezzük.

A menedzsment szerződés egy singleton dobozt irányít, amely a LETS rendszer tagjait tartalmazza.
A szerződés lehetővé teszi új tagok hozzáadását egy tranzakciónként egy tag ütemezésével. A doboz
nem tárolja a tagokat, hanem csak egy kis összefoglalót az azonosított adatstruktúráról, amely a
tagok könyvtárán alapul. Egy tag egy singleton tokenhez kapcsolódik, amelyet egy tranzakció bocsátott ki, amely
hozzáadja a tagot a könyvtárhoz. A tranzakció létrehoz egy új tag dobozt, amely tartalmazza
a tag singleton tokenjét. A tag doboza védve van a csere szerződés által. Ezenkívül az újonnan
létrehozott tag doboz kezdeti egyenlege a R4 regiszterbe van beírva, és az egyenleg
egyenlő nullával a példánkban. Az új tag létrehozására irányuló tranzakciónak bizonyítékot kell szolgáltatnia a
tárgyalás helyességéről.

A menedzsment szerződés dobozát általában egy bizottság irányítja, és a bizottság idővel fejlődhet. Ennek támogatására
a bizottsági logikát a R5 regiszterben tároljuk.
Például tegyük fel, hogy egy új bizottsági tagot adtak hozzá egy új LETS taggal együtt,
a bemeneti menedzsment szerződés doboz 2-ből 3 aláírást igényel, és a kimeneti doboz 3-ból 4 aláírást igényel.
Ebben az esetben az R5 regiszter tartalma a bemeneti és a kimeneti dobozban eltérne.

Az ErgoScript menedzsment szerződés kódja megjegyzésekkel együtt az alábbiakban található. Kérjük, vegye figyelembe, hogy
"userContractHash" a csere szerződés hash-éről szól.

    val selfOut = OUTPUTS(0)
 
    // Menedzsment szkript
    val managementScript = selfOut.R5[SigmaProp].get
 
    // A menedzsment szkript sablon megismétli önmagát, és a menedzsment szkript teljesül
    val scriptCorrect = (selfOut.propositionBytes == SELF.propositionBytes) && managementScript
 
    // Egy költési tranzakció dobozokat hoz létre a könyvtárhoz, felhasználóhoz, díjhoz.
    val outsSizeCorrect = OUTPUTS.size == 3
 
    // Ellenőrzi, hogy a menedzsment címke token megismétli önmagát
    val outTokenCorrect = (selfOut.tokens.size == 1) && (selfOut.tokens(0)._1 == letsToken)
 
    // Ellenőrzi, hogy új token került kibocsátásra, és annak mennyisége helyes
    // OUTPUTS(0) tokenek már ellenőrizve az outtokenCorrect által
    val issuedTokenId = INPUTS(0).id
    val userOut = OUTPUTS(1)
    val correctTokenAmounts =
      (userOut.tokens.size == 1 &&
        userOut.tokens(0)._1 == issuedTokenId &&
        userOut.tokens(0)._2 == 1 &&
        OUTPUTS(2).tokens.size == 0 &&
        outTokenCorrect)
 
    // Ellenőrzi, hogy az új felhasználó nulla egyenleggel jött létre
    val zeroUserBalance  = userOut.R4[Long].get == 0
 
    val properUserScript = blake2b256(userOut.propositionBytes) == userContractHash
 
    // Ellenőrzi, hogy az új token azonosítója hozzá lett adva a könyvtárhoz
    val selfTree = SELF.R4[AvlTree].get
    val toAdd: Coll[(Coll[Byte], Coll[Byte])] = Coll((issuedTokenId, Coll[Byte]()))
    val proof = getVar[Coll[Byte]](1).get
    val modifiedTree = selfTree.insert(toAdd, proof).get
    val expectedTree = selfOut.R4[AvlTree].get
    val treeCorrect = modifiedTree == expectedTree
 
    correctTokenAmounts && scriptCorrect && treeCorrect && zeroUserBalance && properUserScript       
    correctTokenAmounts && scriptCorrect && treeCorrect && zeroUserBalance && properUserScript correctTokenAmounts && scriptCorrect && treeCorrect && zeroUserBalance && properUserScript      

A csere szerződés szkriptje meglehetősen egyszerű, és az alábbiakban található, megjegyzésekkel, amelyek leírják a logikáját. A
szerződésben feltételezzük, hogy egy költési tranzakció egy csere szerződés dobozhoz legalább két bemenetet kap,
a két első bemenetet a csere szerződés szkriptje védi, és LETS tag tokeneket kell tartalmaznia. Annak ellenőrzésére,
hogy a bemeneti singleton tag tokenek valóban a LETS rendszerhez tartoznak, egy költési tranzakció a menedzsment
szerződés dobozát adja meg első olvasásra, és bizonyítékot kell szolgáltatnia arra, hogy a tag tokenek valóban a
könyvtárhoz tartoznak, amelyet a menedzsment szerződés doboz R4 regisztere hitelesít. A "letsToken" a szkriptben a
menedzsment doboz singleton tokenjéről szól.

  // Minimális egyenleg, amely megengedett a LETS kereskedő számára
  val minBalance = -20000

  val lookupProof = getVar[Coll[Byte]](1).get

  // Az olvasásra szánt doboz, amely tartalmazza a LETS tagok könyvtárát
  val treeHolderBox = CONTEXT.dataInputs(0)
  val properLetsToken = treeHolderBox.tokens(0)._1 == letsToken
  val membersTree = treeHolderBox.R4[AvlTree].get

  // Egy költési tranzakció két LETS tag dobozát veszi, akik hajlandóak üzletet kötni,
  // és módosított egyenlegű dobozokat ad vissza.
  val participant0 = INPUTS(0)
  val participant1 = INPUTS(1)
  val participantOut0 = OUTPUTS(0)
  val participantOut1 = OUTPUTS(1)

  // Ellenőrzi, hogy a tagok valóban a LETS-hez tartoznak-e
  val token0 = participant0.tokens(0)._1
  val token1 = participant1.tokens(0)._1
  val memberTokens = Coll(token0, token1)
  val membersExist = membersTree.getMany(memberTokens, lookupProof).forall({ (o: Option[Coll[Byte]]) => o.isDefined })

  // Ellenőrzi, hogy a LETS tag egyenlegének változása az üzlet során helyes-e
  val initialBalance0 = participant0.R4[Long].get
  val initialBalance1 = participant1.R4[Long].get
  val finishBalance0  = participantOut0.R4[Long].get
  val finishBalance1  = participantOut1.R4[Long].get
  val diff0 = finishBalance0 - initialBalance0
  val diff1 = finishBalance1 - initialBalance1
  val diffCorrect = diff0 == -diff1
  val balancesCorrect = (finishBalance0 > minBalance) && (finishBalance1 > minBalance) && diffCorrect

  // Ellenőrzi, hogy a tag dobozok megőrzik a szkriptjeiket.
  // todo: optimalizálás itt lehetséges
  val script0Saved = participantOut0.propositionBytes == participant0.propositionBytes
  val script1Saved = participantOut1.propositionBytes == participant1.propositionBytes
  val scriptsSaved = script0Saved && script1Saved

  // Tag-specifikus dobozvédelem
  val selfPubKey = SELF.R5[SigmaProp].get

  selfPubKey && properLetsToken && membersExist && diffCorrect && scriptsSaved

Ne feledje, hogy mindkét szerződés sokféleképpen módosítható, hogy új rendszereket hozzon létre különböző tulajdonságokkal. Remélhetőleg
valamikor ez a cikk folytatódik!