Waves Smart Assets: listes noires et blanches, trading par intervalles

Dans deux articles précédents, nous avons parlé des comptes intelligents et de la façon dont ils peuvent être utilisés pour mener des enchères et créer des programmes de fidélité , et également contribuer à assurer la transparence des instruments financiers .

Nous allons maintenant examiner les actifs intelligents et plusieurs cas de leur application, y compris le gel des actifs et la création de restrictions sur les transactions à des adresses spécifiées.

Les actifs intelligents Waves permettent aux utilisateurs de superposer des scripts sur les actifs, en suivant la même mécanique qu'avec les comptes intelligents. Chaque nouvelle transaction créée à l'aide de l'actif intelligent sera confirmée d'abord par le script, puis seulement par la blockchain.

Il convient de noter les différences suivantes entre les actifs intelligents et les comptes intelligents:

1. Il est impossible de vérifier les preuves dans le code d'actif intelligent (nous en avons parlé dans le premier article ).
2. Dans le code du compte intelligent, vous ne pouvez vérifier ExchangeTransaction que si votre compte est un compte de correspondance. Sinon, seule la commande est vérifiée. Vous ne pouvez pas vérifier la commande directement dans le code d'actif intelligent, vous pouvez vérifier ExchangeTransaction et, si nécessaire, en extraire la commande.
3. Un actif intelligent, contrairement à un compte intelligent, n'a pas d'état, mais nous avons toujours accès aux états du compte à partir du script.

Les actifs intelligents simplifient considérablement la rédaction des contrats, rendant la mise en œuvre de nombreux cas concise et élégante.

Gel des avoirs

Pour figer les actifs à une certaine hauteur de bloc targetHeight , vous pouvez simplement définir cette valeur dans le script de l'actif intelligent suivant:

let targetHeight = 1500000 height >= targetHeight height -  ,   . 

Condition de correspondance spécifique

Pour définir une correspondance spécifique comme vous le souhaitez, vous pouvez définir son adresse en tant qu'expéditeur dans le script d'actif intelligent du formulaire suivant:

 match tx { case t : ExchangeTransaction => t.sender == addressFromString("3PJaDyprvekvPXPuAtxrapacuDJopgJRaU3") case _ => true } 

Liste blanche des destinataires

Pour autoriser l'envoi de jetons uniquement à certains comptes - pour créer une «liste blanche» de destinataires - vous pouvez utiliser un actif intelligent avec le schéma suivant, qui vérifie l'entrée dans la liste:

 match tx { case t : TransferTransaction => let trustedRecipient1 = addressFromString("3P6ms9EotRX8JwSrebeTXYVnzpsGCrKWLv4") let trustedRecipient2 = addressFromString("3PLZcCJyYQnfWfzhKXRA4rteCQC9J1ewf5K") let trustedRecipient3 = addressFromString("3PHrS6VNPRtUD8MHkfkmELavL8JnGtSq5sx") t.recipient == trustedRecipient1 || t.recipient == trustedRecipient2 || t.recipient == trustedRecipient3 case _ => false } 

Pour des raisons de sécurité et de cohérence du langage, la liste ne contient pas d'implémentation d'itérateur. Par conséquent, il est défini comme un ensemble d'éléments spécifiques.

Destinataires de la liste noire

De même, pour interdire l'envoi de tokens à certains comptes, vous pouvez créer une «liste noire». Dans ce cas, le même actif intelligent est utilisé, mais avec l'adresse vérifiée pour l'absence sur la liste noire:

 match tx { case t : TransferTransaction => let bannedRecipient1 = addressFromString("3P6ms9EotRX8JwSrebeTXYVnzpsGCrKWLv4") let bannedRecipient2 = addressFromString("3PLZcCJyYQnfWfzhKXRA4rteCQC9J1ewf5K") let bannedRecipient3 = addressFromString("3PHrS6VNPRtUD8MHkfkmELavL8JnGtSq5sx") t.recipient != bannedRecipient1 && t.recipient != bannedRecipient2 && t.recipient != bannedRecipient3 case _ => false } 

Envoi avec la permission de l'émetteur

À l'aide d'un actif intelligent, vous pouvez également définir l'option d'envoi d'un actif intelligent uniquement avec la permission de l'émetteur (étiquette d'engagement / de dette ). L'émetteur exprime son consentement en plaçant l'ID de transaction dans le style de son compte:

 match tx { case t : TransferTransaction => let issuer = extract(addressFromString("3P6ms9EotRX8JwSrebeTXYVnzpsGCrKWLv4")) #,      ID   isDefined(getInteger(issuer, toBase58String(t.id))) case _ => false } 

Échangez uniquement contre certaines pièces

Un actif intelligent permet de l'échanger uniquement contre certaines pièces. Par exemple, pour autoriser l'échange uniquement pour les bitcoins, vous pouvez utiliser le code suivant:

 let BTCId = base58'8LQW8f7P5d5PZM7GtZEBgaqRPGSzS3DfPuiXrURJ4AJS' match tx { case t : ExchangeTransaction => t.sellOrder.assetPair.priceAsset == BTCId || t.sellOrder.assetPair.amountAsset == BTCId case _ => true } 

Commerce au prix d'Oracle

Dans le script d'actif intelligent, vous pouvez définir l'autorisation de négocier uniquement au prix fixé dans l'histoire fiable d'Oracle. Voici un exemple d'un tel script:

 let oracle = Address(base58'3PLNmokt22NrSiNvCLvwMUP84LCMJqbXwAD') let assetId = toBase58String(base58'oWgJN6YGZFtZrV8BWQ1PGktZikgg7jzGmtm16Ktyvjd') match tx { #   case t: TransferTransaction | MassTransferTransaction => false case e: ExchangeTransaction => #,     ,        let correctPrice = e.price == extract(getInteger(oracle, assetId)) #,       WAVES let correctPriceAsset = !isDefined(e.sellOrder.assetPair.priceAsset) correctPrice && correctPriceAsset case _ => true } 

Ici, nous sommes confrontés à un moment non évident lors de la vérification de l'ID de l'actif avec lequel le commerce est effectué. Le fait est que si l'ID de l'actif n'est pas défini, alors nous parlons d'ONDES. Dans le script, nous nous assurons que le trading est couplé avec WAVES, de cette manière.

Augmentation du prix fixe

Vous pouvez définir un prix fixe pour un actif intelligent, qui augmentera progressivement dans une proportion donnée. Voici un exemple de script d'actif, dont le prix augmentera de 5% tous les 1000 blocs:

 let startPrice = 10 let startHeight = 1000 let interval = 1000 #        let raise = 5 match tx { case t: TransferTransaction | MassTransferTransaction => false case e: ExchangeTransaction => e.price == startPrice + ((height - startHeight) / interval) * (100 + raise) / 100 && !isDefined(e.sellOrder.assetPair.priceAsset) case _ => true } 

Commerce à intervalles

De plus, grâce au script, le trading d'actifs intelligents peut être limité à des intervalles prédéterminés. Voici un exemple d'un tel script:

 let startHeight = 10000 let interval = 44000 let limit = 1500 match tx { case t: TransferTransaction | MassTransferTransaction | ExchangeTransaction => (height - startHeight) % interval < limit case _ => true } 

Dans le script, nous nous assurons que pas plus d'un intervalle limite ne s'est écoulé depuis le début de la négociation startHeight . La longueur d'intervalle est égale au nombre de blocs spécifié dans le champ d' intervalle .