Gu tric bidh Blockchain ceangailte ri cryptocurrencies a-mhàin, ach tha raointean cleachdadh teicneòlas DLT mòran nas fharsainge. Is e aon de na raointean as gealltanach airson cleachdadh blockchain cùmhnant snasail a thèid a chuir gu bàs gu fèin-ghluasadach agus nach eil feumach air earbsa eadar na pàrtaidhean a rinn e.
RIDE - cànan airson cùmhnantan snasail
Tha Waves air cànan sònraichte a leasachadh airson cùmhnantan snasail - RIDE. Tha na sgrìobhainnean iomlan aige suidhichte . Agus an seo - air Habr.
Tha an cùmhnant RIDE na ro-innse agus a’ tilleadh “fìor” no “meallta” mar thoradh. Mar sin, tha an gnothach air a chlàradh anns an blockchain no air a dhiùltadh. Tha an cùmhnant snasail a’ làn ghealladh gun tèid cumhachan sònraichte a choileanadh. Chan eil e comasach an-dràsta gnothaichean a ghineadh bho chùmhnant ann an RIDE.
An-diugh tha dà sheòrsa de chùmhnantan smart Waves ann: cunntasan snasail agus so-mhaoin snasail. Is e cunntas cleachdaiche cunbhalach a th’ ann an cunntas snasail, ach tha sgriobt air a shuidheachadh air a shon a bhios a’ cumail smachd air a h-uile gnothach. Is dòcha gum bi sgriobt cunntais snasail a’ coimhead mar seo, mar eisimpleir:
match tx {
case t: TransferTransaction | MassTransferTransaction => false
case _ => true
}
tx na ghnothach air a ghiullachd a leigeas leinn an uidheamachd maidsidh pàtrain a chleachdadh a-mhàin mura h-e gnothach gluasaid a th’ ann. Bithear a’ cleachdadh maidseadh pàtrain ann an RIDE gus sùil a thoirt air an t-seòrsa malairt. Faodar a h-uile cunntas a tha ann mu thràth a phròiseasadh ann an sgriobt a’ chunntais ghlic .
Faodaidh an sgriobt cuideachd caochladairean ainmeachadh, togalaichean “ma tha eile” a chleachdadh agus dòighean eile airson làn sgrùdadh a dhèanamh air suidheachaidhean. Gus dèanamh cinnteach gu bheil iomlanachd agus iom-fhillteachd (cosgais) dearbhte aig cùmhnantan a tha furasta a ro-innse mus tòisich coileanadh cùmhnant, chan eil lùban no aithrisean leum ann an RIDE.
Tha feartan eile de chunntasan Waves a’ toirt a-steach làthaireachd “stàit,” is e sin, staid a’ chunntais. Faodaidh tu àireamh neo-chrìochnach de chàraidean (iuchair, luach) a sgrìobhadh gu staid a’ chunntais a’ cleachdadh gnothaichean dàta (DataTransaction). Faodar am fiosrachadh seo a phròiseasadh an dà chuid tron REST API agus gu dìreach sa chùmhnant snasail.
Faodaidh grunn dhearbhaidhean a bhith anns gach gnothach, anns am faodar ainm-sgrìobhte a’ chom-pàirtiche, ID a’ ghnothaich a tha a dhìth, msaa a chuir a-steach.
Ag obair le RIDE tro a’ leigeil leat an sealladh cruinnichte den chùmhnant fhaicinn (ma tha e air a chur ri chèile), cunntasan ùra a chruthachadh agus sgriobtaichean a shuidheachadh air a shon, a bharrachd air gnothaichean a chuir tron loidhne-àithne.
Airson làn chearcall, a’ toirt a-steach cruthachadh cunntas, a’ stàladh cùmhnant snasail air agus a’ cur ghnothaichean air falbh, faodaidh tu cuideachd leabharlann a chleachdadh airson eadar-obrachadh leis an REST API (mar eisimpleir, C #, C, Java, JavaScript, Python, Rust, Elixir) . Gus tòiseachadh ag obair leis an IDE, dìreach cliog air a’ phutan ÙR.
Tha na cothroman airson cùmhnantan snasail a chleachdadh farsaing: bho bhith a’ toirmeasg gnothaichean gu seòlaidhean sònraichte (“liosta dhubh”) gu dApps iom-fhillte.
A-nis leig dhuinn sùil a thoirt air eisimpleirean sònraichte de chleachdadh cùmhnantan snasail ann an gnìomhachas: nuair a bhios tu a’ dèanamh ropan, àrachas, agus a’ cruthachadh phrògraman dìlseachd.
Ropan
Is e aon de na cumhaichean airson rop soirbheachail follaiseachd: feumaidh com-pàirtichean a bhith misneachail gu bheil e do-dhèanta tagraidhean a làimhseachadh. Faodar seo a choileanadh le taing don blockchain, far am bi dàta so-ruigsinneach mu na geall agus an àm anns an deach an dèanamh rim faighinn leis a h-uile com-pàirtiche.
Air blockchain Waves, faodar tagraidhean a chlàradh anns an stàit cunntas rop tro DataTransaction.
Faodaidh tu cuideachd àm tòiseachaidh is crìochnachaidh an rop a shuidheachadh le bhith a’ cleachdadh àireamhan bloca: tha tricead gineadh blocaichean ann an blockchain Waves timcheall air co-ionann ri 60 diog.
1. Beurla dìreadh rup prìs
Bidh com-pàirtichean ann an rop Sasannach a’ cur thagraidhean ann am farpais ri chèile. Feumaidh gach geall ùr a dhol thairis air an fhear roimhe. Thig an rop gu crìch nuair nach eil barrachd luchd-tairgse ann airson a dhol thairis air an tairgse mu dheireadh. Anns a 'chùis seo, feumaidh an neach-tairgse as àirde an t-suim ainmichte a thoirt seachad.
Tha roghainn rop ann cuideachd anns am bi an neach-reic a’ suidheachadh prìs as ìsle airson a’ chrannchur, agus feumaidh a’ phrìs mu dheireadh a dhol thairis air. Rud eile, tha an crannchur fhathast gun reic.
San eisimpleir seo, tha sinn ag obair le cunntas a chaidh a chruthachadh gu sònraichte airson an rop. Is e fad an rop 3000 blocaichean, agus is e prìs tòiseachaidh a’ chrannchur 0,001 WAVES. Faodaidh com-pàirtiche tairgse a chuir a-steach le bhith a’ cur DataTransaction leis a’ phrìomh “phrìs” agus luach an tagraidh aca.
Feumaidh prìs an tagraidh ùr a bhith nas àirde na a’ phrìs làithreach airson an iuchair seo, agus feumaidh co-dhiù comharran [new_bid + commission] a bhith aig a’ chom-pàirtiche sa chunntas aige. Feumaidh seòladh an neach-tairgse a bhith air a chlàradh anns an raon “seoladair” anns an DataTransaction, agus feumaidh àirde a’ bhloc tagraidh a bhith taobh a-staigh ùine an rop.
Ma tha an com-pàirtiche air a’ phrìs as àirde a shuidheachadh aig deireadh an rop, faodaidh e ExchangeTransaction a chuir a-steach gus pàigheadh airson a ’chrannchur co-fhreagarrach aig a’ phrìs ainmichte agus paidhir airgead.
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. Dutch rup de phrìsean a lùghdachadh
Ann an rop Duitseach, tha tòrr ga thabhann an toiseach aig prìs nas àirde na na tha an ceannaiche deònach pàigheadh. Bidh a’ phrìs a’ dol sìos ceum air cheum gus an aontaich aon de na com-pàirtichean an crannchur a cheannach aig a’ phrìs làithreach.
Anns an eisimpleir seo bidh sinn a’ cleachdadh na h-aon chuibhrichean ris an fhear roimhe, a bharrachd air a’ cheum prìse nuair a bhios delta a’ dol sìos. Bidh an sgriobt cunntais a’ sgrùdadh an e an com-pàirtiche gu dearbh a’ chiad fhear a chuir geall. Rud eile, cha ghabh an blockchain ris an DataTransaction.
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. Rop “uile-phàigh”
Tha “All-pay” na rop anns am bi a h-uile com-pàirtiche a’ pàigheadh an tairgse, ge bith cò a bhuannaicheas an crannchur. Bidh gach com-pàirtiche ùr a’ pàigheadh tairgse, agus bidh an com-pàirtiche a nì an tairgse as àirde a’ buannachadh a’ chrannchur.
Anns an eisimpleir againn, bidh gach com-pàirtiche rop a’ cur tairgse tro DataTransaction le (iuchair, luach) * = (“buannaiche”, seòladh), (“prìs”, prìs). Chan eil an leithid de DataTransaction air aontachadh ach ma tha TransferTransaction aig a’ chom-pàirtiche seo mu thràth leis an ainm-sgrìobhte aige agus gu bheil an tagradh aige nas àirde na a h-uile gin roimhe. Bidh an rop a’ leantainn gus an ruigear endHeight.
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)
}Àrachas / Sluagh-mhaoineachadh
Beachdaichidh sinn air suidheachadh far am feum thu àrachas a thoirt do mhaoin luchd-cleachdaidh an aghaidh call ionmhasail. Mar eisimpleir, tha neach-cleachdaidh ag iarraidh barantas ma bhios tòcan a 'lùghdachadh, gum faigh e air ais an t-suim iomlan a chaidh a phàigheadh airson na comharran sin, agus tha e deònach àrachas reusanta a phàigheadh.
Gus seo a bhuileachadh, feumar “tokens àrachais” a chuir a-mach. An uairsin tha sgriobt air a chuir a-steach air cunntas neach-seilbh a ’phoileasaidh, a’ ceadachadh dìreach na ExchangeTransactions sin a choinnicheas ri cumhachan sònraichte a chuir gu bàs.
Gus casg a chuir air caitheamh dùbailte, feumaidh tu iarraidh air an neach-cleachdaidh DataTransaction a chuir gu cunntas neach-seilbh a’ phoileasaidh ro-làimh le (iuchair, luach) = (purchaseTransactionId, sellOrderId) agus casg a chuir air DataTransaction a chuir le iuchair a chaidh a chleachdadh mu thràth.
Mar sin, feumaidh dearbhaidhean an neach-cleachdaidh a bhith ann an ID malairt ceannach tòcan àrachais. Feumaidh am paidhir airgead a bhith co-ionann ris a’ ghnothach ceannach. Feumaidh a’ chosgais a bhith co-ionann ris a’ chosgais a chaidh a shuidheachadh aig àm an ceannach, às aonais prìs an àrachais.
Thathas a’ tuigsinn gu bheil an cunntas àrachais às deidh sin a’ ceannach comharran àrachais bhon neach-cleachdaidh aig prìs nach eil nas ìsle na am fear aig an do cheannaich e iad: bidh an cunntas àrachais a’ cruthachadh ExchangeTransaction, bidh an neach-cleachdaidh a’ soidhnigeadh an òrdugh (ma tha an gnothach air a chrìochnachadh gu ceart), an bidh cunntas àrachais a’ soidhnigeadh an dàrna òrdugh agus an gnothach gu lèir agus ga chuir chun blockchain.
Mura tachair ceannach, faodaidh an neach-cleachdaidh ExchangeTransaction a chruthachadh a rèir nan riaghailtean a tha air am mìneachadh san sgriobt agus an gnothach a chuir chun blockchain. San dòigh seo faodaidh an neach-cleachdaidh an airgead a chaidh a chosg air ceannach comharran àrachais a thilleadh.
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)
}
Faodar comharra àrachais a dhèanamh na so-mhaoin snasail, mar eisimpleir, gus casg a chuir air gluasad gu treas phàrtaidhean.
Faodar an sgeama seo a chuir an gnìomh cuideachd airson comharran crowdfunding, a thèid a thilleadh chun luchd-seilbh mura h-eil an t-suim riatanach air a chruinneachadh.
Cìsean malairt
Tha cùmhnantan snasail cuideachd buntainneach ann an cùisean far a bheil feum air cìs a chruinneachadh air gach gnothach le grunn sheòrsaichean de mhaoin. Faodar seo a dhèanamh tro so-mhaoin ùr le stàladh airson gnothaichean le so-mhaoin smart:
1. Bidh sinn a 'toirt a-mach FeeCoin, a thèid a chuir gu luchd-cleachdaidh aig prìs shuidhichte: 0,01 WAVES = 0,001 FeeCoin.
2. Suidhich urrasachd airson FeeCoin agus reata iomlaid: 0,001 WAVES = 0,001 FeeCoin.
3. Suidhich an sgriobt a leanas airson an so-mhaoin smart:
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
}A-nis a h-uile uair a ghluaiseas cuideigin N so-mhaoin snasail, bheir iad dhut FeeCoin anns an uiread de N / taxDivisor (a dh'fhaodar a cheannach bhuat aig 10 * N / taxDivisor WAVES), agus bheir thu don mhèinnear N / taxDivisor WAVES. Mar thoradh air an sin, bidh do phrothaid (cìs) aig 9 * N / taxDivisor WAVES.
Faodaidh tu cuideachd cìsean a dhèanamh le bhith a’ cleachdadh sgriobt so-mhaoin snasail agus MassTransferTransaction:
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
}Prògraman airgead air ais agus dìlseachd
Is e seòrsa de phrògram dìlseachd a th’ ann an Cashback anns am faigh an ceannaiche pàirt den t-suim a chaidh a chosg air toradh no seirbheis air ais.
Nuair a bhios sinn a’ cur a’ chùis seo an gnìomh a’ cleachdadh cunntas snasail, feumaidh sinn na dearbhaidhean a sgrùdadh san aon dòigh ’s a rinn sinn sa chùis àrachais. Gus casg a chuir air caitheamh dùbailte, feumaidh an neach-cleachdaidh DataTransaction a chuir le (iuchair, luach) = (ceannach TransactionId, cashbackTransactionId) mus faigh e airgead air ais.
Feumaidh sinn cuideachd casg a chuir air iuchraichean gnàthaichte a’ cleachdadh DataTransaction. cashbackDivisor - aonad air a roinn leis a’ chuibhreann airgead-air-ais. An fheadhainn sin. mas e 0.1 an roinn airgead-air-ais, an uairsin 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)
}Malairt atamach
Tha suaip atamach a’ leigeil le luchd-cleachdaidh maoin iomlaid gun chuideachadh bho iomlaid. Le suaip atamach, feumaidh an dà chom-pàirtiche sa ghnothach a dhearbhadh taobh a-staigh ùine sònraichte.
Mura toir co-dhiù aon de na com-pàirtichean dearbhadh ceart air a ’ghnothach taobh a-staigh na h-ùine a chaidh a shònrachadh airson a’ ghnothaich, thèid an gnothach a chuir dheth agus cha bhith an iomlaid a ’tachairt.
Anns an eisimpleir againn, cleachdaidh sinn an sgriobt cunntas snasail a leanas:
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
}
Anns an ath artaigil seallaidh sinn ri cleachdadh chunntasan snasail ann an ionnstramaidean ionmhais leithid roghainnean, amannan ri teachd agus cunntasan.
Source: www.habr.com