ಹಣಕಾಸು ಸಾಧನಗಳಲ್ಲಿ ವೇವ್ಸ್ ಸ್ಮಾರ್ಟ್ ಖಾತೆಗಳು ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತುಗಳ ಅಪ್ಲಿಕೇಶನ್

ಹಿಂದಿನದರಲ್ಲಿ ಲೇಖನ ಹರಾಜು ಮತ್ತು ಲಾಯಲ್ಟಿ ಕಾರ್ಯಕ್ರಮಗಳು ಸೇರಿದಂತೆ ವ್ಯಾಪಾರದಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಖಾತೆಗಳನ್ನು ಬಳಸುವ ಹಲವಾರು ಪ್ರಕರಣಗಳನ್ನು ನಾವು ನೋಡಿದ್ದೇವೆ.
ಇಂದು ನಾವು ಸ್ಮಾರ್ಟ್ ಖಾತೆಗಳು ಮತ್ತು ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತುಗಳು ಆಯ್ಕೆಗಳು, ಭವಿಷ್ಯಗಳು ಮತ್ತು ಬಿಲ್‌ಗಳಂತಹ ಹಣಕಾಸು ಸಾಧನಗಳ ಪಾರದರ್ಶಕತೆ ಮತ್ತು ವಿಶ್ವಾಸಾರ್ಹತೆಯನ್ನು ಹೇಗೆ ಸುಧಾರಿಸಬಹುದು ಎಂಬುದರ ಕುರಿತು ಮಾತನಾಡುತ್ತೇವೆ.

ಆಯ್ಕೆ

ಒಂದು ಆಯ್ಕೆಯು ವಿನಿಮಯ ಒಪ್ಪಂದವಾಗಿದ್ದು ಅದು ಖರೀದಿದಾರರಿಗೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಬೆಲೆಗೆ ಅಥವಾ ನಿರ್ದಿಷ್ಟ ದಿನಾಂಕದ ಮೊದಲು ಸ್ವತ್ತನ್ನು ಖರೀದಿಸುವ ಹಕ್ಕನ್ನು ನೀಡುತ್ತದೆ, ಆದರೆ ಹಾಗೆ ಮಾಡಲು ಅವನನ್ನು ನಿರ್ಬಂಧಿಸುವುದಿಲ್ಲ.

ಆಯ್ಕೆಯ ಅನುಷ್ಠಾನವು ಈ ಕೆಳಗಿನಂತಿರಬಹುದು:

ಆಯ್ಕೆಗಳಿಗಾಗಿ ನಾವು ಒಂದು ಸಾಧನವಾಗಿ ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತನ್ನು ಬಳಸುತ್ತೇವೆ ಮತ್ತು ವಿನಿಮಯ ಮತ್ತು ಆಯ್ಕೆಗಳನ್ನು ನೀಡುವ ಪಾಲ್ಗೊಳ್ಳುವವರಿಗೆ ಸ್ಮಾರ್ಟ್ ಖಾತೆಯನ್ನು ಬಳಸುತ್ತೇವೆ. ಎಕ್ಸ್‌ಪೈರೇಷನ್‌ಸ್ಟಾರ್ಟ್ ಮತ್ತು ಎಕ್ಸ್‌ಪೈರೇಶನ್‌ಎಂಡ್ ಬ್ಲಾಕ್ ಎತ್ತರಗಳ ನಡುವಿನ ಮಾರಾಟದ ಬೆಲೆಯಲ್ಲಿ ನಿರ್ದಿಷ್ಟ ಆಸ್ತಿಯ ನಿರ್ದಿಷ್ಟ ಮೊತ್ತವನ್ನು ಮಾರಾಟ ಮಾಡುವುದಾಗಿ ವಿನಿಮಯ ಪಾಲ್ಗೊಳ್ಳುವವರು ಭರವಸೆ ನೀಡುತ್ತಾರೆ).

ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತು ಕೋಡ್‌ನಲ್ಲಿ, ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಎತ್ತರಗಳ ನಡುವೆ ಮಾತ್ರ ವ್ಯಾಪಾರವಾಗಿದೆಯೇ ಎಂದು ನಾವು ಸರಳವಾಗಿ ಪರಿಶೀಲಿಸುತ್ತೇವೆ ಮತ್ತು ಬೇರೆ ಯಾವುದನ್ನೂ ಪರಿಶೀಲಿಸುವುದಿಲ್ಲ; ನಿಯಮಗಳ ಅನುಸರಣೆಗಾಗಿ ನಾವು ಎಲ್ಲಾ ಜವಾಬ್ದಾರಿಯನ್ನು ವಿನಿಮಯ ಭಾಗವಹಿಸುವವರ ಕೋಡ್‌ಗೆ ಬಿಡುತ್ತೇವೆ.

ಸ್ಮಾರ್ಟ್ ಆಸ್ತಿ ಕೋಡ್:

let expirationStart = 100000
let expirationEnd = 101440

match tx {
   case some : ExchangeTransaction | TransferTransaction =>
       height > expirationStart && height <= expirationEnd
   case _ => false
}

ಕ್ರಿಯೆಗಳು ಈ ಕೆಳಗಿನಂತೆ ನಡೆಯುತ್ತವೆ ಎಂದು ನಾವು ಭಾವಿಸುತ್ತೇವೆ: ವಿನಿಮಯ ಭಾಗವಹಿಸುವವರು ಕೆಲವು ಸ್ವತ್ತುಗಳನ್ನು ಖರೀದಿಸಲು ಆಯ್ಕೆಗಳನ್ನು ಮಾರಾಟ ಮಾಡುತ್ತಾರೆ ಮತ್ತು ಇತರ ಭಾಗವಹಿಸುವವರು ಈ ಆಯ್ಕೆಗಳನ್ನು ಫಾರ್ವರ್ಡ್ ಮಾಡಬಹುದು ಅಥವಾ ಅವುಗಳನ್ನು ವ್ಯಾಪಾರ ಮಾಡಬಹುದು. ಖರೀದಿಸಲು ತನ್ನ ಹಕ್ಕನ್ನು ಚಲಾಯಿಸಲು, ಸಂಭಾವ್ಯ ಖರೀದಿದಾರನು ಮಾರಾಟಗಾರನ ಖಾತೆಗೆ ಅಪೇಕ್ಷಿತ ಸಂಖ್ಯೆಯ ಆಯ್ಕೆಗಳನ್ನು ವರ್ಗಾಯಿಸಬೇಕು, ಅಂದರೆ, ವಿನಿಮಯ ಭಾಗವಹಿಸುವವನು. ಮುಂದೆ, ಅವರು ವಿನಿಮಯ ಭಾಗವಹಿಸುವವರ ರಾಜ್ಯ ಖಾತೆಗೆ ಪೂರ್ಣಗೊಂಡ ವರ್ಗಾವಣೆಯ ಬಗ್ಗೆ ಮಾಹಿತಿಯನ್ನು ಬರೆಯುತ್ತಾರೆ ಮತ್ತು ನಂತರ ಮಾತ್ರ ಎಕ್ಸ್ಚೇಂಜ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಖರೀದಿ ಮತ್ತು ಮಾರಾಟದ ನಿರ್ದಿಷ್ಟ ಷರತ್ತುಗಳ ಪ್ರಕಾರ ಮುಂದುವರಿಯಲು ಸಾಧ್ಯವಾಗುತ್ತದೆ.

ಸ್ಮಾರ್ಟ್ ಅಕೌಂಟ್ ಕೋಡ್‌ನಲ್ಲಿ, ಖರೀದಿ ಮತ್ತು ಮಾರಾಟದ ಅಂತಿಮ ಕ್ರಿಯೆಗಾಗಿ ಅದರ ಮೂಲಕ ಹಾದುಹೋಗುವ ಯಾವುದೇ ವಿನಿಮಯ ವಹಿವಾಟು ನಿರ್ದಿಷ್ಟಪಡಿಸಿದ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸುತ್ತದೆ ಎಂದು ನಾವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು ಮತ್ತು ಭಾಗವಹಿಸುವವರು ಎಕ್ಸ್‌ಚೇಂಜ್ ಭಾಗವಹಿಸುವವರ ಖಾತೆಗೆ ಕಳುಹಿಸಿದ ಘಟಕಗಳ ಸಂಖ್ಯೆಯನ್ನು ನಿಖರವಾಗಿ ಖರೀದಿಸುತ್ತಾರೆ. ಸಂಭಾವ್ಯ ಖರೀದಿದಾರರು ವರ್ಗಾವಣೆಯ ಬಗ್ಗೆ ಸರಿಯಾದ ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಅನ್ನು ಕಳುಹಿಸಬೇಕು ಇದರಿಂದ ವಿನಿಮಯ ಭಾಗವಹಿಸುವವರು ದುಪ್ಪಟ್ಟು ಖರ್ಚು ಮಾಡುವುದನ್ನು ತಪ್ಪಿಸಬಹುದು. ಈ ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್‌ನಲ್ಲಿ, ಖರೀದಿದಾರನು ತನ್ನ ವಿಳಾಸಕ್ಕೆ ಸಮಾನವಾದ ಕೀಲಿಯ ಪ್ರಕಾರ, ವಿನಿಮಯದ ಭಾಗವಹಿಸುವವರ ಖಾತೆಗೆ ವರ್ಗಾಯಿಸಲಾದ ಆಯ್ಕೆಗಳ ಸಂಖ್ಯೆಗೆ ಸಮಾನವಾದ ಮೌಲ್ಯವನ್ನು ಇರಿಸುತ್ತಾನೆ, ಅಂದರೆ, ಅವನು ಖರೀದಿಸಬಹುದಾದ ಆಸ್ತಿ ಘಟಕಗಳ ಸಂಖ್ಯೆ.

ಸ್ಮಾರ್ಟ್ ಖಾತೆ ಕೋಡ್:

#владелец аккаунта дает обязательство продать определенное количество юнитов ассета
#по цене sellPrice между высотами блоков expirationStart и expirationEnd

let expirationStart = 100000
let expirationEnd = 101440
let sellPrice = 10000
let amountAsset = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let priceAsset = base58'9jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
#ID ассета-опциона
let optionsAsset = base58'7jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
#извлекаем из транзакции адрес отправителя
let this = tx.sender
match tx {
   case dataTx : DataTransaction =>
       #извлекаем количество юнитов из дата-транзакции по ключу (ID пользователя)
       let units = extract(getInteger(dataTx.data, dataTx.data[0].key))

       #извлекаем трансфер-транзакцию опционов из пруфа
       let e = transactionById(dataTx.proofs[2]) #
       match e {
           case transferTx : TransferTransaction =>
               #убеждаемся, что трансфер был на текущий адрес
               (transferTx.recipient == this) &&
               #убеждаемся, что отправитель транзакции написал в качестве ключа свой ID
               dataTx.data[0].key == toBase58String(transferTx.sender.bytes) &&
               sigVerify(dataTx.bodyBytes, dataTx.proofs[0], transferTx.senderPublicKey) &&
               #убеждаемся, что указанное количество юнитов соответствует посланному количеству опционов
               (units == transferTx.amount) &&
               #убеждаемся, что был переведен именно ассет-опцион
               (transferTx.assetId == optionsAsset)              
           case _ => false
       } &&
       size(dataTx.data) == 1 && !isDefined(getInteger(this, dataTx.data[0].key))
       && height > expirationStart && height <= expirationEnd
   case exchangeTx : ExchangeTransaction =>
       #убеждаемся, что итоговый обмен происходит по указанным заранее правилам
       let correctAssetPair = exchangeTx.sellOrder.assetPair.amountAsset == amountAsset &&
                                   exchangeTx.sellOrder.assetPair.priceAsset == priceAsset
       let correctPrice = exchangeTx.sellOrder.price == sellPrice
       #извлекаем дата-транзакцию из пруфа      
       let d = transactionById(exchangeTx.proofs[2])
       match d{
           case dataTx : DataTransaction =>
               let buyOrderSender = dataTx.data[0].key
               toBase58String(exchangeTx.buyOrder.sender.bytes) == buyOrderSender &&
               exchangeTx.amount == extract(getInteger(dataTx.data, buyOrderSender))
           case _ => false
       } &&
       exchangeTx.sellOrder.sender == this &&
       correctAssetPair && correctPrice &&
       height > expirationStart && height <= expirationEnd
   case _ => false
}

ಸ್ಮಾರ್ಟ್ ಖಾತೆಗಳಲ್ಲಿ ಭವಿಷ್ಯ

ಒಂದು ಆಯ್ಕೆಗಿಂತ ಭಿನ್ನವಾಗಿ, ಫ್ಯೂಚರ್ಸ್ (ಭವಿಷ್ಯದ ಒಪ್ಪಂದ) ಒಂದು ಹಕ್ಕಲ್ಲ, ಆದರೆ ಭವಿಷ್ಯದಲ್ಲಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಹಂತದಲ್ಲಿ ಒಪ್ಪಂದದ ಮೂಲಕ ನಿಗದಿಪಡಿಸಿದ ಬೆಲೆಗೆ ಆಸ್ತಿಯನ್ನು ಖರೀದಿಸಲು ಖರೀದಿದಾರನ ಬಾಧ್ಯತೆಯಾಗಿದೆ.

ಸಾಮಾನ್ಯವಾಗಿ, ಭವಿಷ್ಯವನ್ನು ಬರೆಯುವುದು ಆಯ್ಕೆಯನ್ನು ಬರೆಯುವುದಕ್ಕೆ ಹೋಲುತ್ತದೆ. ಇಲ್ಲಿ ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತು ಭವಿಷ್ಯದಂತೆ ಕಾರ್ಯನಿರ್ವಹಿಸುತ್ತದೆ.

ಖರೀದಿದಾರ ಮತ್ತು ಮಾರಾಟಗಾರ ಇಬ್ಬರೂ ಖರೀದಿ ಆದೇಶಕ್ಕೆ ಸಹಿ ಹಾಕಿದ್ದಾರೆಯೇ ಎಂದು ನೀವು ಖಚಿತಪಡಿಸಿಕೊಳ್ಳಬೇಕು. ಭವಿಷ್ಯವು ಯಾವುದೇ ಸಂದರ್ಭದಲ್ಲಿ ಪೂರೈಸಬೇಕಾದ ಬಾಧ್ಯತೆಯಾಗಿದೆ. ಇದರರ್ಥ ಮಾರಾಟಗಾರ ಅಥವಾ ಪಾಲ್ಗೊಳ್ಳುವವರು ತಮ್ಮ ಜವಾಬ್ದಾರಿಗಳನ್ನು ನಿರಾಕರಿಸಿದರೆ, ನೆಟ್ವರ್ಕ್ನಲ್ಲಿ ಯಾವುದೇ ಪಾಲ್ಗೊಳ್ಳುವವರು ವಹಿವಾಟನ್ನು ಕಳುಹಿಸಬಹುದು, ಹೀಗಾಗಿ ಭವಿಷ್ಯವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಬಹುದು.

ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತು ಸ್ಕ್ರಿಪ್ಟ್ ಭವಿಷ್ಯದ ಆಸ್ತಿಯ ಎಲ್ಲಾ ವರ್ಗಾವಣೆ ವಹಿವಾಟುಗಳು ಮತ್ತು ವಿನಿಮಯ ವಹಿವಾಟುಗಳನ್ನು ನಿಯಂತ್ರಿಸುತ್ತದೆ, ಖರೀದಿದಾರ ಭಾಗವಹಿಸುವವರು ವಿನಿಮಯದ ಭಾಗವಹಿಸುವವರಿಂದ ಭವಿಷ್ಯದ ಆಸ್ತಿಯ ಭವಿಷ್ಯದ ಖರೀದಿಗೆ ಆದೇಶವನ್ನು ರಚಿಸಿದ್ದರೆ ಮಾತ್ರ ಅವುಗಳನ್ನು ಅನುಮೋದಿಸುತ್ತದೆ.

ಈ ಆದೇಶವು ಮಾನ್ಯವಾಗಿರಬೇಕು ಮತ್ತು ಭವಿಷ್ಯವನ್ನು ನೀಡುವ ಷರತ್ತುಗಳನ್ನು ಪೂರೈಸಬೇಕು. ಆದೇಶವನ್ನು ಮೌಲ್ಯೀಕರಿಸಲು, ಸಹಿ ಮಾಡಿದ ಆದೇಶದ ಬೈಟ್ ಪ್ರಾತಿನಿಧ್ಯದೊಂದಿಗೆ ಖರೀದಿದಾರರ ಖಾತೆಯ ಸ್ಥಿತಿಗೆ ನೀವು ಅದರ ಎಲ್ಲಾ ಕ್ಷೇತ್ರಗಳನ್ನು ನಮೂದಿಸಬಹುದು ಮತ್ತು ನಂತರ ಬಾಹ್ಯ ಮೌಲ್ಯೀಕರಣವನ್ನು ನಿರ್ವಹಿಸಬಹುದು.

ಈ ಸಮಯದಲ್ಲಿ, RIDE ವಹಿವಾಟು ಬೈಟ್‌ಗಳನ್ನು ಪಾರ್ಸಿಂಗ್ ಮಾಡಲು ಸ್ಥಳೀಯ ಕಾರ್ಯವನ್ನು ಹೊಂದಿಲ್ಲ, ಆದರೆ ಅದರ ಅನುಷ್ಠಾನಕ್ಕೆ ಅಗತ್ಯವಾದ ಎಲ್ಲಾ ಸಾಧನಗಳನ್ನು ಒಳಗೊಂಡಿದೆ. ಆದ್ದರಿಂದ, ಅಭಿವರ್ಧಕರು ಈ ವೈಶಿಷ್ಟ್ಯವನ್ನು ಸ್ವತಃ ಕಾರ್ಯಗತಗೊಳಿಸಲು ಪ್ರಯತ್ನಿಸಬಹುದು.

ಬಹು-ಸಹಿ ಖಾತೆ / ಎಸ್ಕ್ರೊ

ಬಹು-ಸಹಿ ಖಾತೆಯು ಬಹು ಬಳಕೆದಾರರಿಗೆ ಜಂಟಿಯಾಗಿ ಸ್ವತ್ತುಗಳನ್ನು ನಿರ್ವಹಿಸಲು ಅನುಮತಿಸುತ್ತದೆ (ಉದಾಹರಣೆಗೆ, ನಾಲ್ಕು ಬಳಕೆದಾರರಲ್ಲಿ ಮೂವರು ಸಹಿಗಳನ್ನು ಹೊಂದಿದ್ದರೆ ಮಾತ್ರ ಸ್ವತ್ತುಗಳೊಂದಿಗೆ ವಹಿವಾಟುಗಳು ಸಾಧ್ಯ). RIDE ಭಾಷೆಯಲ್ಲಿ ಬಹು-ಸಹಿ ಖಾತೆಗಳನ್ನು ರಚಿಸಲು, ನಾವು ವಹಿವಾಟು ಪುರಾವೆಗಳನ್ನು ಬಳಸಬಹುದು.

ಬಹು-ಸಹಿ ಖಾತೆಯನ್ನು ಎಸ್ಕ್ರೊ ಖಾತೆಯಾಗಿಯೂ ಬಳಸಬಹುದು, ಇದರಲ್ಲಿ ಒಪ್ಪಂದದ ಪಕ್ಷಗಳು ತಮ್ಮ ಜವಾಬ್ದಾರಿಗಳನ್ನು ಪೂರೈಸುವವರೆಗೆ ಹಣವನ್ನು ಹಿಡಿದಿಟ್ಟುಕೊಳ್ಳಬಹುದು.

let alicePubKey  = base58'5AzfA9UfpWVYiwFwvdr77k6LWupSTGLb14b24oVdEpMM'
let bobPubKey    = base58'2KwU4vzdgPmKyf7q354H9kSyX9NZjNiq4qbnH2wi2VDF'
let cooperPubKey = base58'GbrUeGaBfmyFJjSQb9Z8uTCej5GzjXfRDVGJGrmgt5cD'
#выясняем, кто предоставил корректные подписи
let aliceSigned  = if(sigVerify(tx.bodyBytes, tx.proofs[0], alicePubKey)) then 1 else 0
let bobSigned    = if(sigVerify(tx.bodyBytes, tx.proofs[1], bobPubKey)) then 1 else 0
let cooperSigned = if(sigVerify(tx.bodyBytes, tx.proofs[2], cooperPubKey)) then 1 else 0
#суммируем все корректные подписи и проверяем их количество
aliceSigned + bobSigned + cooperSigned >= 2

ಟೋಕನ್ ಕ್ಯುರೇಟೆಡ್ ರಿಜಿಸ್ಟ್ರಿ (TCR)

ಅನೇಕ ಬ್ಲಾಕ್‌ಚೈನ್ ಪ್ಲಾಟ್‌ಫಾರ್ಮ್‌ಗಳು ವಿಷಕಾರಿ ಸ್ವತ್ತುಗಳೊಂದಿಗೆ ಸಮಸ್ಯೆಯನ್ನು ಹೊಂದಿವೆ. ಉದಾಹರಣೆಗೆ, ಆಯೋಗವನ್ನು ಪಾವತಿಸಿದ ಯಾವುದೇ ವಿಳಾಸವು ವೇವ್ಸ್‌ನಲ್ಲಿ ಆಸ್ತಿಯನ್ನು ರಚಿಸಬಹುದು.

ವಿಷಕಾರಿ ಸ್ವತ್ತುಗಳಿಂದ ಬಳಕೆದಾರರನ್ನು ಮತ್ತು ಬ್ಲಾಕ್‌ಚೈನ್ ಅನ್ನು ರಕ್ಷಿಸುವ ಸಮಸ್ಯೆಯನ್ನು ಟೋಕನ್ ಹೊಂದಿರುವವರು ರಚಿಸುವ ಟೋಕನ್ ಕ್ಯುರೇಟೆಡ್ ರಿಜಿಸ್ಟ್ರಿ (TCR) ಮೂಲಕ ಪರಿಹರಿಸಬಹುದು.

ಪಟ್ಟಿಗೆ ಸೇರಿಸಲು ನಿರ್ದಿಷ್ಟ ಟೋಕನ್‌ಗೆ ಮತ ಚಲಾಯಿಸಲು, ಹೋಲ್ಡರ್ ನೀಡಿದ ಒಟ್ಟು ಸಂಖ್ಯೆಯ ಟೋಕನ್‌ಗಳ ಪಾಲಿಗೆ ಸಮನಾದ ಬಿಡ್ ಅನ್ನು ಇರಿಸುತ್ತಾನೆ. ಬಹುಪಾಲು ಹೊಂದಿರುವವರು ಅದಕ್ಕೆ ಮತ ಚಲಾಯಿಸಿದರೆ ಟೋಕನ್ ಅನ್ನು ರಿಜಿಸ್ಟರ್‌ನಲ್ಲಿ ಸೇರಿಸಲಾಗುತ್ತದೆ.

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ರಾಜ್ಯ ಕೀ = asset_name ಅನ್ನು ಬಳಸಿಕೊಂಡು ಪರಿಗಣನೆಗೆ ("ಚಾಲೆಂಜ್" ಅವಧಿಯಲ್ಲಿ) ಪಟ್ಟಿಗೆ ಟೋಕನ್ ಅನ್ನು ಸೇರಿಸಲು ನಾವು ಬಳಕೆದಾರರಿಗೆ ಅವಕಾಶ ನೀಡುತ್ತೇವೆ, ಪ್ರಸ್ತುತ ಎಣಿಕೆಯ ಮೌಲ್ಯ = 0 ಆಗಿದ್ದರೆ ಮಾತ್ರ.

ಅಲ್ಲದೆ, ಬಳಕೆದಾರರು ತಮ್ಮ ವ್ಯಾಲೆಟ್‌ನಲ್ಲಿ ಈ ಟೋಕನ್‌ನ ಶೂನ್ಯವಲ್ಲದ ಸಮತೋಲನವನ್ನು ಹೊಂದಿರಬೇಕು. ನಂತರ ಮತದಾನದ ಅವಧಿ ಬರುತ್ತದೆ, ಈ ಸಮಯದಲ್ಲಿ ಬಳಕೆದಾರರು ತಮ್ಮ ವ್ಯಾಲೆಟ್‌ನಲ್ಲಿರುವ ಪ್ರತಿ ಸ್ವತ್ತಿಗೆ ಮತ ಚಲಾಯಿಸಬಹುದು, ಆದರೆ ಒಮ್ಮೆ ಮಾತ್ರ, 1 ರಿಂದ 10 ರವರೆಗಿನ ರೇಟಿಂಗ್ ಅನ್ನು ನೀಡುತ್ತಾರೆ. ಬಳಕೆದಾರ ಮತಗಳನ್ನು ಫಾರ್ಮ್ user_address+assetID ನ ಕೀಲಿಗಳಿಂದ ಪ್ರತಿನಿಧಿಸಲಾಗುತ್ತದೆ.

let asset = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let addingStartHeight = 1000
let votingStartHeight = 2000
let votingEndHeight = 3000

#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)

#извлекаем адрес из пруфа транзакции
let address = addressFromPublicKey(tx.proofs[1])
match tx {
   case t: DataTransaction =>
       if(height > addingStartHeight)
       then(
           if(height < votingStartHeight)
           then(
               #adding
               #выясняем, есть ли этот ассет у этого адреса
               let hasTokens = assetBalance(address, asset) > 0
               size(t.data) == 1
                     #убеждаемся, что этот ассет еще не был добавлен
                     && !isDefined(getInteger(this, toBase58String(asset)))
                     #убеждаемся, что по ключу-ассету добавляется значение равное 0
                     && extract(getInteger(t.data, toBase58String(asset))) == 0
                     && hasTokens
           )
           else(
               if(height < votingEndHeight)
               then
               (
                   #voting
                   #узнаем текущее количество голосов за данный ассет и задаваемое количество
                   let currentAmount = extract(getInteger(this, toBase58String(asset)))
                   let newAmount = extract(getInteger(t.data, toBase58String(asset)))
                   let betString = toBase58String(address.bytes) + toBase58String(asset)

                   #убеждаемся, что этот адрес еще не голосовал за этот ассет
                   let noBetBefore = !isDefined(getInteger(this, betString))
                   let isBetCorrect = extract(getInteger(t.data, betString)) > 0
                       && extract(getInteger(t.data, betString)) <= 10
                  
                   #убеждаемся, что у голосующего есть необходимые токены
                   let hasTokens = assetBalance(address, asset) > 0
                   #проверяем корректность значений транзакции
                   size(t.data) == 2 && isDefined(getInteger(this, toBase58String(asset)))
                       && newAmount == currentAmount + 1
                       && noBetBefore && isBetCorrect && hasTokens
               )
               else false
           ) && sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1])
       )
       else false
   case _ => false
}

ಚಂದಾದಾರಿಕೆ ಶುಲ್ಕ

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಿರ್ದಿಷ್ಟ ಮಧ್ಯಂತರಗಳಲ್ಲಿ ಉತ್ಪನ್ನ ಅಥವಾ ಸೇವೆಗಾಗಿ ನಿಯಮಿತ ಪಾವತಿಗಳನ್ನು ಮಾಡಲು ಸ್ಮಾರ್ಟ್ ಖಾತೆಗಳ ಬಳಕೆಯನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ - "ಚಂದಾದಾರಿಕೆ ಶುಲ್ಕಗಳು".
ಬಳಕೆದಾರರು ಸ್ಮಾರ್ಟ್ ಖಾತೆಯನ್ನು (ವಹಿವಾಟು ಪುರಾವೆಗಳ ಮೂಲಕ) ವರ್ಗಾಯಿಸಿದ ಹಣದ ಅಗತ್ಯವಿರುವ ಮೊತ್ತದ ಟ್ರಾನ್ಸ್‌ಫರ್ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಐಡಿಯೊಂದಿಗೆ ಒದಗಿಸಿದರೆ, ಅವರು ಖಾತೆಯ ಸ್ಥಿತಿಗೆ {ಕೀ: ವಿಳಾಸ, ಮೌಲ್ಯ:) ಬರೆಯಬಹುದು ನಿಜವಾದ}.

ಇದರರ್ಥ ಬಳಕೆದಾರರು ಉತ್ಪನ್ನ ಅಥವಾ ಸೇವೆಗೆ ತಮ್ಮ ಚಂದಾದಾರಿಕೆಯನ್ನು ದೃಢೀಕರಿಸುತ್ತಾರೆ. ಚಂದಾದಾರಿಕೆಯು ಮುಕ್ತಾಯಗೊಂಡಾಗ, ಯಾವುದೇ ನೆಟ್ವರ್ಕ್ ಬಳಕೆದಾರರು ರಾಜ್ಯದಲ್ಲಿ ಅನುಗುಣವಾದ ಕೀಲಿಯ ವಿರುದ್ಧ ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸಬಹುದು ಸುಳ್ಳು.

let subscriptionPeriod = 44000
let signature = tx.proofs[0]
let pk = tx.proofs[1]
let requiredAmount = 100000

#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
match tx {
   case d: DataTransaction =>
     #извлекаем дату последнего платежа
     let lastPaymentHeight = extract(getInteger(this, d.data[0].key + "_lastPayment"))
     size(d.data) == 1 && d.data[0].value == "false" && lastPaymentHeight + subscriptionPeriod < height
     ||
     (
       let address = d.data[0].key

       #извлекаем трансфер-транзакцию по ID, указанному в пруфах
       let ttx = transactionById(d.proofs[0])
       
       size(d.data) == 2
           && d.data[0].value == "true"
           && d.data[1].key == address + "_lastPayment"
           && match ttx {
             case purchase : TransferTransaction =>
               d.data[1].value == transactionHeightById(purchase.id)
               && toBase58String(purchase.sender.bytes) == address
               && purchase.amount == requiredAmount
               && purchase.recipient == this
               #убеждаемся, что ассет waves
               && !isDefined(purchase.assetId)
         case _ => false
       }
     )
   case _ => false
}

ಮತ ಚಲಾಯಿಸಿ

ಬ್ಲಾಕ್‌ಚೈನ್‌ನಲ್ಲಿ ಮತದಾನವನ್ನು ಕಾರ್ಯಗತಗೊಳಿಸಲು ಸ್ಮಾರ್ಟ್ ಖಾತೆಗಳನ್ನು ಬಳಸಬಹುದು. ರಾಯಭಾರಿ ಕಾರ್ಯಕ್ರಮದೊಳಗೆ ಅತ್ಯುತ್ತಮ ರಾಯಭಾರಿ ವರದಿಗಾಗಿ ಮತದಾನ ಮಾಡುವುದು ಒಂದು ಉದಾಹರಣೆಯಾಗಿದೆ. ಖಾತೆಯ ಸ್ಥಿತಿಯನ್ನು ನಿರ್ದಿಷ್ಟ ಆಯ್ಕೆಗಾಗಿ ಮತಗಳನ್ನು ದಾಖಲಿಸಲು ವೇದಿಕೆಯಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ.

ಈ ಉದಾಹರಣೆಯಲ್ಲಿ, ವಿಶೇಷ "ಮತದಾನ" ಟೋಕನ್‌ಗಳನ್ನು ಖರೀದಿಸಿದವರಿಗೆ ಮಾತ್ರ ಮತ ಚಲಾಯಿಸಲು ಅನುಮತಿಸಲಾಗಿದೆ. ಭಾಗವಹಿಸುವವರು ಜೋಡಿ (ಕೀ, ಮೌಲ್ಯ) = (ಖರೀದಿ ಟ್ರಾನ್ಸಾಕ್ಷನ್ ಐಡಿ, ಖರೀದಿ ವಹಿವಾಟು ಐಡಿ) ಯೊಂದಿಗೆ ಮುಂಚಿತವಾಗಿ ಡೇಟಾ ವಹಿವಾಟನ್ನು ಕಳುಹಿಸುತ್ತಾರೆ. ಈ ಕೀಲಿಗಾಗಿ ಮತ್ತೊಂದು ಮೌಲ್ಯವನ್ನು ಹೊಂದಿಸುವುದನ್ನು ನಿಷೇಧಿಸಲಾಗಿದೆ. ನಿಮ್ಮ ವಿಳಾಸ ಮತ್ತು ಮತದಾನದ ಆಯ್ಕೆಯನ್ನು ಬಳಸಿಕೊಂಡು, ನೀವು ಒಮ್ಮೆ ಮಾತ್ರ ಡೇಟಾಎಂಟ್ರಿಯನ್ನು ಹೊಂದಿಸಬಹುದು. ನಿಗದಿತ ಅವಧಿಯಲ್ಲಿ ಮಾತ್ರ ಮತದಾನಕ್ಕೆ ಅವಕಾಶವಿದೆ.

let asset = base58'8jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
let address = addressFromPublicKey(tx.proofs[1])
let votingStartHeight = 2000
let votingEndHeight = 3000

#извлекаем из транзакции адрес отправителя
let this = extract(tx.sender)
 match tx {
   case t: DataTransaction =>
     (height > votingStartHeight && height < votingEndHeight) &&
     #убеждаемся, что у транзакции правильная подпись
     sigVerify(tx.bodyBytes, tx.proofs[0], tx.proofs[1]) &&

     #проверяем, что пользователь отдает свой голос напротив своего адреса
     if (t.data[0].key == toBase58String(address.bytes))
     then (
       #извлекаем транзакцию перевод голосовательного токена из пруфов
       let purchaseTx = transactionById(t.proofs[7])
       
       match purchaseTx {
         case purchase : TransferTransaction =>
           let correctSender = purchase.sender == t.sender
           let correctAsset = purchase.assetId == asset
           let correctPrice = purchase.amount == 1
           let correctProof = extract(getBinary(this, toBase58String(purchase.id))) == t.id
           correctSender && correctAsset && correctPrice && correctProof
         case _ => false
       }
     )
     else
         size(t.data) == 1 && !isDefined(getBinary(this, t.data[0].key))
   case _ => false
}

ಪ್ರಾಮಿಸರಿ ಟಿಪ್ಪಣಿ

ಪ್ರಾಮಿಸರಿ ನೋಟ್ ಎನ್ನುವುದು ಲಿಖಿತ ಬಾಧ್ಯತೆಯಾಗಿದ್ದು, ಒಂದು ಪಕ್ಷವು ಬೇಡಿಕೆಯ ಮೇರೆಗೆ ಅಥವಾ ಪೂರ್ವನಿರ್ಧರಿತ ದಿನಾಂಕದಂದು ನಿಗದಿತ ಮೊತ್ತವನ್ನು ಪಾವತಿಸಲು ಅಗತ್ಯವಿದೆ.

ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ನಾವು ಸ್ಮಾರ್ಟ್ ಖಾತೆಯನ್ನು ಬಳಸುತ್ತೇವೆ, ಅದರ ಮುಕ್ತಾಯ ದಿನಾಂಕವು ಬಿಲ್ ಪಾವತಿ ದಿನಾಂಕಕ್ಕೆ ಅನುರೂಪವಾಗಿದೆ.

let expiration = 100000
let amount = 10
let asset =  base58'9jfD2JBLe23XtCCSQoTx5eAW5QCU6Mbxi3r78aNQLcNf'
  
let Bob = Address(base58'3NBVqYXrapgJP9atQccdBPAgJPwHDKkh6A8')
let Alice = Address(base58'3PNX6XwMeEXaaP1rf5MCk8weYeF7z2vJZBg')
  
match tx {
    case t: TransferTransaction =>
        (t.assetId == asset)&&      
        (t.amount == amount)&&       
        (t.sender == Bob)&&
        (t.recipient == Alice)&&
        (sigVerify(t.bodyBytes, t.proofs[0], t.senderPublicKey))&&
        (height >= expiration)
    case _ => false
}

ಠೇವಣಿ

ಠೇವಣಿ ಎಂದರೆ ಕೆಲವು ಷರತ್ತುಗಳ ಅಡಿಯಲ್ಲಿ (ಅವಧಿ, ಬಡ್ಡಿ) ಬ್ಯಾಂಕಿನಲ್ಲಿ ನಿಧಿಗಳ ನಿಯೋಜನೆ.
ನಮ್ಮ ಉದಾಹರಣೆಯಲ್ಲಿ, ಬ್ಯಾಂಕಿನ ಕಾರ್ಯವನ್ನು ಸ್ಮಾರ್ಟ್ ಖಾತೆಯಿಂದ ನಿರ್ವಹಿಸಲಾಗುತ್ತದೆ. ಠೇವಣಿ ಅವಧಿಗೆ ಅನುರೂಪವಾಗಿರುವ ನಿರ್ದಿಷ್ಟ ಸಂಖ್ಯೆಯ ಬ್ಲಾಕ್‌ಗಳ ನಂತರ, ಬಳಕೆದಾರರು ತಮ್ಮ ಹಣವನ್ನು ಬಡ್ಡಿಯೊಂದಿಗೆ ಹಿಂದಿರುಗಿಸಬಹುದು. ಸ್ಕ್ರಿಪ್ಟ್ ಬ್ಲಾಕ್ ಎತ್ತರವನ್ನು (ಫೈನಲ್ ಹೈಟ್) ನಿರ್ದಿಷ್ಟಪಡಿಸುತ್ತದೆ, ಅದನ್ನು ತಲುಪಿದ ನಂತರ ಬಳಕೆದಾರರು ಖಾತೆಯಿಂದ ಹಣವನ್ನು ಹಿಂಪಡೆಯಬಹುದು.

ಎತ್ತರ ಘಟಕ - ಸಮಯದ ಒಂದು ಘಟಕದಲ್ಲಿನ ಬ್ಲಾಕ್‌ಗಳ ಸಂಖ್ಯೆ (ಉದಾಹರಣೆಗೆ, ತಿಂಗಳು, ವರ್ಷ, ಇತ್ಯಾದಿ). ಮೊದಲಿಗೆ ನಾವು ಜೋಡಿಯೊಂದಿಗೆ ನಮೂದನ್ನು ಪರಿಶೀಲಿಸುತ್ತೇವೆ (ಕೀ, ಮೌಲ್ಯ) = (ಆರಂಭಿಕ ವರ್ಗಾವಣೆ ವಹಿವಾಟು, ಭವಿಷ್ಯದ ಡೇಟಾ ಟ್ರಾನ್ಸಾಕ್ಷನ್). ಬಳಕೆದಾರರು ನಂತರ ಠೇವಣಿ ಮೊತ್ತ ಮತ್ತು ಠೇವಣಿ ಅವಧಿಗೆ ಸಂಗ್ರಹವಾದ ಬಡ್ಡಿಯ ಬಗ್ಗೆ ಸರಿಯಾದ ಮಾಹಿತಿಯೊಂದಿಗೆ ವರ್ಗಾವಣೆ ವಹಿವಾಟನ್ನು ಸಲ್ಲಿಸಬೇಕು. ಈ ಮಾಹಿತಿಯನ್ನು ಮೂಲ ವರ್ಗಾವಣೆ ವಹಿವಾಟಿನ ವಿರುದ್ಧ ಪರಿಶೀಲಿಸಲಾಗಿದೆ, ಇದು ಪ್ರಸ್ತುತ ವರ್ಗಾವಣೆಯ ಪುರಾವೆಯಲ್ಲಿದೆ. ಠೇವಣಿ ವಿಭಜಕವು ಠೇವಣಿ ಷೇರಿನ ವಿಲೋಮ ಸಂಖ್ಯೆಯಾಗಿದೆ (ಠೇವಣಿ 10% ಕ್ಕೆ ಸ್ವೀಕರಿಸಲ್ಪಟ್ಟರೆ, ಠೇವಣಿ ಪಾಲು 0,1, ಮತ್ತು ಠೇವಣಿ ಡಿವೈಸರ್ = 1/0,1 = 10).

let this = extract(tx.sender)
let depositDivisor = 10
let heightUnit = 1000
let finalHeight = 100000
 match tx {
   case e : TransferTransaction =>
     #извлекаем высоту транзакции по ID транзакции в седьмом пруфе  
     let depositHeight = extract(transactionHeightById(e.proofs[7]))

     #извлекаем транзакцию депозита
     let purchaseTx = transactionById(e.proofs[7])    
     match purchaseTx {
       case deposit : TransferTransaction =>
         let correctSender = deposit.sender == e.sender
         #убеждаемся, что пользователь переводит себе корректную сумму депозита + проценты
         let correctAmount = deposit.amount + deposit.amount / depositDivisor * (height - depositHeight) / heightUnit == e.amount
         let correctProof = extract(getBinary(this, toBase58String(deposit.id))) == e.id
         correctSender && correctProof && correctAmount
       case _ => false
     }
     && finalHeight <= height 
 case _ => sigVerify(tx.bodyBytes, tx.proofs[0], tx.senderPublicKey)
}

ಈ ಸರಣಿಯ ಮೂರನೇ ಮತ್ತು ಅಂತಿಮ ಲೇಖನದಲ್ಲಿ, ನಿರ್ದಿಷ್ಟ ವಿಳಾಸಗಳಿಗಾಗಿ ಫ್ರೀಜ್ ಮಾಡುವುದು ಮತ್ತು ವಹಿವಾಟುಗಳನ್ನು ಸೀಮಿತಗೊಳಿಸುವುದು ಸೇರಿದಂತೆ ಸ್ಮಾರ್ಟ್ ಸ್ವತ್ತುಗಳ ಹೆಚ್ಚಿನ ಬಳಕೆಗಳನ್ನು ನಾವು ನೋಡುತ್ತೇವೆ.

ಮೂಲ: www.habr.com