Sistem Perdagangan Pertukaran Lokal Di Atas Ergo

Sistem perdagangan pertukaran lokal (LETS) adalah asosiasi kredit mutual lokal yang memungkinkan anggotanya untuk menciptakan uang kredit bersama secara individu, dengan semua transaksi dalam sistem dicatat dalam buku besar bersama. Sebagai contoh, anggaplah Alice dengan saldo nol bersedia membeli satu liter susu mentah dari Bob. Pertama, mereka sepakat pada harga, misalnya, anggaplah harga sekitar 2 Euro (karena Alice dan Bob tinggal di Irlandia). Setelah transaksi dicatat dalam buku besar, saldo Alice menjadi -2 (minus dua) Euro, dan saldo Bob menjadi 2 Euro. Kemudian Bob dapat menghabiskan 2 Euro-nya, misalnya, untuk bir buatan rumah dari Charlie. Seringkali, sistem semacam itu memberlakukan batasan pada saldo negatif, dan kadang-kadang bahkan pada saldo positif, untuk mendorong pertukaran dalam komunitas.

Secara historis, sistem semacam itu menjadi populer selama masa krisis. Sistem pertama didirikan oleh Michael Linton di sebuah kota Kanada yang terjebak dalam depresi pada tahun 1981. Sistem perdagangan pertukaran lokal sangat populer selama Depresi Besar Argentina 1998-2002. Sebagian besar kelompok LETS berkisar antara 50 hingga 250 anggota, dengan catatan kredit berbasis kertas dan buku besar yang dikelola oleh komite inti. Namun, mata uang LETS berbasis kertas telah menunjukkan beberapa masalah, seperti uang palsu, kemungkinan perilaku nakal dari pengelola sistem, dan sebagainya. Oleh karena itu, LETS berbasis blockchain bisa lebih unggul dibandingkan sistem lama. Informasi lebih lanjut tentang LETS dapat ditemukan di
"The Ecology of Money" book (oleh Richard Douthwaite) dan
Wikipedia.

Dalam artikel ini kami menunjukkan bagaimana LETS dapat diimplementasikan di atas Ergo. Sejauh yang kami ketahui, ini adalah
implementasi pertama dari jenis mata uang komunitas semacam ini di atas blockchain.
Implementasi referensi kami
sederhana dan terdiri dari dua kontrak, yaitu, kontrak manajemen dan kontrak pertukaran.
Kami melewatkan prasyarat Ergo, jadi silakan baca
artikel ICO dan
tutorial ErgoScript (dasar dan
lanjutan) untuk pemula.
Namun, kami akan memperkenalkan beberapa istilah baru dalam kalimat berikut.
Jika sebuah token diterbitkan dengan jumlah sama dengan satu, kami menyebutnya token singleton. Demikian pula,
satu kotak yang berisi token singleton disebut kotak singleton.

Kontrak manajemen mengontrol kotak singleton yang menyimpan anggota sistem LETS.
Kontrak ini memungkinkan penambahan anggota baru dengan kecepatan satu anggota per satu transaksi. Kotak
ini tidak menyimpan anggota, tetapi hanya ringkasan kecil dari struktur data terautentikasi yang dibangun di atas
direktori anggota. Seorang anggota terkait dengan token singleton yang diterbitkan dalam transaksi yang
menambahkan anggota ke direktori. Transaksi tersebut menciptakan kotak anggota baru yang berisi
token singleton anggota. Kotak anggota dilindungi oleh kontrak pertukaran. Selain itu, kotak anggota yang baru
dibuat memiliki saldo awal yang dicatat dalam register R4, dan saldo tersebut
equal dengan nol dalam contoh kami. Transaksi yang menciptakan anggota baru harus memberikan bukti kebenaran untuk
deklarasi direktori.

Kotak kontrak manajemen biasanya dikendalikan oleh sebuah komite, dan komite tersebut dapat berkembang seiring waktu. Untuk mendukung
itu, kami mengizinkan logika komite untuk berada di register R5.
Sebagai contoh, anggaplah bahwa anggota komite baru telah ditambahkan bersamaan dengan anggota LETS baru,
kotak kontrak manajemen input memerlukan 2-dari-3 tanda tangan, dan kotak output memerlukan 3-dari-4 tanda tangan.
Dalam hal ini, isi register R5 di kotak input dan output akan berbeda.

Kode kontrak manajemen dalam ErgoScript dengan komentar disediakan di bawah ini. Harap dicatat bahwa
"userContractHash" adalah tentang hash kontrak pertukaran.

    val selfOut = OUTPUTS(0)
 
    // Skrip manajemen
    val managementScript = selfOut.R5[SigmaProp].get
 
    // Template skrip manajemen mereplikasi diri, dan skrip manajemen terpenuhi
    val scriptCorrect = (selfOut.propositionBytes == SELF.propositionBytes) && managementScript
 
    // Transaksi pengeluaran menciptakan kotak untuk direktori, pengguna, biaya.
    val outsSizeCorrect = OUTPUTS.size == 3
 
    // Memeriksa bahwa token label manajemen mereplikasi diri
    val outTokenCorrect = (selfOut.tokens.size == 1) && (selfOut.tokens(0)._1 == letsToken)
 
    // Memeriksa bahwa token baru diterbitkan, dan jumlahnya benar
    // OUTPUTS(0) token sudah diperiksa melalui outtokenCorrect
    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)
 
    // Memeriksa bahwa pengguna baru telah dibuat dengan saldo nol
    val zeroUserBalance  = userOut.R4[Long].get == 0
 
    val properUserScript = blake2b256(userOut.propositionBytes) == userContractHash
 
    // Memeriksa bahwa pengenal token baru telah ditambahkan ke direktori
    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      

Skrip kontrak pertukaran cukup sederhana dan disediakan di bawah ini bersama dengan komentar yang menjelaskan logikanya. Dalam
kontrak, diasumsikan bahwa transaksi pengeluaran untuk kotak kontrak pertukaran menerima setidaknya dua input,
dan dua input pertama harus dilindungi oleh skrip kontrak pertukaran dan berisi token anggota LETS. Untuk memeriksa
bahwa token anggota singleton dalam input memang milik sistem LETS, transaksi pengeluaran menyediakan kotak kontrak manajemen
sebagai input data baca-saja pertama, dan juga harus memberikan bukti bahwa token anggota memang milik
direktori yang terautentikasi melalui register R4 dari kotak kontrak manajemen. "letsToken" dalam skrip adalah tentang
token singleton dari kotak manajemen.

  // Saldo minimal yang diizinkan untuk pedagang LETS
  val minBalance = -20000

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

  // Kotak baca-saja yang berisi direktori anggota LETS
  val treeHolderBox = CONTEXT.dataInputs(0)
  val properLetsToken = treeHolderBox.tokens(0)._1 == letsToken
  val membersTree = treeHolderBox.R4[AvlTree].get

  // Transaksi pengeluaran mengambil dua kotak anggota LETS yang bersedia melakukan kesepakatan,
  // dan mengembalikan kotak dengan saldo yang dimodifikasi.
  val participant0 = INPUTS(0)
  val participant1 = INPUTS(1)
  val participantOut0 = OUTPUTS(0)
  val participantOut1 = OUTPUTS(1)

  //Periksa bahwa anggota memang milik LETS
  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 })

  // Periksa bahwa perubahan saldo anggota LETS selama kesepakatan adalah benar
  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

  // Periksa bahwa kotak anggota menyimpan skrip mereka.
  // todo: optimasi dapat dilakukan di sini
  val script0Saved = participantOut0.propositionBytes == participant0.propositionBytes
  val script1Saved = participantOut1.propositionBytes == participant1.propositionBytes
  val scriptsSaved = script0Saved && script1Saved

  // Perlindungan kotak spesifik anggota
  val selfPubKey = SELF.R5[SigmaProp].get

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

Perhatikan bahwa kedua kontrak dapat dimodifikasi dengan banyak cara untuk mendapatkan sistem baru dengan properti yang berbeda. Jadi semoga
suatu hari artikel ini akan dilanjutkan!