Applicatio fluctuum dolor rationum: ex auctionibus programmatum bonus

Claustrum saepe solum cryptocurrencie coniungitur, sed areae applicationis technologiarum DLT multo latiora sunt. Una ex promissis locis ad usum impedimenti est dolor acer contractus qui ipso facto exsecutus est neque fiduciam requirit inter partes ingressas.

EQUITO - lingua ad captiosus contractus

Fluctus peculiarem linguam pro captis contractibus elaboravit – EQUITO. Eius completum documentum sita est hic. Et hic - articulus de hac re in Habr.

EQUITO contractus praedicatum est et redit "verum" vel "falsum" quasi output. Itaque res gesta vel in impedimento vel in rejicitur. Dolor contractus plene adimpletionem certorum condicionum praestat. Res gignere ex contractu in EQUITO nunc fieri non potest.

Hodie sunt duo genera fluctus callidi contractuum: dolor rationes et bona dolor. Dolor dolor rationem is a regular usor account, but a script is set for it that controls all transactions. Dolor rationem scriptoris spectare potest sicut hoc, pro exemplo:

match tx {
  case t: TransferTransaction | MassTransferTransaction => false
  case _ => true
}

tx transaction discursum est ut nos concedimus utendi exemplaris mechanismi congruens solum si transactionis translatio non sit. Exemplum matching in EO adhibetur ad reprimendam rationem transactionis. Omnes rationes exsistentes possunt discursum in callide propter scriptor transaction types.

Scriptum etiam variabiles declarare potest, uti "si-tunc-aliud" construere aliosque modos ad condiciones plene reprimendas. Curet ut contractus habeant plenam perfectionem et multiplicitatem (cost) facile praedicere antequam executio contractus incipiat, EO non continet ansas vel sententias salire.

Aliae fluctuum rationes praesentiam status, id est, statum rationis includunt. Infinita paria (clavem, valorem) scribere potes ad rationem civitatis utens notitia transactionum (DataTransaction). Haec indicia tum discursum esse possunt tum per CETERA API et directe in contractu acri.

Unaquaeque res continere potest ordinatam probationum, in quas subscriptio particeps, ID transactionis inquisitae, etc. iniri potest.

Operantes cum EO via hIC sino te videre conspectum contractus (si compilatum est), novas rationes creare et scripta pro eo ponere, ac per lineam mandati transactiones mittere.

Ad plenum cyclum, incluso rationem creando, callidum contractum in ea insertis et transactionibus mittendo, bibliothecam quoque uti potes ad mutuam cum reliquis API (exempli gratia C#, C, Java, JavaScript, Python, Rust, Elixir) . Incipere opus cum IDE, preme modo deprimendo Novam.

Facultates contractuum acri utendi latae sunt: ​​a vetita transactions ad inscriptiones quaedam ("nigrum album") ad dApps implicatas.

Nunc inspiciamus exempla specifica usus contractuum callidiorum in negotio: cum auctiones, cautiones, cautiones, et rationes fidem faciendi.

Auctions

Una ex condicionibus auctionis felicis perspicuitas est: participes confidere debent non posse manipulare iubet. Hoc fieri potest propter impedimentum, ubi notitia immutabilis de omnibus sponsionibus et tempus, quo facta sunt, omnibus participantibus praesto erunt.

In clausura Undarum iubet notari posse in auctione rationis status per DataTransactionis.

Potes etiam initium et finem tempus auctionis numerorum clausorum uti: frequentia generationis impedimentorum in undarum clausura fere aequalis est. 60 secundis.

1. Anglis ascendendo pretio auction

Participes auctionis Anglicae locum inter se certantes iubet. Quaelibet nova sponsio priora excedere debet. Auctio finit, cum amplius pretiis amplius non sunt quam ultimum bid. In hoc casu summa licitatio praedictam quantitatem praebere debet.

Est etiam auctionis optio, in qua venditor minimum pretium sors ponit, ac supremum pretium excedere debet. Secus sors remanet.

In hoc exemplo laboramus propter auctionis rationem specialiter creatam. Auctio duratio 3000 cuneos est, ac initium sortis 0,001 Undarum pretium est. Participem pretium ponere potest mittendo DataTransaction cum clave "pretium" et pretii sui iussi.

Pretium novi bidui debet esse altior quam pretia huius clavis currentis, et particeps debet habere saltem signa [new_bid + commissionis] suae rationis. Inscriptio inscriptionem licitae notari debet in agro "mittente" in DataTransactione, et ad stipitem currentem statutum debet intra tempus auctionis esse.

Si particeps in fine auctionis summum pretium posuit, potest mittere commutationemTransactionis ad solvendum pro sorte debita in statuto pretio et par monetae.

let startHeight = 384120
let finishHeight = startHeight + 3000
let startPrice = 100000
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
 
match tx {
case d : DataTransaction =>
  #проверяем, задана ли в стейте цена
  let currentPrice = if isDefined(getInteger(this, "price"))
 
                      #извлекаем цену из стейта
                      then extract(getInteger(this, "price"))
                      else startPrice
 
  #извлекаем цену из транзакции
  let newPrice = extract(getInteger(d.data, "price"))
  let priceIsBigger = newPrice > currentPrice
  let fee = 700000
  let hasMoney = wavesBalance(tx.sender) + fee >= newPrice
 
  #убеждаемся, что в текущей транзакции два поля и что отправитель совпадает с указанным в транзакции
  let correctFields = size(d.data) == 2 &&      
      d.sender == addressFromString(extract(getString(d.data,"sender")))
  startHeight <= height && height <= finishHeight && priceIsBigger && hasMoney && correctFields
case e : ExchangeTransaction =>
  let senderIsWinner = e.sender == addressFromString(extract(getString(this, "sender"))) #убеждаемся, что лот обменивает тот, кто его выиграл
  let correctAssetPair = e.sellOrder.assetPair.amountAsset == token && ! isDefined(e.sellOrder.assetPair.priceAsset)
  let correctAmount = e.amount == 1
  let correctPrice = e.price == extract(getInteger(this, "price"))
 
  height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice
case _ => false
}

2. auctio Batavica decrescentes pretium

In auctione Batavica multum pretio altius initio oblatum est quam quod emptor solvere vult. Pretium gradatim decrescit, donec unus e participibus convenit emere sortem pretio currenti.

In hoc exemplo iisdem constantibus ac in priori utimur, tum pretii gradus cum della decrescit. Rationis scriptor reprehendo num particeps quidem primus est bet collocare. Alioquin DataTransaction a impedimento non accipitur.

let startHeight = 384120
let finishHeight = startHeight + 3000
let startPrice = 100000000
let delta = 100
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
match tx {
case d : DataTransaction =>
  let currentPrice = startPrice - delta * (height - startHeight)
 
  #извлекаем из поступившей дата-транзакции поле "price"
  let newPrice = extract(getInteger(d.data, "price"))
 
  #убеждаемся, что в стейте текущего аккаунта не содержится поля "sender"
  let noBetsBefore = !isDefined(getInteger(this, "sender"))
  let fee = 700000
  let hasMoney = wavesBalance(tx.sender) + fee >= newPrice
 
  #убеждаемся, что в текущей транзакции только два поля
  let correctFields = size(d.data) == 2 && newPrice == currentPrice && d.sender == addressFromString(extract(getString(d.data, "sender")))
  startHeight <= height && height <= finishHeight && noBetsBefore && hasMoney && correctFields
case e : ExchangeTransaction =>
 
  #убеждаемся, что отправитель текущей транзакции указан в стейте аккаунта по ключу sender
  let senderIsWinner = e.sender == addressFromString(extract(getString(this, "sender")))
 
  #убеждаемся, что аmount ассета указан корректно, и что прайс-ассет - waves
  let correctAssetPair = e.sellOrder.assetPair.amountAsset == token && ! isDefined(e.sellOrder.assetPair.priceAsset)
  let correctAmount = e.amount == 1
  let correctPrice = e.price == extract(getInteger(this, "price"))
  height > finishHeight && senderIsWinner && correctAssetPair && correctAmount && correctPrice
case _ => false
}

3. Auction "omnia stipendium"

“Omnes stipendii” auctionis est in qua omnes participes reddere iubent, cuiuscumque sortis conciliat. Uterque participem novum licitum reddit, et participem qui maximum facit iussos conciliat sortem.

In nostro exemplo, quisque auctionis particeps locat pretium DataTransaction cum (clavis, pretii)* = ("victor", oratio), ("pretium", pretium). Talis DataTransactio nonnisi approbatur si hic particeps translationem cum subscriptione iam habet et pretium suum superioribus omnibus altior est. Auctio usque ad endHeight ventum est.

let startHeight = 1000
let endHeight = 2000
let this = extract(tx.sender)
let token = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
match tx {
 case d: DataTransaction =>
   #извлекаем из поступившей дата-транзакции поле "price"
   let newPrice = extract(getInteger(d.data, "price"))
 
   #извлекаем из пруфов транзакции публичный ключ аккаунта
   let pk = d.proofs[1]
   let address = addressFromPublicKey(pk)
 
   #извлекаем транзакцию доказательство из пруфов поступившей дата транзакции
   let proofTx = extract(transactionById(d.proofs[2]))
   
   height > startHeight && height < endHeight
   && size(d.data) == 2
   #убеждаемся, что адрес победителя, извлеченный из текущей транзакции, совпадает с адресом, извлеченным из пруфов
   && extract(getString(d.data, "winner")) == toBase58String(address.bytes)
   && newPrice > extract(getInteger(this, "price"))
   #проверяем, что транзакция подписана
   && sigVerify(d.bodyBytes, d.proofs[0], d.proofs[1])
   #проверяем корректность транзакции, указанной в пруфах
   && match proofTx {
     case tr : TransferTransaction =>
       tr.sender == address &&
       tr.amount == newPrice
     case _ => false
   }
 case t: TransferTransaction =>
 sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
 || (
   height > endHeight
   && extract(getString(this, "winner")) == toBase58String((addressFromRecipient(t.recipient)).bytes)
   && t.assetId == token
   && t.amount == 1
 )
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

Cautionum / Crowdfunding

Consideremus condicionem qua vos postulo ut res usorum praestandae contra damna pecuniaria. Exempli causa, cautionem usoris cupit, si tessera detracta est, mercedem plenam pro his signis recipere poterit et rationabilem cautionum quantitatem solvere voluerit.

Ad hoc efficiendum "signa assecurationis" edenda est. Inde scriptum in rationem consilii inauguratum est, solum illas ExchangeTransactiones quae certas condiciones exsecutioni mandare conveniant.

Duplex impendio ne fiat, postulare debes utentis ut rationem mitteret DataTransaction ad rationem in antecessum cum (clavis, pretii) = (emptioTransactionId, sellOrderId) et interdicere DataTransactiones mittere cum clave quae iam adhibita est.

Ideo probationes usoris continere debent transactionem ID emptionis cautionis tesserae. Coniugatio monetae eadem esse debet quae in transactione emptione. Sumptus etiam aequari debet ei qui tempore emptionis praefixo, minus pretio assecurationis.

Intellegitur postea assecurationis rationes emere signa assecurationis ab utentis pretio non minore eo quo emerat: assecurationis ratio permutationem efficit, ordinem utentis subscribit (si recte gesta res peracta est), a. cautionum rationem subscribit secundi ordinis et totius negotii et ad impedimentum emittit.

Nulla emptione facta, usura potest commutationem Transactionis creare secundum normas in scripto descriptas et transactionem ad impedimentum mittere. Hoc modo reddere potest utens pecuniam in signis emendandis emptam.

let insuranceToken = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let freezePeriod = 150000
let insurancePrice = 10000
match tx {
 
 #убеждаемся, что, если поступила дата-транзакция, то у нее ровно одно поле и в стейте еще нет такого ключа
 case d : DataTransaction => size(d.data) == 1 && !isDefined(getBinary(this, d.data[0].key))
 case e : ExchangeTransaction =>
 
   #если у транзакции нет седьмого пруфа, проверяем корректность подписи
   if !isDefined(e.proofs[7]) then
     sigVerify(e.bodyBytes, e.proofs[0], e.senderPublicKey)
   else
     #если у транзакции есть седьмой пруф, извлекаем из него транзакцию и узнаём её высоту
     let purchaseTx = transactionById(e.proofs[7])
     let purchaseTxHeight = extract(transactionHeightById(e.proofs[7]))
    
     #обрабатываем транзакцию из пруфа
     match purchaseTx {
       case purchase : ExchangeTransaction =>
         let correctSender = purchase.sender == e.sellOrder.sender
         let correctAssetPair = e.sellOrder.assetPair.amountAsset == insuranceToken &&
                                purchase.sellOrder.assetPair.amountAsset == insuranceToken &&
                                e.sellOrder.assetPair.priceAsset == purchase.sellOrder.assetPair.priceAsset
         let correctPrice = e.price == purchase.price - insurancePrice && e.amount == purchase.amount
         let correctHeight = height > purchaseTxHeight + freezePeriod
 
         #убеждаемся, что в транзакции-пруфе указан верный ID текущей транзакции
         let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == e.sellOrder.id
         correctSender && correctAssetPair && correctPrice && correctHeight && correctProof
     case _ => false
   }
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

Causa assecurationis magni pretii fieri potest, exempli gratia, vetare eius translationem in tertias partes facere.

Quae res etiam ad signa frequentia perficienda potest, quae dominis redduntur, si moles summa non fuerit collecta.

Transactio tributa

Captiosus contractus etiam applicabilis est in casibus ubi opus est in singulis negotiis tributum colligere cum pluribus generibus bonorum. Hoc fieri potest per novam res cum installed patrocinio dolor enim transactions cum bonorum:

1. FeeCoin edimus, quod certo pretio usoribus mittetur: 0,01 FLUCTU = 0,001 FeeCoin.

2. Pone patrocinium pro FeeCoin et commutationem rate: 0,001 FLUCTU = 0,001 FeeCoin.

Dolor dignissim 3. pone hoc scriptum est:

let feeAssetId = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let taxDivisor = 10
 
match tx {
  case t: TransferTransaction =>
    t.feeAssetId == feeAssetId && t.fee == t.amount / taxDivisor
  case e: ExchangeTransaction | MassTransferTransaction => false
  case _ => true
}

Quotiens quis N vafras res transfert, tibi FeeCoin in quantitate N/taxDivisoris dabunt (quod a te emi X *N/taxDivisor FLUCTUS), et fossorem N/taxDivisorem Undarum dabis. Quam ob rem lucrum tuum (tributum) erit 10*N / taxDivisor UNDA.

Etiam taxationem praestare potes utens acri dignissim scripto et MassTransferTransactione:

let taxDivisor = 10
 
match tx {
  case t : MassTransferTransaction =>
    let twoTransfers = size(t.transfers) == 2
    let issuerIsRecipient = t.transfers[0].recipient == addressFromString("3MgkTXzD72BTfYpd9UW42wdqTVg8HqnXEfc")
    let taxesPaid = t.transfers[0].amount >= t.transfers[1].amount / taxDivisor
    twoTransfers && issuerIsRecipient && taxesPaid
  case _ => false
}

Cashback ac fidem programs

Cashback est genus fidelitatis programma in quo emptor redit partem pecuniae in productum vel servitium impendi.

Cum hanc causam exsequendam ratione acri utendo, probationes eodem modo reprimendas oportet ac in casu assecurationis fecimus. Ut ne duplex impendio, usor debet mittere DataTransaction cum (clavis, pretii) = (emptioTransactionId, cashbackTransactionId) antequam cashback accipiatur.

Bannum etiam apponere debemus clavium existentium utendo DataTransactione. cashbackDivisor - unitas divisa per participes cashback. Illae. si cashback participes sunt 0.1, deinde cashbackDivisor 1/ 0.1 = 10.

let cashbackToken = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
 
#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
let cashbackDivisor = 10
match tx {
 
 #убеждаемся, что, если поступила дата-транзакция, то у нее ровно одно поле и в стейте еще нет такого ключа
 case d : DataTransaction => size(d.data) == 1 && !isDefined(getBinary(this, d.data[0].key))
 case e : TransferTransaction =>
 
   #если у транзакции нет седьмого пруфа, проверяем корректность подписи
   if !isDefined(e.proofs[7]) then
     sigVerify(e.bodyBytes, e.proofs[0], e.senderPublicKey)
   else
 
     #если у транзакции есть седьмой пруф, извлекаем из него транзакцию и узнаём её высоту
     let purchaseTx = transactionById(e.proofs[7])
     let purchaseTxHeight = extract(transactionHeightById(e.proofs[7]))
    
     #обрабатываем транзакцию из пруфа
     match purchaseTx {
       case purchase : TransferTransaction =>
         let correctSender = purchase.sender == e.sender
         let correctAsset = e.assetId == cashbackToken
         let correctPrice = e.amount == purchase.amount / cashbackDivisor
 
         #убеждаемся, что в транзакции-пруфе указан верный ID текущей транзакции
         let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == e.id
         correctSender && correctAsset && correctPrice && correctProof
     case _ => false
   }
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

PERMUTO atomi

PERMUTO atomi permittit utentes ad res commutandas sine auxilio commutationis. Cum PERMUTO atomico, ambo participes transactionis eam intra certum tempus confirmare debent.

Si saltem unus ex participibus intra tempus negotii gerendi rectam confirmationem non praebet, transactio aboletur et commutatio non occurrit.

In exemplo nostro sequenti scripto rationi callidi utemur:

let Bob = Address(base58'3NBVqYXrapgJP9atQccdBPAgJPwHDKkh6A8')
let Alice = Address(base58'3PNX6XwMeEXaaP1rf5MCk8weYeF7z2vJZBg')
 
let beforeHeight = 100000
 
let secret = base58'BN6RTYGWcwektQfSFzH8raYo9awaLgQ7pLyWLQY4S4F5'
match tx {
  case t: TransferTransaction =>
    let txToBob = t.recipient == Bob && sha256(t.proofs[0]) == secret && 20 + beforeHeight >= height
    let backToAliceAfterHeight = height >= 21 + beforeHeight && t.recipient == Alice
    txToBob || backToAliceAfterHeight
  case _ => false
}

In proximo articulo videbimus usum rationum captiosarum in instrumentis nummariis sicut optiones, futura et rogationes.

Source: www.habr.com