ืืืึธืงืืฉืืื ืืื ืึธืคื ืคืืจืืื ืื ืืืืื ืืื ืงืจืืคึผืืึธืงืืจืจืขื ืกื, ืึธืืขืจ ืื ืึทืคึผืืึทืงืืืฉืึทื ื ืคืื DLT ืืขืื ืึธืืึธืืืข ืืขื ืขื ืคืื ืืจืืื. ืืืื ืขืจ ืคืื ืื ืืขืจืกื ืคึผืจืึทืืึทืกืื ื ืืขืืืื ืคึฟืึทืจ ืื ื ืืฆื ืคืื ืืืึทืงืืืืืืึทื ืืื ืึท ืงืืื ืงืึธื ืืจืึทืงื ืืืึธืก ืืื ืขืงืกืึทืงืืืืึทื ืืืืืึธืืึทืืืฉ ืืื ืืื ื ืืฉื ืืึทืจืคื ืฆืืืจืื ืฆืืืืฉื ืื ืคึผืึทืจืืืขืก ืืืึธืก ืืขื ืขื ืืจืืื ืืื ืขืก.
RIDE - ืึท ืฉืคึผืจืึทื ืคึฟืึทืจ ืงืืื ืงืึทื ืืจืึทืงืฅ
ืืืึทืืืขืก ืืื ืืขืืืขืืึธืคึผืขื ืึท ืกืคึผืขืฆืืขื ืฉืคึผืจืึทื ืคึฟืึทืจ ืงืืื ืงืึทื ืืจืึทืงืฅ - RIDE. ืืืึทื ืืึทื ืฅ ืืึทืงืืืืขื ืืืืฉืึทื ืืื ืืืื
ืื RIDE ืงืึธื ืืจืึทืงื ืืื ืึท ืคึผืจืขืืืงืึทื ืืื ืงืขืจื "ืืืช" ืึธืืขืจ "ืคืึทืืฉ" ืืื ืจืขืืืืืึทื. ืึทืงืงืึธืจืืื ืืื, ืื ืืจืึทื ืกืึทืงืืืึธื ืืื ืึธืืขืจ ืจืขืงืึธืจืืขื ืืื ืื ืืืึทืงืืืืืืึทื ืึธืืขืจ ืคืืจืืืืจืคื. ืืขืจ ืงืืื ืงืึธื ืืจืึทืงื ืืึธืจ ืืขืจืึทื ืืื ืื ืืงืืื ืคืื ืกืคึผืขืกืืคืืขื ืื ืึธืื. ืขืก ืืื ืืขืจืืืืึทื ื ืื ืืขืืืขื ืฆื ืืืฉืขื ืขืจืืื ืืจืึทื ืืึทืงืฉืึทื ื ืคืื ืึท ืงืึธื ืืจืึทืงื ืืื RIDE.
ืืืึทื ื ืขืก ืืขื ืขื ืฆืืืื ืืืืคึผืก ืคืื ืืืึทืืืขืก ืงืืื ืงืึทื ืืจืึทืงืฅ: ืงืืื ืึทืงืึทืื ืฅ ืืื ืงืืื ืึทืกืขืฅ. ื ืงืืื ืืฉืืื ืืื ืึท ืจืขืืืืขืจ ืืึทื ืืฆืขืจ ืืฉืืื, ืึธืืขืจ ืึท ืฉืจืืคื ืืื ืืึทืฉืืืื ืคึฟืึทืจ ืืื ืืืึธืก ืงืึธื ืืจืึธื ืึทืืข ืืจืึทื ืืึทืงืฉืึทื ื. ื ืงืืื ืืฉืืื ืฉืจืืคื ืงืขื ืงืืงื ืืื ืืึธืก, ืืืฉื:
match tx {
case t: TransferTransaction | MassTransferTransaction => false
case _ => true
}
tx ืืื ืึท ืืจืึทื ืกืึทืงืืืึธื ืคึผืจืึทืกืขืกื ืึทื ืืืจ ืืึธืื ื ืืฆื ืื ืืืกืืขืจ ืืืึธืก ืจืืืื ืืขืงืึทื ืืืึทื ืืืืื ืืืื ืขืก ืืื ื ืืฉื ืึท ืึทืจืืืขืจืคืืจื ืืจืึทื ืกืึทืงืืืึธื. ืืืกืืขืจ ืืืึธืก ืจืืืื ืืื ืืื RIDE ืืื ืืขื ืืฆื ืฆื ืงืึธื ืืจืึธืืืจื ืืขื ืืืคึผ ืคืื ืืจืึทื ืกืึทืงืืืึธื. ืื ืืืืืกืืื ื ืึทืงืึทืื ืฅ ืงืขื ืขื ืืืื ืคึผืจืึทืกืขืกื ืืื ืื ืงืืื ืืฉืืื ืฉืจืืคื
ืืขืจ ืฉืจืืคื ืงืขื ืขื ืืืื ืืขืจืงืืขืจื ืืืขืจืืึทืืึทืื, ื ืืฆื "ืืืื-ืืขืืึธืื-ืื ืืขืจืข" ืงืึทื ืกืืจืึทืงืฉืึทื ื ืืื ืื ืืขืจืข ืืขืืืึธืืก ืคึฟืึทืจ ืืึธืจ ืงืึธื ืืจืึธืืืจืื ื ืื ืึธืื. ืฆื ืขื ืฉืืจ ืึทื ืงืึทื ืืจืึทืงืฅ ืืึธืื ืคึผืจืึทืืืืืึทืืึทื ืงืึทืืคึผืืืื ืึทืก ืืื ืงืึทืืคึผืืขืงืกืืื (ืคึผืจืืึทื) ืืืึธืก ืืื ืืจืื ื ืฆื ืคืึธืจืืืกืืึธืื ืืืืืขืจ ืื ืืืจืืคืืจืื ื ืคืื ืงืึธื ืืจืึทืงื ืืืืื, RIDE ืืื ื ืืฉื ืึทื ืืืึทืืื ืืืคึผืก ืึธืืขืจ ืฉืคึผืจืื ืืขื ืกืืืืืืึทื ืฅ.
ืื ืืขืจืข ืคึฟืขืึดืงืืืื ืคืื ืืืึทืืืขืก ืึทืงืึทืื ืฅ ืึทืจืืึทื ื ืขืืขื ืื ืืืึทืืืึทื ืคืื ืึท "ืฉืืึทื," ืืืึธืก ืืื, ืื ืฉืืึทื ืคืื ืื ืืฉืืื. ืืืจ ืงืขื ืขื ืฉืจืืึทืื ืึท ืื ืคืึทื ืึทื ื ืืืขืจ ืคืื ืคึผืขืจื (ืฉืืืกื, ืืืขืจื) ืฆื ืื ืืฉืืื ืฉืืึทื ื ืืฆื ืืึทืื ืืจืึทื ืืึทืงืฉืึทื ื (DataTransaction). ืื ืืื ืคึฟืึธืจืืึทืฆืืข ืงืขื ืขื ืืืื ืคึผืจืึทืกืขืกื ืืืืืข ืืืจื ืื REST API ืืื ืืืืึทื ืืื ืื ืงืืื ืงืึธื ืืจืึทืงื.
ืืขืืขืจ ืืจืึทื ืกืึทืงืืืึธื ืงืขื ืขื ืึทื ืืืึทืืื ืึท ืงืืื ืคืื ืคึผืจืึธืืืขืก, ืืื ืืืึธืก ืื ืืกืืืข ืคืื โโืื ืืึทืืืืืืงืืขืจ, ืื ID ืคืื ืื ืคืืจืืื ืื ืืจืึทื ืกืึทืงืืืึธื, ืืื"ื ื.
ืืจืืขืื ืืื RIDE ืืืจื
ืคึฟืึทืจ ืึท ืืึทื ืฅ ืฆืืงื, ืึทืจืืึทื ืืขืจืขืื ื ืงืจืืืืืื ื ืึท ืืฉืืื, ืื ืกืืึธืืื ื ืึท ืงืืื ืงืึธื ืืจืึทืงื ืืืืฃ ืขืก ืืื ืฉืืงื ืืจืึทื ืืึทืงืฉืึทื ื, ืืืจ ืงืขื ืขื ืืืื ื ืืฆื ืึท ืืืืืืึธืืขืง ืคึฟืึทืจ ืื ืืขืจืึทืงืืื ื ืืื ืื REST API (ืืืฉื C #, C, Java, JavaScript, Python, Rust, Elixir) . ืฆื ืึธื ืืืืื ืืจืืขืื ืืื ืื IDE, ื ืึธืจ ืืื ืื ื ืืึท ืงื ืขืคึผื.
ืื ืคึผืึทืกืึทืืืืึทืืื ืคึฟืึทืจ ื ืืฆื ืงืืื ืงืึทื ืืจืึทืงืฅ ืืขื ืขื ืืจืืื: ืคืื ืคึผืจืึธืืืืืึทืืื ื ืืจืึทื ืืึทืงืฉืึทื ื ืฆื ืืืืขืจ ืึทืืจืขืกืขืก ("ืฉืืืึทืจืฅ ืจืฉืืื") ืฆื ืงืึธืืคึผืืขืงืก ืืึทืคึผืคึผืก.
ืืืฆื ืืึธืืืจ ืงืืงื ืืื ืกืคึผืขืฆืืคืืฉ ืืืืฉืคืืื ืคืื ืื ื ืืฆื ืคืื ืงืืื ืงืึทื ืืจืึทืงืฅ ืืื ืืขืฉืขืคื: ืืืขื ืงืึทื ืืึทืงืืื ื ืึธืงืฉืึทื ื, ืคืึทืจืืืืขืจืื ื ืืื ืงืจืืืืืื ื ืืืืึทืืื ืืืืื.
ืึธืงืฉืึทื ื
ืืืื ืขืจ ืคืื ืื ืืืืื ืืื ืืขื ืคึฟืึทืจ ืึท ืืฆืืื ืืืฆืืืึทืฆืืข ืืื ืืืจืืืขืืงืืึทื: ืคึผืึทืจืืืกืึทืคึผืึทื ืฅ ืืืื ืืืื ืืืืขืจ ืึทื ืขืก ืืื ืืืืืขืืืขื ืฆื ืืึทื ืืคึผืืืืจื ืืืืก. ืืขื ืงืขื ืขื ืืืื ืึทืืฉืืืื ืืึทื ืง ืฆื ืื ืืืึทืงืืืืืืึทื, ืืื ืืืืืืึทืืึทื ืืึทืื ืืืขืื ืึทืืข ืืขืฅ ืืื ืื ืฆืืื ืืืขื ืืื ืืขื ืขื ืืขืืืื ืืืขื ืืืื ืืืจืขืืืืื ืคึฟืึทืจ ืึทืืข ืคึผืึทืจืืืกืึทืคึผืึทื ืฅ.
ืืืืฃ ืื ืืืึทืืืขืก ืืืึธืงืืฉืืื, ืืืืก ืงืขื ืขื ืืืื ืจืขืงืึธืจืืขื ืืื ืื ืืืฆืืืึทืฆืืข ืืฉืืื ืฉืืึทื ืืืจื DataTransaction.
ืืืจ ืงืขื ืขื ืืืื ืฉืืขืื ืื ืึธื ืืืื ืืื ืกืืฃ ืฆืืื ืคืื ืื ืืืฆืืืึทืฆืืข ืืื ืืืึธืง ื ืืืขืจื: ืื ืึธืคืืงืืึทื ืคืื ืืืึธืง ืืืจ ืืื ืื ืืืึทืืืขืก ืืืึทืงืืืืืืึทื ืืื ืืขืขืจืขื ืืืืึทื ืฆื 60 ืกืขืงืื ืืขืก.
1. ืขื ืืืืฉ ืึทืกืขื ืืื ื ืคึผืจืืึทื ืืืฆืืืึทืฆืืข
ืคึผืึทืจืืืกืึทืคึผืึทื ืฅ ืืื ืึทื ืขื ืืืืฉ ืืืฆืืืึทืฆืืข ืฉืืขืื ืืืืก ืืื ืคืึทืจืืขืกื ืืื ืืขืืขืจ ืื ืืขืจืขืจ. ืืขืืขืจ ื ืืึท ืืขืืืขื ืืืื ืืงืกืื ืื ืคืจืืขืจืืืงืข. ืื ืืืฆืืืึทืฆืืข ืขื ืืก ืืืขื ืขืก ืืขื ืขื ื ืื ืืขืจ ืืืืืขืจืก ืฆื ืืงืกืื ืื ืืขืฆืืข ืืึทืคืขืื. ืืื ืืขื ืคืึทื, ืื ืืขืืกืื ืืืืขืจ ืืืื ืฆืืฉืืขืื ืื ืกืืืืืื ืกืืืข.
ืขืก ืืื ืืืื ืึท ืืืฆืืืึทืฆืืข ืึธืคึผืฆืืข ืืื ืืืึธืก ืื ืืจืขืืขืจ ืฉืืขืื ืึท ืืื ืืืื ืคึผืจืืึทื ืคึฟืึทืจ ืื ืคึผืืึทืฅ, ืืื ืื ืืขืฆื ืคึผืจืืึทื ืืืื ืืงืกืื ืขืก. ืึทื ืืขืจืฉ, ืื ืคึผืืึทืฅ ืืืืืื ืึทื ืกืึธืืื.
ืืื ืืขื ืืืึทืฉืคึผืื, ืืืจ ืึทืจืืขืื ืืื ืึท ืืฉืืื ืกืคึผืึทืกืืคืืงืื ืืืฉืืคื ืคึฟืึทืจ ืื ืืืฆืืืึทืฆืืข. ืื ืืืฆืืืึทืฆืืข ืืขืืืืขืจ ืืื 3000 ืืืึทืงืก, ืืื ืื ืกืืึทืจืืื ื ืคึผืจืืึทื ืคืื ืื ืคึผืืึทืฅ ืืื 0,001 ืืืึทืืืขืก. ื ืืึทืืืืืืงืืขืจ ืงืขื ืขื ืฉืืขืื ืึท ืืึทืคืขืื ืืืจื ืฉืืงื ืึท ืืึทืืึทืืจืึทื ืกืึทืงืืืึธื ืืื ืื ืฉืืืกื "ืคึผืจืืึทื" ืืื ืื ืืืขืจื ืคืื ืืืืขืจ ืืึทืคืขืื.
ืื ืคึผืจืืึทื ืคืื ืื ื ืืึทืข ืืึทืคืขืื ืืืื ืืืื ืืขืืขืจ ืืื ืื ืงืจืึทื ื ืคึผืจืืึทื ืคึฟืึทืจ ืืขื ืฉืืืกื, ืืื ืืขืจ ืืึทืืืืืืงืืขืจ ืืืื ืืึธืื ืืืึท ืืื ืืกืืขืจ [new_bid + ืงืึธืืืกืืข] ืืึธืงืขื ืก ืืื ืืืื ืืฉืืื. ืื ืืืืขืจ ืก ืึทืืจืขืก ืืืื ืืืื ืจืขืงืึธืจืืขื ืืื ืื "ืึธืคึผืฉืืงืขืจ" ืคืขืื ืืื ืื ืืึทืืึทืืจืึทื ืกืึทืงืืืึธื, ืืื ืื ืงืจืึทื ื ืืึทืคืขืื ืืืึธืง ืืืื ืืืื ืืืื ืืื ืื ืืืฆืืืึทืฆืืข ืฆืืื.
ืืืื ืืื ืื ืกืืฃ ืคืื ืื ืืืฆืืืึทืฆืืข ืืขืจ ืืึทืืืืืืงืืขืจ ืืื ืืึทืฉืืืื ืืขื ืืขืืกืื ืคึผืจืืึทื, ืขืจ ืงืขื ืขื ืฉืืงื ืึทื ืขืงืกืืฉืึทื ืืข ืืจืึทื ืกืึทืงืืืึธื ืฆื ืืึทืฆืึธืื ืคึฟืึทืจ ืื ืงืึธืจืึทืกืคึผืึทื ืืื ื ืคึผืืึทืฅ ืืื ืื ืกืคึผืขืกืืคืืขื ืคึผืจืืึทื ืืื ืงืจืึทื ืืงืืึทื ืคึผืึธืจ.
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. ืืึธืืขื ืืืฉ ืืืฆืืืึทืฆืืข ืคืื โโืืืงืจืืกืื ื ืคึผืจืืืกืื
ืืื ืึท ืืึธืืขื ืืืฉ ืืืฆืืืึทืฆืืข, ืึท ืคึผืืึทืฅ ืืื ืืืืืขืก ืืขืคึฟืื ื ืฆื ืึท ืคึผืจืืึทื ืืขืืขืจ ืืื ืืืึธืก ืื ืงืืื ืข ืืื ืืจืืื ืฆื ืืึทืฆืึธืื. ืืขืจ ืคืจืืื ืืืขืจื ืจืืืืกื ืฉืจืื ืืืจื ืฉืจืื ืืื ืืืื ืขืจ ืคืื ืื ืคึผืึทืจืืืกืึทืคึผืึทื ืฅ ืฉืืืืขื ืฆื ืงืืืคื ืื ืคึผืืึทืฅ ืืื ืื ืงืจืึทื ื ืคึผืจืืึทื.
ืืื ืืขื ืืืึทืฉืคึผืื ืืืจ ื ืืฆื ืื ืืขืืืข ืงืึทื ืกืืึทื ืฅ ืืื ืืื ืื ืคืจืืขืจืืืงืข ืืืื ืขืจ, ืืื ืืขืืื ื ืืื ืื ืคึผืจืืึทื ืฉืจืื ืืืขื ืืขืืืึท ืืืงืจืืกืึทื. ืืขืจ ืืฉืืื ืฉืจืืคื ืืฉืขืงืก ืฆื ืืขืจ ืืึทืืืืืืงืืขืจ ืืื ืืึทืงืข ืืขืจ ืขืจืฉืืขืจ ืฆื ืฉืืขืื ืึท ืืขืืืขื. ืึทื ืืขืจืฉ, ืื ืืึทืืึทืืจืึทื ืกืึทืงืืืึธื ืืื ื ืืฉื ืื ืืขื ืืืขื ืืืจื ืื ืืืึทืงืืืืืืึทื.
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. ืืืฆืืืึทืฆืืข "ืึทืืข-ืืึทืฆืึธืื"
"ืึทืืข-ืืึทืฆืึธืื" ืืื ืึท ืืืฆืืืึทืฆืืข ืืื ืืืึธืก ืึทืืข ืคึผืึทืจืืืกืึทืคึผืึทื ืฅ ืืึทืฆืึธืื ืื ืืึทืคืขืื, ืจืึทืืึทืจืืืึทืก ืคืื ืืืขืจ ืืืื ืก ืื ืคึผืืึทืฅ. ืืขืืขืจ ื ืืึท ืืึทืืืืืืงืืขืจ ืืึทืฆืึธืื ืึท ืืึทืคืขืื, ืืื ืืขืจ ืืึทืืืืืืงืืขืจ ืืืืก ืืืื ืื ืืึทืงืกืืืื ืืึทืคืขืื ืืืื ืก ืื ืคึผืืึทืฅ.
ืืื ืืื ืืืขืจ ืืืึทืฉืคึผืื, ืืขืืขืจ ืืืฆืืืึทืฆืืข ืืึทืืืืืืงืืขืจ ืืืืื ืึท ืืึทืคืขืื ืืืจื ืืึทืืึทืืจืึทื ืกืึทืงืืืึธื ืืื (ืฉืืืกื, ืืืขืจื) * = ("ืืขืืืื ืขืจ", ืึทืืจืขืก), ("ืคึผืจืืึทื", ืคึผืจืืึทื). ืึทืืึท ืึท ืืึทืืึทืืจืึทื ืกืึทืงืืืึธื ืืื ืืืืืืืืงื ืืืืื ืืืื ืืขืจ ืืึทืืืืืืงืืขืจ ืืื ืฉืืื ืึท ืืจืึทื ืกืคืขืจืืจืึทื ืกืึทืงืืืึธื ืืื ืืืื ืืกืืืข ืืื ืืืื ืืึทืคืขืื ืืื ืืขืืขืจ ืืื ืึทืืข ืคืจืืขืจืืืงืข ืึธื ืขืก. ืื ืืืฆืืืึทืฆืืข ืืืื ืืื ืื ืกืืฃ ืคืื ืื ืืืื ืืื ืจืืืฉื.
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)
}
ืคืึทืจืืืืขืจืื ื / ืงืจืึทืืืคืึทื ืืื ื
ืืื ืก ืืึทืืจืึทืืื ืึท ืกืืืืึทืฆืืข ืืื ืืืจ ืืึทืจืคึฟื ืฆื ืคืึทืจืืืืขืจื ืื ืึทืกืขืฅ ืคืื ื ืืฆืขืจืก ืงืขืื ืคืื ืึทื ืฆืืขื ืืึธืกืกืขืก. ืฆืื ืืืืฉืคืื, ื ืืื ืืฆืขืจ ืืืื ื ืืืจืื ืืืข ืื ืืืื ื ืกืืืขื ืืืขืจื ืืืคึผืจืืฉืืืจื, ืืืขื ืขืจ ืงืขื ืขื ืฆืืจืืง ืืืงืืืขื ืื ืคืืืข ืกืืื ืืืืก ืืื ืืืฆืืื ืืขืืืืจื ืคืืจ ืื ืืืงืขื ืก, ืืื ืืื ืืจืืื ืฆื ืฆืืื ื ืืขืืขืจืืืข ืกืืืข ืืื ืฉืืจืขื ืก.
ืฆื ืื ืกืืจืืืขื ื ืืขื, "ืคืึทืจืืืืขืจืื ื ืืึธืงืขื ืก" ืืึทืจืคึฟื ืฆื ืืืื ืืจืืืก. ืืขืจื ืึธื ืึท ืฉืจืืคื ืืื ืืื ืกืืึทืืืจื ืืืืฃ ืื ืคึผืึทืืึทืกืืืึธืืืืขืจ ืก ืืฉืืื, ืึทืืึทืืื ื ืืืืื ืื ืขืงืกืืฉืึทื ืืข ืืจืึทื ืืึทืงืฉืึทื ื ืืืึธืก ืืจืขืคื ืืืืขืจ ืื ืึธืื ืฆื ืืืื ืขืงืกืึทืงืืืืึทื.
ืฆื ืคืึทืจืืืืื ืืึธืคึผื ืกืคึผืขื ืืื ื, ืืืจ ืืึทืจืคึฟื ืฆื ืืขืื ืืขื ืืึทื ืืฆืขืจ ืฆื ืฉืืงื ืึท ืืึทืืึทืืจืึทื ืกืึทืงืืืึธื ืฆื ืื ืคึผืึทืืึทืกืืืึธืืืืขืจ ืก ืืฉืืื ืืื ืฉืืืึทืื ืืื (ืฉืืืกื, ืืืขืจื) = (ืคึผืืจืืฉืึทืกืขืืจืึทื ืกืึทืงืืืึธืืื, ืกืขืืืึธืจืืขืจืื) ืืื ืคืึทืจืืืขืจื ืฉืืงื ืืึทืืึทืืจืึทื ืกืึทืงืืืึธื ืก ืืื ืึท ืฉืืืกื ืืืึธืก ืืื ืฉืืื ืืขื ืืฆื.
ืืขืจืืืขืจ, ืืขืจ ืืึทื ืืฆืขืจ ืก ืคึผืจืึธืืืขืก ืืืื ืึทื ืืืึทืืื ืื ืืจืึทื ืกืึทืงืืืึธื ืฉืืึทื ืคืื ืื ืงืืืคื ืคืื ืคืึทืจืืืืขืจืื ื ืืึธืงืขื. ืื ืงืจืึทื ืืงืืึทื ืคึผืึธืจ ืืืื ืืืื ืื ืืขืืืข ืืื ืืื ืื ืงืืืคื ืืจืึทื ืกืึทืงืืืึธื. ืื ืคึผืจืืึทื ืืืื ืืืื ืืืื ืืืืึทื ืฆื ืื ืคืึทืจืคืขืกืืืงื ืืื ืืขืจ ืฆืืื ืคืื ืงืืืคื, ืืื ืืก ืื ืคึผืจืืึทื ืคืื ืคืึทืจืืืืขืจืื ื.
ืขืก ืืื ืคืืจืฉืืื ืขื ืึทื ืืขืจื ืึธื, ืืขืจ ืคืึทืจืืืืขืจืื ื ืืฉืืื ืงืืืคื ืคืึทืจืืืืขืจืื ื ืืึธืงืขื ืก ืคืื ืืขืจ ืืึทื ืืฆืขืจ ืืื ืึท ืคึผืจืืึทื ื ืื ื ืืืขืจืืงืขืจ ืืื ืื ืืืึธืก ืขืจ ืคึผืขืจืืฉืึทืกื ืืื: ืื ืคืึทืจืืืืขืจืื ื ืืฉืืื ืงืจืืืืฅ ืึทื ืขืงืกืืฉืึทื ืืข ืืจืึทื ืืึทืงืฉืึทื, ืืขืจ ืืึทื ืืฆืขืจ ืฆืืืื ืื ืกืืจ (ืืืื ืื ืืจืึทื ืกืึทืงืืืึธื ืืื ืืืจืืืขืงืึธืื ืจืืืืืง), ืคืึทืจืืืืขืจืื ื ืืฉืืื ืฆืืืื ืื ืจืืข ืกืืจ ืืื ืื ืืื ืฆืข ืืจืึทื ืกืึทืงืืืึธื ืืื ืกืขื ืื ืขืก ืฆื ืื ืืืึทืงืืืืืืึทื.
ืืืื ืงืืื ืงืืืคื ืึทืงืขืจื, ืืขืจ ืืึทื ืืฆืขืจ ืงืขื ืขื ืืึทืื ืึทื ืขืงืกืืฉืึทื ืืข ืืจืึทื ืกืึทืงืืืึธื ืืืื ืื ืึผืืืื ืืืกืงืจืืืื ืืื ืื ืฉืจืืคื ืืื ืฉืืงื ืื ืืจืึทื ืกืึทืงืืืึธื ืฆื ืื ืืืึทืงืืืืืืึทื. ืืขื ืืืขื ืืขืจ ืืึทื ืืฆืขืจ ืงืขื ืขื ืฆืืจืืงืงืืืขื ืื ืืขืื ืคืืจืืจืืื ืืืืฃ ืื ืงืืืคื ืคืื ืคืึทืจืืืืขืจื ืืึธืงืขื ืก.
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)
}
ืึท ืคืึทืจืืืืขืจืื ื ืกืืืขื ืงืขื ืขื ืืืื ืืขืืืื ืึท ืงืืื ืึทืกืขื, ืืืฉื, ืฆื ืคืึทืจืืืขืจื ืื ืึทืจืืืขืจืคืืจื ืฆื ืืจืื ืคึผืึทืจืืืขืก.
ืืขืจ ืกืืขืืข ืงืขื ืขื ืืืื ืืืื ืืืคึผืืึทืืขื ืึทื ืคึฟืึทืจ crowdfunding ืืึธืงืขื ืก, ืืืึธืก ืืขื ืขื ืืืืืขืงืขืจื ืฆื ืื ืึธืื ืขืจื ืืืื ืื ืคืืจืืื ืื ืกืืืข ืืื ื ืืฉื ืืขืืืืื.
ืืจืึทื ืกืึทืงืืืึธื ืืึทืงืกืื
ืกืืึทืจื ืงืึทื ืืจืึทืงืฅ ืืขื ืขื ืืืื ืึธื ืืืขื ืืืขื ืืื ืงืึทืกืขืก ืืื ืขืก ืืื ื ืืืืืง ืฆื ืืึทืืืขื ืฉืืืึทืขืจ ืืืืฃ ืืขืืขืจ ืืจืึทื ืกืึทืงืืืึธื ืืื ืขืืืขืืข ืืืืคึผืก ืคืื ืึทืกืขืฅ. ืืขื ืงืขื ืขื ืืืื ืืขืืื ืืืจื ืึท ื ืืึท ืึทืกืขื ืืื ืืื ืกืืึทืืืจื
1. ืืืจ ืึทืจืืืกืืขืื FeeCoin, ืืืึธืก ืืืขื ืืืื ืืขืฉืืงื ืฆื ืืืืขืจื ืืื ืึท ืคืึทืจืคืขืกืืืงื ืคึผืจืืึทื: 0,01 ืืืึทืืืขืก = 0,001 ืคืขืขืงืึธืื.
2. ืฉืืขืื ืกืคึผืึธื ืกืึธืจืฉืืคึผ ืคึฟืึทืจ FeeCoin ืืื ืืืขืงืกื ืงืืจืก: 0,001 ืืืึทืืืขืก = 0,001 FeeCoin.
3. ืฉืืขืื ืื ืคืืืืขื ืืข ืฉืจืืคื ืคึฟืึทืจ ืื ืงืืื ืึทืกืขื:
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
}
ืืืฆื ืืขืืขืจ ืืึธื ืืืขื ืขืืขืฆืขืจ ืืจืึทื ืกืคืขืจืก ืขื ืงืืื ืึทืกืขืฅ, ืืื ืืืขื ืืขืื ืืืจ ืคืขืขืงืึธืื ืืื ืื ืกืืืข ืคืื โโืขื / ืืึทืงืกืืืืืืกืึธืจ (ืืืึธืก ืงืขื ืขื ืืืื ืคึผืขืจืืฉืึทืกื ืคืื ืืืจ ืืืึท 10 * ืขื / ืฉืืืึทืขืจ ืืืืืืกืึธืจ ืืืืืืืขืก), ืืื ืืืจ ืืืขื ืืขืื ืื ืืืื ืขืจ ืขื / ืฉืืืึทืขืจ ืืืืืืกืึธืจ ืืืืืืืขืก. ืืื ืึท ืจืขืืืืืึทื, ืืืื ื ืืฅ (ืฉืืืึทืขืจ) ืืืขื ืืืื 9 * ืขื / ืืึทืงืกืืืืืืกืึธืจ ืืืืืืืขืก.
ืืืจ ืงืขื ื ืืืื ืืืจืืคืืจื ืืึทืฉืืืึทืขืจืื ื ื ืืฆื ืึท ืงืืื ืึทืกืขื ืฉืจืืคื ืืื 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
}
ืงืึทืฉืืึทืงืง ืืื ืืืืึทืืื ืืืืื
ืงืึทืฉืืึทืงืง ืืื ืึท ืืืคึผ ืคืื ืืืืึทืืื ืคึผืจืึธืืจืึทื ืืื ืืืึธืก ืื ืงืืื ืข ืืึทืงืืืขื ืฆืืจืืง ืืืื ืคืื ืื ืกืืืข ืคืืจืืจืืื ืืืืฃ ืึท ืคึผืจืึธืืืงื ืึธืืขืจ ืืื ืกื.
ืืืขื ืืืคึผืืึทืืขื ืื ื ืืขื ืคืึทื ืืื ืึท ืงืืื ืืฉืืื, ืืืจ ืืืื ืงืึธื ืืจืึธืืืจื ืื ืคึผืจืึธืืืขืก ืืืืฃ ืื ืืขืืืข ืืืขื ืืื ืืืจ ืืึธืื ืืขืืื ืืื ืื ืคืึทืจืืืืขืจืื ื ืคืึทื. ืฆื ืคืึทืจืืืึทืื ืืึธืคึผื ืกืคึผืขื ืืื ื, ืืขืจ ืืึทื ืืฆืขืจ ืืืื ืฉืืงื ืึท ืืึทืืึทืืจืึทื ืกืึทืงืืืึธื ืืื (ืฉืืืกื, ืืืขืจื) = (ืคึผืืจืืฉืึทืกืขืืจืึทื ืกืึทืงืืืึธืืื, ืงืึทืฉืืึทืงืงืืจืึทื ืกืึทืงืืืึธืืื) ืืืืืขืจ ืขืจ ืืืงืืืขื ืงืึทืฉืืึทืงืง.
ืืืจ ืืืื ืืืื ืฉืืขืื ืึท ืคืึทืจืืึธื ืืืืฃ ืืืืืกืืื ื ืฉืืืกืืขื ื ืืฆื DataTransaction. cashbackDivisor - ืึทืคึผืึทืจืึทื ืฆืขืืืืื ืืืจื ืื ืงืึทืฉืืึทืงืง ืืืืื. ืืขื ืข. ืืืื ืื ืงืึทืฉืืึทืงืง ืืืืื ืืื 0.1, ืงืึทืฉืืึทืงืงืืืืืืกืึธืจ 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)
}
ืึทืืึธืืืฉืข ืืืกืืืึทืื
ืึทืืึธืืืฉืข ืืืกืืืึทืื ืึทืืึทืื ื ืืฆืขืจืก ืฆื ืืืขืงืกื ืึทืกืขืฅ ืึธื ืื ืืืืฃ ืคืื ืึท ืืืขืงืกื. ืืื ืึท ืึทืืึธืืืฉืข ืืืกืืืึทืื, ืืืืืข ืคึผืึทืจืืืกืึทืคึผืึทื ืฅ ืืื ืื ืืจืึทื ืกืึทืงืืืึธื ืืขื ืขื ืคืืจืืื ืื ืฆื ืืึทืฉืืขืืืงื ืขืก ืืื ืึท ืืืืขืจ ืฆืืื.
ืืืื ืืืึท ืืื ืืกืืขืจ ืืืื ืขืจ ืคืื ืื ืคึผืึทืจืืืกืึทืคึผืึทื ืฅ ืืื ื ืืฉื ืฆืืฉืืขืื ืจืืืืืง ืืึทืฉืืขืืืงืื ื ืคืื ืื ืืึทืกืข - ืืึทืื ืืื ืื ืึทืืึทืืื ืฆืืื ืคึฟืึทืจ ืื ืืจืึทื ืกืึทืงืืืึธื, ืื ืืจืึทื ืกืึทืงืืืึธื ืืื ืงืึทื ืกืึทืื ืืื ืืขืจ ืืืขืงืกื ืืื ื ืืฉื ืคึผืึทืกืืจื.
ืืื ืืื ืืืขืจ ืืืึทืฉืคึผืื, ืืืจ ืืืขืื ื ืืฆื ืื ืคืืืืขื ืืข ืงืืื ืืฉืืื ืฉืจืืคื:
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
}
ืืื ืืขืจ ืืืืึทืืขืจ ืึทืจืืืงื ืืืจ ืืืขืื ืงืืงื ืืื ืื ื ืืฆื ืคืื ืงืืื ืึทืงืึทืื ืฅ ืืื ืคืื ืึทื ืฆืืขื ืื ืกืืจืึทืืึทื ืฅ ืึทืืึท ืืื ืึธืคึผืฆืืขืก, ืคืืืืฉืขืจื ืืื ืืืืืก.
ืืงืืจ: www.habr.com