บล็อคเชนมักจะเกี่ยวข้องกับสกุลเงินดิจิทัลเท่านั้น แต่ขอบเขตการประยุกต์ใช้เทคโนโลยี DLT นั้นกว้างกว่ามาก หนึ่งในพื้นที่ที่มีแนวโน้มมากที่สุดสำหรับการใช้บล็อคเชนคือสัญญาอัจฉริยะที่ดำเนินการโดยอัตโนมัติและไม่ต้องการความไว้วางใจระหว่างฝ่ายที่เข้าร่วม
RIDE – ภาษาสำหรับสัญญาอัจฉริยะ
Waves ได้พัฒนาภาษาพิเศษสำหรับสัญญาอัจฉริยะ - RIDE มีเอกสารประกอบที่สมบูรณ์อยู่ . และที่นี่ - บน Habr
สัญญา RIDE เป็นภาคแสดงและส่งกลับ "จริง" หรือ "เท็จ" เป็นเอาต์พุต ดังนั้นธุรกรรมจะถูกบันทึกในบล็อคเชนหรือถูกปฏิเสธ สัญญาอัจฉริยะรับประกันการปฏิบัติตามเงื่อนไขที่ระบุอย่างเต็มที่ การสร้างธุรกรรมจากสัญญาใน RIDE ไม่สามารถทำได้ในขณะนี้
ปัจจุบันสัญญาอัจฉริยะของ Waves มีสองประเภท: บัญชีอัจฉริยะและสินทรัพย์อัจฉริยะ บัญชีอัจฉริยะเป็นบัญชีผู้ใช้ทั่วไป แต่มีการตั้งค่าสคริปต์เพื่อควบคุมธุรกรรมทั้งหมด สคริปต์บัญชีอัจฉริยะอาจมีลักษณะเช่นนี้ เช่น:
match tx {
case t: TransferTransaction | MassTransferTransaction => false
case _ => true
}
tx คือธุรกรรมที่กำลังประมวลผลซึ่งเราอนุญาตให้ใช้กลไกการจับคู่รูปแบบเฉพาะในกรณีที่ไม่ใช่ธุรกรรมการโอน การจับคู่รูปแบบใน RIDE ใช้เพื่อตรวจสอบประเภทของธุรกรรม บัญชีที่มีอยู่ทั้งหมดสามารถประมวลผลได้ในสคริปต์บัญชีอัจฉริยะ .
สคริปต์ยังสามารถประกาศตัวแปร ใช้โครงสร้าง "if-then-else" และวิธีการอื่นๆ สำหรับการตรวจสอบเงื่อนไขทั้งหมด เพื่อให้แน่ใจว่าสัญญามีความสมบูรณ์และซับซ้อนที่พิสูจน์ได้ (ต้นทุน) ซึ่งง่ายต่อการคาดการณ์ก่อนที่จะเริ่มดำเนินการตามสัญญา RIDE จะไม่มีคำสั่งวนซ้ำหรือข้าม
คุณสมบัติอื่นๆ ของบัญชี Waves รวมถึงการมี "สถานะ" ซึ่งก็คือสถานะของบัญชี คุณสามารถเขียนคู่ (คีย์, ค่า) ได้อย่างไม่จำกัดไปยังสถานะบัญชีโดยใช้ธุรกรรมข้อมูล (DataTransaction) ข้อมูลนี้สามารถประมวลผลได้ทั้งผ่าน REST API และในสัญญาอัจฉริยะโดยตรง
ธุรกรรมแต่ละรายการสามารถมีอาร์เรย์ของหลักฐาน ซึ่งสามารถป้อนลายเซ็นของผู้เข้าร่วม ID ของธุรกรรมที่ต้องการ ฯลฯ ได้
ทำงานร่วมกับ RIDE ผ่าน ช่วยให้คุณเห็นมุมมองที่รวบรวมของสัญญา (หากถูกรวบรวม) สร้างบัญชีใหม่และตั้งค่าสคริปต์ รวมถึงส่งธุรกรรมผ่านทางบรรทัดคำสั่ง
สำหรับวงจรทั้งหมด รวมถึงการสร้างบัญชี การติดตั้งสัญญาอัจฉริยะและการส่งธุรกรรม คุณยังสามารถใช้ไลบรารีสำหรับการโต้ตอบกับ REST API (เช่น C#, C, Java, JavaScript, Python, Rust, Elixir) . หากต้องการเริ่มทำงานกับ IDE เพียงคลิกปุ่มใหม่
ความเป็นไปได้ในการใช้สัญญาอัจฉริยะนั้นมีมากมาย ตั้งแต่การห้ามทำธุรกรรมไปจนถึงที่อยู่บางแห่ง (“บัญชีดำ”) ไปจนถึง dApps ที่ซับซ้อน
ตอนนี้เรามาดูตัวอย่างเฉพาะของการใช้สัญญาอัจฉริยะในธุรกิจ: เมื่อดำเนินการประมูล การประกันภัย และการสร้างโปรแกรมความภักดี
การประมูล
เงื่อนไขประการหนึ่งสำหรับการประมูลที่ประสบความสำเร็จคือความโปร่งใส: ผู้เข้าร่วมจะต้องมั่นใจว่าเป็นไปไม่ได้ที่จะบิดเบือนราคาเสนอ สิ่งนี้สามารถทำได้สำเร็จด้วยบล็อกเชน ซึ่งข้อมูลที่ไม่เปลี่ยนแปลงเกี่ยวกับการเดิมพันทั้งหมดและเวลาที่ทำการเดิมพันจะพร้อมใช้งานสำหรับผู้เข้าร่วมทุกคน
บนบล็อกเชน Waves สามารถบันทึกการเสนอราคาในสถานะบัญชีการประมูลผ่าน DataTransaction
คุณยังสามารถตั้งเวลาเริ่มต้นและสิ้นสุดของการประมูลโดยใช้หมายเลขบล็อกได้: ความถี่ของการสร้างบล็อกในบล็อกเชน Waves มีค่าประมาณเท่ากับ 60 วินาที
1. การประมูลราคาจากน้อยไปมากภาษาอังกฤษ
ผู้เข้าร่วมการประมูลในภาษาอังกฤษจะเสนอราคาแข่งขันกันเอง การเดิมพันใหม่แต่ละครั้งจะต้องเกินการเดิมพันครั้งก่อน การประมูลจะสิ้นสุดลงเมื่อไม่มีผู้เสนอราคาเกินราคาเสนอล่าสุด ในกรณีนี้ผู้เสนอราคาสูงสุดจะต้องระบุจำนวนเงินที่ระบุไว้
นอกจากนี้ยังมีตัวเลือกการประมูลที่ผู้ขายกำหนดราคาขั้นต่ำสำหรับล็อต และราคาสุดท้ายจะต้องสูงกว่าราคาดังกล่าว ไม่เช่นนั้นสินค้าคงเหลือขายไม่ออก
ในตัวอย่างนี้ เรากำลังทำงานร่วมกับบัญชีที่สร้างขึ้นสำหรับการประมูลโดยเฉพาะ ระยะเวลาการประมูลคือ 3000 บล็อก และราคาเริ่มต้นของล็อตคือ 0,001 WAVES ผู้เข้าร่วมสามารถเสนอราคาโดยการส่ง DataTransaction พร้อม "ราคา" ที่สำคัญและมูลค่าของการประมูล
ราคาของการเสนอราคาใหม่จะต้องสูงกว่าราคาปัจจุบันสำหรับคีย์นี้ และผู้เข้าร่วมจะต้องมีโทเค็นอย่างน้อย [new_bid + ค่าคอมมิชชัน] ในบัญชีของเขา ที่อยู่ของผู้เสนอราคาจะต้องบันทึกไว้ในช่อง "ผู้ส่ง" ใน DataTransaction และความสูงของบล็อกการเสนอราคาปัจจุบันต้องอยู่ภายในระยะเวลาการประมูล
หากในตอนท้ายของการประมูล ผู้เข้าร่วมได้กำหนดราคาสูงสุดไว้ เขาสามารถส่ง ExchangeTransaction เพื่อชำระค่าล็อตที่เกี่ยวข้องในราคาและคู่สกุลเงินที่ระบุได้
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. การประมูลลดราคาของเนเธอร์แลนด์
ในการประมูลของชาวดัตช์ ในตอนแรกจะมีการเสนอขายสินค้าจำนวนมากในราคาที่สูงกว่าที่ผู้ซื้อยินดีจ่าย ราคาจะลดลงทีละขั้นจนกระทั่งผู้เข้าร่วมคนใดคนหนึ่งตกลงที่จะซื้อล็อตในราคาปัจจุบัน
ในตัวอย่างนี้ เราใช้ค่าคงที่เดียวกันกับค่าก่อนหน้า รวมถึงขั้นตอนราคาเมื่อเดลต้าลดลง สคริปต์บัญชีจะตรวจสอบว่าผู้เข้าร่วมเป็นคนแรกที่วางเดิมพันหรือไม่ มิฉะนั้น DataTransaction จะไม่ได้รับการยอมรับจาก blockchain
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. การประมูลแบบ “จ่ายทั้งหมด”
“จ่ายทั้งหมด” คือการประมูลที่ผู้เข้าร่วมทุกคนจ่ายราคาประมูล ไม่ว่าใครจะชนะรางวัลก็ตาม ผู้เข้าร่วมใหม่แต่ละคนจะต้องชำระราคาประมูล และผู้เข้าร่วมที่ให้ราคาเสนอสูงสุดจะเป็นผู้ชนะรางวัล
ในตัวอย่างของเรา ผู้เข้าร่วมการประมูลแต่ละรายจะเสนอราคาผ่าน DataTransaction ด้วย (คีย์, มูลค่า)* = (“ผู้ชนะ”, ที่อยู่), (“ราคา”, ราคา) DataTransaction ดังกล่าวจะได้รับการอนุมัติก็ต่อเมื่อผู้เข้าร่วมรายนี้มี TransferTransaction พร้อมลายเซ็นของเขาอยู่แล้ว และราคาเสนอของเขาสูงกว่ารายการก่อนหน้าทั้งหมด การประมูลดำเนินต่อไปจนกว่าจะถึงจุดสิ้นสุดความสูง
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)
}ประกันภัย / การระดมทุน
ลองพิจารณาสถานการณ์ที่คุณต้องประกันทรัพย์สินของผู้ใช้จากการสูญเสียทางการเงิน ตัวอย่างเช่น ผู้ใช้ต้องการการรับประกันว่าหากโทเค็นอ่อนค่าลง เขาจะสามารถคืนเงินเต็มจำนวนที่ชำระสำหรับโทเค็นเหล่านี้ และยินดีจ่ายค่าประกันในจำนวนที่สมเหตุสมผล
เพื่อดำเนินการนี้ จำเป็นต้องออก "โทเค็นการประกัน" จากนั้นจะมีการติดตั้งสคริปต์ในบัญชีของผู้ถือกรมธรรม์ โดยอนุญาตให้ดำเนินการเฉพาะ ExchangeTransactions ที่ตรงตามเงื่อนไขบางประการเท่านั้น
เพื่อป้องกันการใช้จ่ายซ้ำซ้อน คุณต้องขอให้ผู้ใช้ส่ง DataTransaction ไปยังบัญชีของผู้ถือกรมธรรม์ล่วงหน้าด้วย (คีย์, ค่า) = (purchaseTransactionId, sellOrderId) และห้ามไม่ให้ส่ง DataTransactions ด้วยคีย์ที่ใช้ไปแล้ว
ดังนั้นหลักฐานของผู้ใช้จะต้องมีรหัสธุรกรรมของการซื้อโทเค็นประกัน คู่สกุลเงินจะต้องเหมือนกันกับในธุรกรรมการซื้อ ค่าใช้จ่ายจะต้องเท่ากับราคาคงที่ ณ เวลาที่ซื้อ ลบด้วยราคาประกัน
เป็นที่เข้าใจว่าต่อมาบัญชีประกันจะซื้อโทเค็นประกันจากผู้ใช้ในราคาไม่ต่ำกว่าราคาที่เขาซื้อ: บัญชีประกันจะสร้าง ExchangeTransaction ผู้ใช้ลงนามในคำสั่ง (หากธุรกรรมเสร็จสมบูรณ์อย่างถูกต้อง) บัญชีประกันภัยลงนามในคำสั่งซื้อที่สองและธุรกรรมทั้งหมดแล้วส่งไปที่บล็อคเชน
หากไม่มีการซื้อเกิดขึ้น ผู้ใช้สามารถสร้าง ExchangeTransaction ตามกฎที่อธิบายไว้ในสคริปต์ และส่งธุรกรรมไปยังบล็อคเชน วิธีนี้ทำให้ผู้ใช้สามารถคืนเงินที่ใช้ไปในการซื้อโทเค็นที่มีประกันได้
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)
}
โทเค็นการประกันสามารถถูกทำให้เป็นสินทรัพย์อัจฉริยะได้ เช่น เพื่อห้ามการถ่ายโอนไปยังบุคคลที่สาม
โครงการนี้สามารถนำไปใช้กับโทเค็นการระดมทุนได้ ซึ่งจะถูกส่งคืนให้กับเจ้าของ หากยังไม่ได้รวบรวมจำนวนเงินที่ต้องการ
ภาษีการทำธุรกรรม
สัญญาอัจฉริยะยังสามารถใช้ได้ในกรณีที่จำเป็นต้องเก็บภาษีในแต่ละธุรกรรมที่มีสินทรัพย์หลายประเภท ซึ่งสามารถทำได้ผ่านเนื้อหาใหม่ที่ติดตั้งไว้ สำหรับการทำธุรกรรมกับสินทรัพย์อัจฉริยะ:
1. เราออก FeeCoin ซึ่งจะถูกส่งให้กับผู้ใช้ในราคาคงที่: 0,01 WAVES = 0,001 FeeCoin
2. ตั้งค่าการสนับสนุน FeeCoin และอัตราแลกเปลี่ยน: 0,001 WAVES = 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
}ตอนนี้ทุกครั้งที่มีคนโอนสินทรัพย์อัจฉริยะ N พวกเขาจะมอบ FeeCoin ให้คุณเป็นจำนวน N/taxDivisor (ซึ่งสามารถซื้อได้จากคุณที่ 10 *N/taxDivisor WAVES) และคุณจะมอบ N/taxDivisor WAVES แก่คนขุดแร่ เป็นผลให้กำไร (ภาษี) ของคุณจะเป็น 9*N / TaxDivisor WAVES
คุณยังสามารถดำเนินการจัดเก็บภาษีได้โดยใช้สคริปต์สินทรัพย์อัจฉริยะและ 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 ด้วย (คีย์, ค่า) = (purchaseTransactionId, cashbackTransactionId) ก่อนที่จะรับเงินคืน
เรายังต้องกำหนดการห้ามคีย์ที่มีอยู่โดยใช้ DataTransaction cashbackDivisor - หน่วยหารด้วยส่วนแบ่งเงินคืน เหล่านั้น. หากส่วนแบ่งเงินคืนคือ 0.1 ดังนั้น 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)
}การแลกเปลี่ยนอะตอม
Atomic swap อนุญาตให้ผู้ใช้แลกเปลี่ยนสินทรัพย์โดยไม่ต้องอาศัยความช่วยเหลือจากการแลกเปลี่ยน ด้วย Atomic Swap ผู้เข้าร่วมทั้งสองในธุรกรรมจะต้องยืนยันภายในระยะเวลาหนึ่ง
หากผู้เข้าร่วมอย่างน้อยหนึ่งรายไม่ยืนยันธุรกรรมที่ถูกต้องภายในเวลาที่กำหนดสำหรับธุรกรรม ธุรกรรมจะถูกยกเลิกและการแลกเปลี่ยนจะไม่เกิดขึ้น
ในตัวอย่างของเรา เราจะใช้สคริปต์บัญชีอัจฉริยะต่อไปนี้:
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
}
ในบทความถัดไป เราจะดูการใช้บัญชีอัจฉริยะในเครื่องมือทางการเงิน เช่น ออปชั่น ฟิวเจอร์ส และตั๋วเงิน
ที่มา: will.com