ProHoster > Actifs intelligents Waves : listes noire et blanche, trading par intervalles

Actifs intelligents Waves : listes noire et blanche, trading par intervalles

Actifs intelligents Waves : listes noire et blanche, trading par intervalles

Dans les deux articles précédents, nous avons parlé des comptes intelligents et de la manière dont ils peuvent être utilisés pour organiser des enchères et créer des programmes de fidélitéet aussi aider assurer la transparence des instruments financiers.

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

Waves Smart Assets permet aux utilisateurs de superposer des scripts sur des actifs, en suivant les mêmes mécanismes que les comptes Smart. Chaque nouvelle transaction créée à l'aide d'un actif intelligent sera d'abord confirmée par le script, puis ensuite seulement par la blockchain.

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

  1. Dans le code d'un actif intelligent, il est impossible de vérifier les preuves (nous en avons parlé dans le premier article).
  2. Dans le code du compte intelligent, vous pouvez vérifier ExchangeTransaction uniquement si votre compte est un compte correspondant. Dans le cas contraire, seule la commande est vérifiée. Dans le code de l'actif intelligent, vous ne pouvez pas vérifier directement la commande ; vous pouvez vérifier l'ExchangeTransaction et, si nécessaire, en extraire une 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 grandement la rédaction des contrats, rendant la mise en œuvre de nombreux cas concise et élégante.

Gel des avoirs

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

let targetHeight = 1500000
height >= targetHeight
 
height - функция языка, возращающая текущую высоту.

Condition spécifique au matcheur

Pour définir un correspondant spécifique comme celui souhaité, vous pouvez définir son adresse en tant qu'expéditeur dans un script d'actif intelligent qui ressemble à ceci :

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'inclusion 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 d'exhaustivité prouvable du langage, la liste ne contient pas d'implémentation d'itérateur. Il est donc défini comme un ensemble d’éléments concrets.

"Liste noire" des destinataires

De même, pour interdire l’envoi de tokens vers certains comptes, vous pouvez créer une « liste noire ». Dans ce cas, exactement le même actif intelligent est utilisé, mais avec l'adresse vérifiée pour s'assurer qu'elle ne figure pas 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 autorisation de l'émetteur

À l'aide d'un actif intelligent, vous pouvez également définir l'option permettant d'envoyer un actif intelligent uniquement avec l'autorisation de l'émetteur. (libellé engagement/dette). L'émetteur exprime son consentement en plaçant l'identifiant de la transaction dans l'état 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 uniquement l’échange de 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
}

Trading par prix de l'oracle

Dans le script d'actifs intelligents, vous pouvez définir l'autorisation de négocier uniquement au prix fixé dans l'état d'un oracle fiable. 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
}

Nous sommes ici confrontés à un point non évident lors de la vérification de l'identifiant de l'actif avec lequel le trading est effectué. Le fait est que si l’ID de l’actif n’est pas défini, alors nous parlons de WAVES. Dans le script, nous veillons à ce que le trading soit effectué en tandem avec WAVES, exactement de cette manière.

Augmentation du prix fixe

Vous pouvez fixer 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
}

Trading par intervalles

De plus, grâce au script, la négociation d'un actif intelligent peut être limitée à 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 dès le début du trading hauteur de départ pas plus que limite intervalles. La longueur de l'intervalle est égale au nombre de blocs spécifié dans le champ intervalle.

Source: habr.com

Ajouter un commentaire