Negli articoli precedenti abbiamo descritto i conti smart e come possono essere utilizzati , oltre a contribuire .
Attualmente esamineremo i smart asset e alcuni casi d'uso, inclusi il congelamento degli asset e la creazione di restrizioni sulle transazioni verso indirizzi specifici.
I smart asset Waves consentono agli utenti di applicare script sugli asset, seguendo la stessa meccanica dei conti smart. Ogni nuova transazione creata utilizzando un smart asset sarà confermata prima dallo script e solo dopo dalla blockchain.
È importante notare le seguenti differenze tra i smart asset e i conti smart:
- Nel codice del smart asset non è possibile effettuare un controllo delle prove (di cui abbiamo parlato ).
- Nel codice dello smart account è possibile verificare l'ExchangeTransaction solo se il tuo account è un account corrispondente. Altrimenti, viene controllato solo l'ordine. Nel codice dello smart asset non è possibile controllare direttamente l'ordine, ma è possibile verificare l'ExchangeTransaction e, se necessario, estrarre l'ordine da essa.
- Lo smart asset, a differenza dello smart account, non ha uno stato, ma abbiamo comunque accesso agli stati degli account dallo script.
Gli smart asset semplificano notevolmente la scrittura dei contratti, rendendo l'implementazione di molti casi concisa ed elegante.
Congelamento degli asset
Per congelare gli asset fino a un'altezza di blocco specificata targetHeight, puoi semplicemente impostare questo valore nel codice del seguente smart asset:
let targetHeight = 1500000
height >= targetHeight
height - funzione del linguaggio che restituisce l'attuale altezza.
Condizione di un corrispondente specifico
Per impostare un corrispondente specifico desiderato, puoi specificare il suo indirizzo come mittente nel codice dello smart asset di seguito:
match tx {
case t : ExchangeTransaction =>
t.sender == addressFromString("3PJaDyprvekvPXPuAtxrapacuDJopgJRaU3")
case _ => true
}
«Whitelist» dei destinatari
Per consentire l'invio di token solo a determinati indirizzi — creando una «lista bianca» di destinatari — puoi utilizzare un smart asset con il seguente schema, che verifica l'appartenenza alla 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 motivi di sicurezza e per garantire la visibilità del linguaggio, la lista non contiene implementazioni di iteratori. Pertanto, è definita come un insieme di elementi specifici.
«Lista nera» dei destinatari
Allo stesso modo, per vietare l'invio di token a determinati indirizzi, puoi creare una «lista nera». Anche in questo caso si utilizza un smart asset identico, ma con un controllo per verificare che l’indirizzo non sia presente nella 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 l'autorizzazione dell'emittente
Con l'asseta smart è possibile anche impostare l'opzione di invio dell'asseta smart solo con l'autorizzazione dell'emittente (etichetta di impegno/debito). L'emittente esprime il proprio consenso inserendo l'ID della transazione nello stato del proprio account:
match tx {
case t : TransferTransaction =>
let issuer = extract(addressFromString("3P6ms9EotRX8JwSrebeTXYVnzpsGCrKWLv4"))
#verifichiamo che nello stato dell'emittente sia presente l'ID della transazione corrente
isDefined(getInteger(issuer, toBase58String(t.id)))
case _ => false
}
Scambio solo per determinate monete
L'asseta smart consente di autorizzare lo scambio solo per determinate monete. Ad esempio, per consentire lo scambio solo di bitcoin, è possibile 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
}
Commercio al prezzo dell'oracolo
Nel codice dell'asseta smart è possibile impostare l'autorizzazione a commerciare 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 {
#vietiamo il trasferimento dell'asset
case t: TransferTransaction | MassTransferTransaction => false
case e: ExchangeTransaction =>
#verifichiamo che il trading avvenga al prezzo stabilito nello stato dell'oracolo per questo asset
let correctPrice = e.price == extract(getInteger(oracle, assetId))
#verifichiamo che il trading avvenga in cambio di WAVES
let correctPriceAsset = !isDefined(e.sellOrder.assetPair.priceAsset)
correctPrice && correctPriceAsset
case _ => true
}
Qui ci troviamo di fronte a un punto non ovvio durante la verifica dell'ID dell'asset con cui si sta negoziando. Infatti, se l'ID dell'asset non è definito, si parla di WAVES. Nel nostro script ci assicuriamo che il trading avvenga in coppia con WAVES, proprio in questo modo.
Incremento di prezzo fisso
È possibile impostare un prezzo fisso per lo smart asset, che aumenterà gradualmente in una proporzione definita. Ecco un esempio di script di un asset il cui prezzo aumenterà del 5% ogni 1000 blocchi:
let startPrice = 10
let startHeight = 1000
let interval = 1000
#di quanti punti percentuali il prezzo aumenta ad ogni passaggio
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 interventistico
Inoltre, grazie allo script, il trading dell'asset intelligente può essere limitato a intervalli prestabiliti. 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 true
}
Nello script ci assicuriamo che dall'inizio del trading startHeight non siano passati più di limit intervalli. La lunghezza dell'intervallo è pari al numero di blocchi indicato nel campo interval.
Fonte: habr.com
