ProHoster > Waves asset intelligenti: liste nere e bianche, trading a intervalli

Waves asset intelligenti: liste nere e bianche, trading a intervalli

Waves asset intelligenti: liste nere e bianche, trading a intervalli

Nei due articoli precedenti abbiamo parlato degli smart account e di come possono essere utilizzati per organizzare aste e creare programmi fedeltàe anche aiutare garantire la trasparenza degli strumenti finanziari.

Ora esamineremo gli asset intelligenti e diversi casi del loro utilizzo, incluso il congelamento degli asset e la creazione di restrizioni sulle transazioni a indirizzi specifici.

Waves Smart Assets consente agli utenti di sovrapporre script alle risorse, seguendo la stessa meccanica degli Smart Account. Ogni nuova transazione creata utilizzando uno smart asset verrà confermata prima dallo script e solo successivamente dalla blockchain.

Vale la pena notare le seguenti differenze tra risorse intelligenti e account intelligenti:

  1. Nel codice di uno smart asset è impossibile verificare le prove (ne abbiamo parlato nel primo articolo).
  2. Nel codice dell'account intelligente, puoi controllare ExchangeTransaction solo se il tuo account è un account corrispondente. Altrimenti viene controllato solo l'ordine. Nel codice smart asset non è possibile controllare direttamente l'ordine; è possibile controllare la ExchangeTransaction e, se necessario, estrarre un ordine da essa.
  3. Una risorsa intelligente, a differenza di un account intelligente, non ha uno stato, ma abbiamo comunque accesso agli stati dell'account dallo script.

Gli asset intelligenti semplificano notevolmente la stesura dei contratti, rendendo l’implementazione di molti casi concisa ed elegante.

Congelamento dei beni

Per congelare le risorse a una determinata altezza di blocco targetHeight, puoi semplicemente impostare questo valore nello script della seguente risorsa intelligente:

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

Condizione specifica del matcher

Per impostare un corrispondente specifico come quello desiderato, puoi impostare il suo indirizzo come mittente in uno script di risorse intelligenti simile al seguente:

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

"Lista bianca" dei destinatari

Per consentire l'invio dei token solo a determinati account – per creare una “lista bianca” di destinatari – è possibile utilizzare uno smart asset con il seguente schema che verifica l'inclusione nella lista:

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
}

Per ragioni di sicurezza e completezza dimostrabile del linguaggio, l'elenco non contiene un'implementazione dell'iteratore. Pertanto si definisce come un insieme di elementi concreti.

"Lista nera" dei destinatari

Allo stesso modo, per vietare l’invio di token a determinati account, è possibile creare una “lista nera”. In questo caso, viene utilizzata esattamente la stessa risorsa intelligente, ma con l'indirizzo controllato per garantire che non sia sulla lista nera:

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
}

Invio con il permesso dell'emittente

Utilizzando una risorsa intelligente, puoi anche impostare l'opzione per inviare una risorsa intelligente solo con il permesso dell'emittente (etichetta impegno/debito). L'emittente esprime il proprio consenso inserendo l'ID della transazione nello stato del proprio conto:

match tx {
  case t : TransferTransaction =>
    let issuer = extract(addressFromString("3P6ms9EotRX8JwSrebeTXYVnzpsGCrKWLv4"))
    #убеждаемся, что в стейте эмитента содержится ID текущей транзакции
    isDefined(getInteger(issuer, toBase58String(t.id)))
  case _ => false
}

Scambia solo con determinate monete

Una risorsa intelligente consente il permesso di scambiarla solo con determinate monete. Ad esempio, per consentire solo lo scambio con Bitcoin, potresti utilizzare il seguente codice:

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

Trading in base al prezzo dall'oracolo

Nello script delle risorse intelligenti, puoi impostare l'autorizzazione per fare trading solo al prezzo fissato nello stato di un oracolo affidabile. Ecco un esempio di tale 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
}

Qui ci troviamo di fronte ad un punto non ovvio quando si verifica l’ID dell’asset con cui si effettua la negoziazione. Il punto è che se l'asset ID non è definito, allora parliamo di WAVES. Nello script ci assicuriamo che il trading venga effettuato in tandem con WAVES, esattamente in questo modo.

Aumento fisso del prezzo

Puoi impostare un prezzo fisso per una risorsa intelligente, che aumenterà passo dopo passo in una determinata proporzione. Ecco un esempio di uno script di asset il cui prezzo aumenterà del 5% ogni 1000 blocchi:

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
}

Negoziazione a intervalli

Inoltre, grazie allo script, la negoziazione di uno smart asset può essere limitata a intervalli predeterminati. Ecco un esempio di tale script:

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

Nello script ci assicuriamo che fin dall'inizio del trading startHeight non più di limitare intervalli. La lunghezza dell'intervallo è uguale al numero di blocchi specificati nel campo intervallo.

Fonte: habr.com

Aggiungi un commento