Plutus.V1.Ledger.Address

Table des matières

  • 1 Aperçu

  • 2 Extensions du langage et importations

  • 3 Structures de données

    • 3.1 Exemple de newtype

    • 3.2 Exemple de synonyme de type

    • 3.3 Exemple de type data

    • 3.4 Type de données Address

  • 4 ⚙️ Fonctions

    • 4.1 pubKeyHashAddress

    • 4.2 toPubKeyHash

    • 4.3 toValidatorHash

    • 4.4 scriptHashAddress

    • 4.5 stakingCredential

  • 5 Instances de classes de type

  • 6 Glossaire

1 Aperçu

Ce tutoriel présente un script Address Plutus en Haskell :

  • Définit un type de données Address personnalisé avec des credentials de paiement et de staking.

  • Implémente des fonctions utilitaires pour construire et interroger des adresses.

  • Montre comment dériver les instances pour les données on-chain (IsData) et le lifting.

  • Explique les extensions de langage, les importations et les classes de type associées.

Il illustre également des exemples basiques de définitions newtype, de synonymes de type et de types algébriques data pour comparaison.

2 Extensions du langage et importations

{-# LANGUAGE DerivingStrategies #-}
{-# LANGUAGE DeriveAnyClass    #-}
{-# LANGUAGE TemplateHaskell   #-}
{-# LANGUAGE OverloadedStrings #-}
{-# LANGUAGE INLINABLE         #-}

  • DerivingStrategies : choisit entre stock et anyclass pour le dérivé.

  • DeriveAnyClass : permet de dériver des classes comme NFData.

  • TemplateHaskell : utilisé par PlutusTx.makeIsDataIndexed et makeLift pour le code on-chain.

  • OverloadedStrings : pour des littéraux de chaîne pratiques avec Prettyprinter.

  • INLINABLE pragma : marque les fonctions pour la compilation et l’optimisation on-chain.

Imports :

import Control.DeepSeq (NFData)
import GHC.Generics    (Generic)
import PlutusTx        qualified
import PlutusTx.Bool   qualified as PlutusTx
import PlutusTx.Eq     qualified as PlutusTx
import Prettyprinter

import Plutus.V1.Ledger.Credential (Credential(..), StakingCredential)
import Plutus.V1.Ledger.Crypto
import Plutus.V1.Ledger.Scripts

  • NFData, Generic : pour une évaluation stricte et un dérivé générique.

  • Modules PlutusTx : utilitaires on-chain (Bool, Eq, makeIsDataIndexed, makeLift).

  • Prettyprinter : pour l’instance Pretty lisible par l’humain.

  • Ledger.Credential, Crypto, Scripts : types de grand livre on-chain (PubKeyHash, ValidatorHash, Credential).

3 Structures de données

Ci-dessous, trois exemples de définitions de types Haskell, suivis de notre Address.

3.1 Exemple de newtype

-- Un wrapper pour les entiers avec une signification particulière
newtype MyInt = MyInt Int
    deriving (Eq, Show)

-- Utilisation :
let x = MyInt 5
print x           -- outputs: MyInt 5

  • Entrée : valeur Int

  • Traitement : aucun (wrapper à coût nul)

  • Sortie : MyInt

3.2 Exemple de synonyme de type

-- Alias pour la lisibilité
type Username = String

-- Utilisation :
let user :: Username
    user = "alice"

  • Entrée/Sortie : identique à String, simplement renommé.

3.3 Exemple de type data

-- Un type somme représentant des formes
data Shape = Circle Double | Rectangle Double Double
    deriving (Eq, Show)

-- Utilisation :
let c = Circle 2.0
let r = Rectangle 3.0 4.0

  • Entrée : paramètres Double

  • Traitement : aucun à la construction

  • Sortie : valeur Shape

3.4 Type de données Address

-- | Address with payment and optional staking credential
data Address = Address
    { addressCredential        :: Credential
    , addressStakingCredential :: Maybe StakingCredential
    }
    deriving stock (Eq, Ord, Show, Generic)
    deriving anyclass (NFData)

  • Champs :

    • addressCredential : Credential on-chain (soit clé publique, soit script)

    • addressStakingCredential : Maybe StakingCredential (optionnel)

  • Dérivations :

    • Eq, Ord, Show, Generic via stock

    • NFData via anyclass

Exemple d’utilisation :

import Plutus.V1.Ledger.Credential (PubKeyCredential(..))
import Plutus.V1.Ledger.Crypto     (PubKeyHash)

let pkh  = PubKeyHash "abcdef..."
let addr = Address (PubKeyCredential pkh) Nothing
print addr

4 ⚙️ Fonctions

Chaque fonction ci-dessous est marquée {-# INLINABLE #-} pour une utilisation on-chain.

4.1 pubKeyHashAddress

{-# INLINABLE pubKeyHashAddress #-}
-- | Construct an address locked by a public key hash
pubKeyHashAddress :: PubKeyHash -> Address
pubKeyHashAddress pkh = Address (PubKeyCredential pkh) Nothing

  • Entrée : PubKeyHash

  • Traitement : wrappe en PubKeyCredential, pas de staking

  • Sortie : Address

Exemple :

let myAddr = pubKeyHashAddress somePubKeyHash

4.2 toPubKeyHash

{-# INLINABLE toPubKeyHash #-}
-- | Extract the public key hash, if present
toPubKeyHash :: Address -> Maybe PubKeyHash
toPubKeyHash (Address (PubKeyCredential k) _) = Just k
toPubKeyHash _                                = Nothing

  • Entrée : Address

  • Traitement : correspondance de motif sur Credential

  • Sortie : Maybe PubKeyHash

Exemples :

toPubKeyHash (pubKeyHashAddress pkh) == Just pkh
toPubKeyHash (scriptHashAddress vh)   == Nothing

4.3 toValidatorHash

{-# INLINABLE toValidatorHash #-}
-- | Extract the validator hash, if any
toValidatorHash :: Address -> Maybe ValidatorHash
toValidatorHash (Address (ScriptCredential k) _) = Just k
toValidatorHash _                                = Nothing

  • Entrée : Address

  • Traitement : correspondance de motif sur ScriptCredential

  • Sortie : Maybe ValidatorHash

Exemple :

toValidatorHash (scriptHashAddress someVH) == Just someVH

4.4 scriptHashAddress

{-# INLINABLE scriptHashAddress #-}
-- | Construct an address locked by a script validator hash
scriptHashAddress :: ValidatorHash -> Address
scriptHashAddress vh = Address (ScriptCredential vh) Nothing

  • Entrée : ValidatorHash

  • Traitement : wrappe en ScriptCredential, pas de staking

  • Sortie : Address

Exemple :

let scriptAddr = scriptHashAddress myValidatorHash

4.5 stakingCredential

{-# INLINABLE stakingCredential #-}
-- | Retrieve staking credential, if any
stakingCredential :: Address -> Maybe StakingCredential
stakingCredential (Address _ s) = s

  • Entrée : Address

  • Traitement : projection du champ

  • Sortie : Maybe StakingCredential

Exemple :

stakingCredential addr == Nothing

5 Instances de classes de type

instance Pretty Address where
    pretty (Address cred stakingCred) =
        let staking = maybe "no staking credential" pretty stakingCred in
        pretty cred <+> parens staking

instance PlutusTx.Eq Address where
    {-# INLINABLE (==) #-}
    Address c1 s1 == Address c2 s2 =
        c1 PlutusTx.== c2 PlutusTx.&& s1 PlutusTx.== s2

-- On-chain Derivation :
PlutusTx.makeIsDataIndexed ''Address [('Address,0)]
PlutusTx.makeLift     ''Address

  • Pretty : classe de Prettyprinter pour l’affichage

  • PlutusTx.Eq : classe Eq on-chain, (==) doit être INLINABLE

  • makeIsDataIndexed : génère l’instance IsData avec index de constructeur

  • makeLift : permet de “lifter” les valeurs Haskell dans le code on-chain

6 Glossaire

  • Address : identifiant on-chain combinant les credentials de paiement et de staking.

  • Credential : soit PubKeyCredential PubKeyHash, soit ScriptCredential ValidatorHash.

  • StakingCredential : credential optionnel pour les récompenses de staking.

  • PubKeyHash : hachage d’une clé publique.

  • ValidatorHash : hachage d’un script de validation.

  • INLINABLE : pragma GHC rendant une fonction disponible pour spécialisation.

  • makeIsDataIndexed : Template Haskell pour la sérialisation des données on-chain.

  • makeLift : Template Haskell pour le lifting en code on-chain.

  • newtype : wrapper à coût nul autour d’un seul champ.

  • type : synonyme pour un autre type.

  • data : définit un nouveau type algébrique.

  • NFData : classe pour l’évaluation profonde (rnf).

  • Pretty : classe pour le “pretty-printing” des valeurs.

Dernière mise à jour : il y a 1 heure.

PreviousPlutus: Ledger.Tx.ConstraintsNextPlutus.V1.Ledger.Api

Last updated