Projet échafaudé Go NFT pour ERC-721

Blockchain App Builder prend l'entrée de votre fichier de spécification NFT et génère un projet de code de chaîne entièrement fonctionnel.

Le projet génère automatiquement des classes et des fonctions de cycle de vie NFT, y compris les méthodes CRUD et non CRUD. La validation des arguments, la conversion/déconversion des paramètres et la capacité de persistance transparente sont toutes prises en charge automatiquement.

Pour plus d'informations sur le projet échafaudé et sur les méthodes qui ne sont pas directement liées aux opérations de transfert (NFT), voir Projet de code de chaîne de démarrage échafaudé.

Informations de référence :

Modèle

Transparent Persistence Capability, ou ORM simplifié, est capturé dans la classe OchainModel. 

package model

type ArtCollection struct {
	AssetType     string `json:"AssetType" final:"otoken"`
	TokenId       string `json:"TokenId" id:"true" mandatory:"true" validate:"regexp=^[A-Za-z0-9][A-Za-z0-9_-]*$,max=16"`
	TokenName     string `json:"TokenName" final:"artcollection"`
	TokenDesc     string `json:"TokenDesc" validate:"max=256"`
	Symbol        string `json:"Symbol" final:"ART"`
	TokenStandard string `json:"TokenStandard" final:"erc721+"`
	TokenType     string `json:"TokenType" final:"nonfungible" validate:"regexp=^nonfungible$"`
	TokenUnit     string `json:"TokenUnit" final:"whole" validate:"regexp=^whole$"`

	Behavior []string `json:"Behavior" final:"[\"indivisible\",\"singleton\",\"mintable\",\"transferable\",\"burnable\",\"roles\"]"`

	Roles map[string]interface{} `json:"Roles" final:"{\"minter_role_name\":\"minter\"}"`

	Mintable map[string]interface{} `json:"Mintable" final:"{\"Max_mint_quantity\":20000}"`

	Owner           string `json:"Owner,omitempty" validate:"string"`
	CreatedBy       string `json:"CreatedBy,omitempty" validate:"string"`
	TransferredBy   string `json:"TransferredBy,omitempty" validate:"string"`
	CreationDate    string `json:"CreationDate,omitempty" validate:"string"`
	TransferredDate string `json:"TransferredDate,omitempty" validate:"string"`
	IsBurned        bool   `json:"IsBurned" validate:"bool"`
	BurnedBy        string `json:"BurnedBy,omitempty" validate:"string"`
	BurnedDate      string `json:"BurnedDate,omitempty" validate:"string"`
	TokenUri        string `json:"TokenUri" validate:"string,max=2000"`

	TokenMetadata ArtCollectionMetadata `json:"TokenMetadata"`

	Price        int  `json:"Price" validate:"int"`
	On_sale_flag bool `json:"On_sale_flag" validate:"bool"`
}

type ArtCollectionMetadata struct {
	Painting_name string `json:"Painting_name" validate:"string"`
	Description   string `json:"Description" validate:"string"`
	Image         string `json:"Image" validate:"string"`
	Painter_name  string `json:"Painter_name" validate:"string"`
}

Controller

Il n'y a qu'un seul contrôleur principal.

type Controller struct {
    Ctx trxcontext.TrxContext
}

Vous pouvez créer un nombre illimité de classes, de fonctions ou de fichiers, mais seules les méthodes définies dans la classe de contrôleur principale peuvent être appelées. Les autres méthodes sont masquées.

Vous pouvez utiliser les méthodes de la trousse SDK de jeton pour écrire des méthodes personnalisées pour votre application d'affaires.

Méthodes NFT générées automatiquement

Blockchain App Builder génère automatiquement des méthodes pour prendre en charge les NFT et les cycles de vie NFT. Vous pouvez utiliser ces méthodes pour initialiser les NFT, gérer les rôles et les comptes et effectuer d'autres tâches du cycle de vie NFT sans codage supplémentaire.

Blockchain App Builder génère automatiquement des méthodes pour prendre en charge les NFT et les cycles de vie NFT. Vous pouvez utiliser ces méthodes pour initialiser les NFT, gérer les rôles et les comptes et effectuer d'autres tâches du cycle de vie NFT sans codage supplémentaire. Les méthodes du contrôleur doivent être publiques pour pouvoir être invoquées. Les noms de méthode publique commencent par un caractère majuscule. Les noms de méthode commençant par un caractère minuscule sont privés.

Méthodes de gestion du contrôle d'accès

AddTokenAdmin
Cette méthode ajoute un utilisateur en tant qu'Token Admin du code de chaîne. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. 
func (t *Controller) AddTokenAdmin(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ADMIN.AddAdmin", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Admin.AddAdmin(orgId, userId)
}
Paramètres :
  • orgId string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, un message contenant les détails de l'utilisateur qui a été ajouté en tant que Token Admin du code de chaîne.
Exemple de valeur renvoyée :
{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveTokenAdmin
Cette méthode supprime un utilisateur en tant qu'Token Admin du code de chaîne. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. Vous ne pouvez pas utiliser cette méthode pour vous supprimer en tant que Token Admin. 
func (t *Controller) RemoveTokenAdmin(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ADMIN.RemoveAdmin", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Admin.RemoveAdmin(orgId, userId)
}
Paramètres :
  • orgId string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, un message contenant les détails de l'utilisateur qui a été supprimé en tant que Token Admin du code de chaîne.
Exemple de valeur renvoyée :
{"msg":"Successfully removed Admin (OrgId Org1MSP UserId user1)"}
IsTokenAdmin
Cette méthode retourne la valeur booléenne true si l'appelant de la fonction est Token Admin, sinon elle retourne false. Un Token Admin peut appeler cette fonction sur n'importe quel autre utilisateur du réseau de chaîne de blocs. Les autres utilisateurs ne peuvent appeler cette méthode que sur leurs propres comptes. 
func (t *Controller) IsTokenAdmin(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ADMIN.IsTokenAdmin", "TOKEN", map[string]string{"orgId": orgId, "userId": userId})
      if err != nil || !auth {
            return false, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Auth.IsUserTokenAdmin(orgId, userId)
}
Paramètres :
  • orgId string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • La méthode retourne true si l'appelant est Token Admin, sinon elle retourne false.
Exemple de valeur renvoyée :
{"result":true}
GetAllTokenAdmins
Cette méthode retourne la liste de tous les utilisateurs qui sont des Token Admin du code de chaîne. Cette méthode ne peut être appelée que par Token Admin du code de chaîne. 
func (t *Controller) GetAllTokenAdmins() (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ADMIN.GetAllAdmins", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Admin.GetAllAdminUsers()
}
Paramètres :
  • aucune
Retourne :
  • En cas de succès, une liste JSON d'administrateurs comprenant des objets OrgId et UserId.
Exemple de valeur renvoyée :
{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}

Méthodes de gestion de la configuration de jeton

Init
Cette méthode est appelée lorsque le code de chaîne est instancié. Chaque Token Admin est identifié par les informations UserId et OrgId dans le paramètre adminList. UserId est le nom d'utilisateur ou l'ID courriel du responsable de l'instance ou de l'utilisateur connecté à l'instance. OrgId est l'ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante. Le paramètre adminList est obligatoire lors du premier déploiement du code de chaîne. Si vous mettez à niveau le code de chaîne, transmettez une liste vide ([]). Toutes les autres informations du paramètre adminList sont ignorées lors des mises à niveau. 
func (t *Controller) Init(adminList []erc721Admin.ERC721TokenAdminAsset) (interface{}, error) {
      list, err := t.Ctx.ERC721Admin.InitAdmin(adminList)
      if err != nil {
            return nil, fmt.Errorf("initialising admin list failed %s", err.Error())
      }
      <Token Name> := <Token Class>{}
      _, err = t.Ctx.ERC721Token.SaveClassInfo(&<Token Name>)
      if err != nil {
            return nil, err
      }
      _, err = t.Ctx.ERC721Token.SaveDeleteTransactionInfo()
      if err != nil {
            fmt.Println("error: ", err)
      }
      return list, nil
}
Paramètres :
  • adminList array – Tableau d'informations {OrgId, UserId} qui spécifie la liste des administrateurs de jetons. Le tableau adminList est un paramètre obligatoire.
GetAllTokens
Cette méthode retourne toutes les ressources de jeton enregistrées dans la base de données d'état. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. Cette méthode utilise des interrogations Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau distant Oracle Blockchain Platform. 
func (t *Controller) GetAllTokens() (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetAllTokens", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Token.GetAllTokens()
}
Paramètres :
  • aucune
Retourne :
  • Liste de toutes les ressources de jeton au format JSON.
Exemple de valeur renvoyée :
[
    {
        "key": "monalisa",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:01:42Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "token Description",
            "TokenId": "monalisa",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
    },
    {
        "key": "monalisa2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:04:44Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "monalisa1",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
        }
    }
]
GetAllTokensByUser
Cette méthode retourne toutes les ressources de jeton détenues par un utilisateur spécifié. Cette méthode utilise des interrogations Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau distant Oracle Blockchain Platform. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne ou par le responsable du compte. 
func (t *Controller) GetAllTokensByUser(orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetAllTokensByUser", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
    return t.Ctx.ERC721Token.GetAllTokensByUser(accountId)
}
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • Liste des ressources de jeton au format JSON.
Exemple de valeur renvoyée :
[
    {
        "key": "monalisa",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:01:42Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "token Description",
            "TokenId": "monalisa",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
    },
    {
        "key": "monalisa2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:04:44Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "monalisa1",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
        }
    }
]
GetTokenById
Cette méthode retourne un objet de jeton si le jeton est présent dans la base de données d'état. Cette méthode ne peut être appelée que par Token Admin du code de chaîne ou du responsable du jeton. 
func (t *Controller) GetTokenById(tokenId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.Get", "TOKEN", map[string]string{"tokenId": tokenId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      tokenAsset, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      return tokenAsset.Interface(), nil
}
Paramètres :
  • tokenId: string - ID du jeton à obtenir.
Retourne :
  • Ressource de jeton au format JSON.
Exemple de valeur renvoyée :
{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2022-04-06T00:35:42Z",
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 200,
    "Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "Token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
    "TransferredBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "TransferredDate": "2022-04-06T00:51:56Z"
}
GetTokenHistory
Cette méthode retourne l'historique pour un ID jeton spécifié. Cette méthode ne peut être appelée que si elle est connectée au réseau Oracle Blockchain Platform distant. Tout le monde peut appeler cette méthode.
func (t *Controller) GetTokenHistory(tokenId string) (interface{}, error) {
      /*
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetTokenHistory", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      */
      return t.Ctx.ERC721Token.History(tokenId)
}
Paramètres :
  • tokenId: string – ID du jeton.
Exemple de valeur renvoyée :
[
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T19:22:52z",
        "TxId": "6b7989be322956164a8d1cd7bf2a7187d59eba73ce756e6bf946ab48b349bbc0",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "CreationDate": "2022-04-06T19:22:23z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "token Description",
            "TokenId": "monalisa",
            "TokenMetadata": {
               "Description": "Mona Lisa Painting",
               "Image": "monalisa.jpeg",
               "PainterName": "Leonardo_da_Vinci",
               "PaintingName": "Mona_Lisa"
            },
           "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg""
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T19:22:23z",
        "TxId": "e61bcb3cb61c8920f7e6d8f0d19726c7c88d876e0ad6cfb052cfb92d49985c3f",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "CreationDate": "2022-04-06T19:22:23z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            ""TokenId": "monalisa",
            "TokenMetadata": {
                "Description": "Mona Lisa Painting",
                "Image": "monalisa.jpeg",
                "PainterName": "Leonardo_da_Vinci",
                "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
        }
    }
]
getTokenObject
Il s'agit d'une méthode d'utilitaire qui retourne une instance du jeton pour un ID de jeton spécifié. Cette méthode est utilisée par de nombreuses méthodes générées automatiquement pour extraire des objets de jeton. Vous pouvez appeler cette méthode si nécessaire à partir de vos méthodes personnalisées. Lorsque vous créez une ressource ou une classe segmentée en unités, mettez à jour la casse du commutateur avec la classe Token correspondante pour retourner l'objet de jeton correct. La commande ochain sync dans Blockchain App Builder crée automatiquement un cas de commutateur lorsqu'une ressource segmentée en unités est créée dans le fichier de spécification. Comme cette méthode est privée, elle n'est pas directement appelable et ne peut être appelée qu'à partir d'autres méthodes. 
func (t *Controller) getTokenObject(tokenId string) (reflect.Value, error) {
      if tokenId == "" {
            return reflect.Value{}, fmt.Errorf("error in retrieving token, token_id cannot be empty")
      }
      tokenAsset, err := t.Ctx.ERC721Token.Get(tokenId)
      if err != nil {
            return reflect.Value{}, fmt.Errorf("no token exists with id %s %s", tokenId, err.Error())
      }
      tokenName := tokenAsset.(map[string]interface{})["TokenName"].(string)
      switch tokenName {
      case "<Token Name>":
            var asset <Token Class>
            _, err := t.Ctx.ERC721Token.Get(tokenId, &asset)
            if err != nil {
                  return reflect.Value{}, err
            }
            return reflect.ValueOf(&asset), nil
      default:
            return reflect.Value{}, fmt.Errorf("no token exists with token name %s", tokenName)
      }
}
Paramètres :
  • tokenId: string – ID du jeton.
OwnerOf
Cette méthode retourne l'ID compte du responsable de l'ID jeton spécifié. Tout le monde peut appeler cette méthode.
func (t *Controller) Ownerof(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.OwnerOf(tokenId)
}
Paramètres :
  • tokenId: string – ID du jeton.
Retourne :
  • Objet JSON de l'ID compte du responsable.
Exemple de valeur renvoyée :
{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
Name
Cette méthode retourne le nom de la classe de jeton. Tout le monde peut appeler cette méthode.
func (t *Controller) Name() (interface{}, error) {
      return t.Ctx.ERC721Token.Name()
}
Paramètres :
  • aucune
Retourne :
  • Objet JSON du nom du jeton.
Exemple de valeur renvoyée :
{"TokenName": "paintingnft"}
Symbol
Cette méthode retourne le symbole de la classe de jeton. Tout le monde peut appeler cette méthode.
func (t *Controller) Symbol() (interface{}, error) {
      return t.Ctx.ERC721Token.Symbol()
}
Paramètres :
  • aucune
Retourne :
  • Objet JSON du symbole de jeton.
Exemple de valeur renvoyée :
{"Symbol": "PNT"}
TokenURI
Cette méthode retourne l'URI d'un jeton spécifié. Tout le monde peut appeler cette méthode.
func (t *Controller) TokenURI(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.TokenURI(tokenId)
}
Paramètres :
  • tokenId: string – ID du jeton.
Retourne :
  • En cas de succès, un objet JSON de l'URI de jeton.
Exemple de valeur renvoyée :
{"TokenURI": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
TotalSupply
Cette méthode retourne le nombre total de jetons frappés. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. 
func (t *Controller) TotalSupply() (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.TotalSupply", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Token.TotalSupply()
}
Paramètres :
  • aucune
Retourne :
  • En cas de succès, un objet JSON du nombre de jetons.
Exemple de valeur renvoyée :
{"TotalSupply": 3}
TotalNetSupply
Cette méthode retourne le nombre total de jetons frappés moins le nombre de jetons brûlés. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. 
func (t *Controller) TotalNetSupply() (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.TotalNetSupply", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Token.GetTotalMintedTokens()
}
Paramètres :
  • aucune
Retourne :
  • En cas de succès, un objet JSON du nombre de jetons.
Exemple de valeur renvoyée :
{"TotalNetSupply": 2}

Méthodes de gestion des comptes

CreateAccount
Cette méthode crée un compte pour un utilisateur et un jeton spécifiés. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Les comptes suivent le nombre d'opérations de transfert de fonds (NFT) dont dispose un utilisateur. Les utilisateurs doivent avoir des comptes dans le réseau pour effectuer des opérations liées au jeton. Vous ne pouvez créer qu'un seul compte NFT par utilisateur.

Un ID compte est un jeu alphanumérique de caractères, précédé de oaccount~ et suivi d'un hachage SHA-256 de l'ID fournisseur de services d'adhésion (OrgId) de l'utilisateur dans l'organisation réseau courante, du nom d'utilisateur ou de l'ID courriel (UserId) du responsable de l'instance ou de l'utilisateur connecté à l'instance, et de la chaîne constante nft. Cette méthode ne peut être appelée que par Token Admin du code de chaîne. 

func (t *Controller) CreateAccount(orgId string, userId string, tokenType string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.CreateAccount", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Account.CreateAccount(orgId, userId, tokenType)
}
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
  • tokenType: string – Le seul type de jeton pris en charge est nonfungible.
Retourne :
  • En cas de succès, un objet JSON du compte qui a été créé.
Exemple de valeur renvoyée :
{
    "AssetType": "oaccount",
    "BapAccountVersion" : 0,
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
BalanceOf
Cette méthode retourne le nombre total de TEF qu'un utilisateur spécifié détient. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne ou par le responsable du compte. 
func (t *Controller) BalanceOf(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.BalanceOf", "TOKEN", map[string]string{"orgId": orgId, "userId": userId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil{
            return nil,err
      }
      return t.Ctx.ERC721Account.BalanceOf(accountId)
}
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • Objet JSON du nombre NFT courant.
Exemple de valeur renvoyée :
{"totalNfts": 0}
GetAllAccounts
Cette méthode retourne une liste de tous les comptes. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. Cette méthode utilise des interrogations Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau distant Oracle Blockchain Platform. 
func (t *Controller) GetAllAccounts() (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.GetAllAccounts", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Account.GetAllAccounts()
}
Paramètres :
  • aucune
Retourne :
  • En cas de succès, un tableau JSON de tous les comptes.
Exemple de valeur renvoyée :
[
    {
        "key": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "valueJson": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 5,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    },
    {
        "key": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "valueJson": {
            "AccountId": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user_minter"
        }
    },
    {
        "key": "oaccount~5541fb520058d83664b844e7a55fe98d574ddeda765d0e795d4779e9ccc271ce",
        "valueJson": {
            "AccountId": "oaccount~5541fb520058d83664b844e7a55fe98d574ddeda765d0e795d4779e9ccc271ce",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user_burner"
        }
    }
]
GetAccountByUser
Cette méthode retourne les détails du compte pour un utilisateur spécifié. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne ou le Account Owner du compte. 
func (t *Controller) GetAccountByUser(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.GetAccountByUser", "TOKEN", map[string]string{"orgId": orgId, "userId": userId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Account.GetAccountWithStatusByUser(orgId, userId)
}
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, un objet de compte JSON qui inclut les propriétés suivantes :
  • AccountId – ID du compte d'utilisateur.
  • UserId – Nom d'utilisateur ou ID courriel de l'utilisateur.
  • OrgId – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • TokenType – Type de jeton que le compte détient.
  • NoOfNfts – Le nombre total de NFT détenus par le compte.
  • BapAccountVersion – Paramètre d'objet de compte à usage interne.
  • Status – Le statut actuel du compte d'utilisateur.
Exemple de valeur renvoyée :
{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}
GetUserByAccountId
Cette méthode retourne les détails de l'utilisateur pour un compte spécifié. Cette méthode peut être appelée par n'importe quel utilisateur.
func (t *Controller) GetUserByAccountId(accountId string) (interface{}, error) {
      return t.Ctx.ERC721Account.GetUserByAccountById(accountId)
}
Paramètres :
  • accountId: string – ID du compte.
Retourne :
  • En cas de succès, un objet JSON des détails de l'utilisateur (OrgId et UserId).
Exemple de valeur renvoyée :
{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
GetAccountHistory
Cette méthode retourne l'historique de compte pour un utilisateur spécifié. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne ou par le responsable du compte. 
func (t *Controller) GetAccountHistory(orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.History", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Account.History(accountId)
}
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, une liste d'objets.
Exemple de valeur renvoyée :
[
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T08:16:53Z",
        "TxId": "750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "Value": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "BapAccountVersion" : 1,
            "NoOfNfts": 1,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T08:15:19Z",
        "TxId": "49eb84c42d452e5ba0028d8ebb4190454cf9013a11c0bad3e96594af452d4982",
        "Value": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    }
]

Méthodes de gestion des rôles

AddRole
Cette méthode ajoute un rôle à un utilisateur spécifié. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. 
func (t *Controller) AddRole(role string, orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.AddRoleMember", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Token.AddRoleMember(role, accountId)
}
Paramètres :
  • userRole: string – Nom du rôle à ajouter à l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, un message avec les détails de l'utilisateur.
Exemple de valeur renvoyée :
{"msg": "Successfully added role minter to oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin)"}
RemoveRole
Cette méthode supprime un rôle d'un utilisateur spécifié. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. 
func (t *Controller) RemoveRole(userRole string, orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.RemoveRoleMember", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Token.RemoveRoleMember(userRole, accountId)
}
Paramètres :
  • userRole: string – Nom du rôle à supprimer de l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, un message avec les détails de l'utilisateur.
Exemple de valeur renvoyée :
{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}
GetAccountsByRole
Cette méthode retourne une liste de tous les ID compte pour un rôle spécifié. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. 
func (t *Controller) GetAccountsByRole(userRole string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ROLE.GetAccountsByRole", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Role.GetAccountsByRole(userRole)
}
Paramètres :
  • userRole: string – Nom du rôle à rechercher.
Retourne :
  • En cas de succès, un tableau JSON d'ID compte.
Exemple de valeur renvoyée :
{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
Cette méthode retourne une liste de tous les utilisateurs pour un rôle spécifié. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne. 
func (t *Controller) GetUsersByRole(userRole string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ROLE.GetUsersByRole", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Role.GetUsersByRole(userRole)
}
Paramètres :
  • userRole: string – Nom du rôle à rechercher.
Retourne :
  • En cas de succès, un tableau JSON des objets utilisateur (orgId et userId).
Exemple de valeur renvoyée :
{
    "Users": [
        {
            "OrgId": "Org1MSP",
            "UserId": "admin"
        }
    ]
}
IsInRole
Cette méthode retourne une valeur booléenne pour indiquer si un utilisateur a un rôle spécifié. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne ou le Account Owner du compte. 
func (t *Controller) IsInRole(orgId string, userId string, role string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.IsInRole", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      result, err := t.Ctx.ERC721Token.IsInRole(role, accountId)
      if err != nil {
            return nil, fmt.Errorf("error in IsInRole %s", err.Error())
      }
      response := make(map[string]interface{})
      response["result"] = result
      return response, nil
}
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
  • userRole: string – Nom du rôle à rechercher.
Retourne :
  • En cas de succès, une chaîne JSON du résultat booléen.
Exemple de valeur renvoyée :
{"result":"true"}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory
Cette méthode retourne l'historique des transactions de compte pour un utilisateur spécifié. Cette méthode peut être appelée par Token Admin du code de chaîne ou par le responsable du compte. 
func (t *Controller) GetAccountTransactionHistory(orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.GetAccountTransactionHistory", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }

      transactionArray, err := t.Ctx.ERC721Account.GetAccountTransactionHistory(accountId)
      return transactionArray, err
}
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, une liste d'objets.
Exemple de valeur renvoyée :
[
     {
        "Timestamp": "2022-04-06T08:31:39Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
        "TransactionType": "DEBIT"
    }
    {
        "Timestamp": "2022-04-06T08:16:53Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "TransactionId": "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "TransactionType": "MINT"
    }
]
GetAccountTransactionHistoryWithFilters
Cette méthode retourne l'historique des transactions de compte pour un utilisateur spécifié, filtré par PageSize, Bookmark, StartTime et EndTime. Cette méthode ne peut être appelée que si elle est connectée au réseau Oracle Blockchain Platform distant. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne ou par le responsable du compte. 
func (t *Controller) GetAccountTransactionHistoryWithFilters(orgId string, userId string, filters ...erc721Account.AccountHistoryFilters) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.GetAccountTransactionHistoryWithFilters", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }

      transactionArray, err := t.Ctx.ERC721Account.GetAccountTransactionHistoryWithFilters(accountId, filters...)
      return transactionArray, err
}
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
  • filters: string – Paramètre facultatif. Si vide, tous les enregistrements sont retournés. La propriété PageSize détermine le nombre d'enregistrements à retourner. Si PageSize a la valeur 0, la taille de page par défaut est 20. La propriété Bookmark détermine l'index de début des enregistrements à retourner. Pour plus d'informations, consultez la documentation sur Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.
Retourne :
  • En cas de succès, une liste d'objets.
Exemple de valeur renvoyée :
[
     {
        "Timestamp": "2022-04-06T08:31:39Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
        "TransactionType": "DEBIT"
    }
    {
        "Timestamp": "2022-04-06T08:16:53Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "TransactionId": "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "TransactionType": "MINT"
    }
]
GetTransactionById
Cette méthode retourne l'historique des transactions pour un ID transaction spécifié. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne ou par le responsable du compte. 
func (t *Controller) GetTransactionById(transactionId string) (interface{}, error) {
      return t.Ctx.ERC721Transaction.GetTransactionById(transactionId)
}
Paramètres :
  • transactionId: string – ID de la ressource de transaction.
Retourne :
  • En cas de succès, une liste d'objets.
Exemple de valeur renvoyée :
{
    "History": [
        {
            "IsDelete": "false",
            "Timestamp": "2022-04-06T08:31:39Z",
            "TxId": "5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
            "Value": {
                "AssetType": "otransaction",
                "Data": "",
                "FromAccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
                "Timestamp": "2022-04-06T08:31:39Z",
                "ToAccountId": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
                "TokenId": "monalisa",
                "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
                "TransactionType": "TRANSFER",
                "TriggeredByAccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1"
            }
        }
    ],
    "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7"
}
DeleteHistoricalTransactions
Cette méthode supprime les transactions antérieures à un horodatage spécifié dans la base de données d'état. Cette méthode ne peut être appelée que par Token Admin du code de chaîne. 
func (t *Controller) DeleteHistoricalTransactions(timestamp string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TRANSACTION.DeleteHistoricalTransactions", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)
}
Paramètres :
  • timestamp: Date – Un horodatage. Toutes les transactions antérieures à l'horodatage seront supprimées.
Retourne :
  • En cas de succès, une liste d'objets.
Exemple de valeur renvoyée :
{
    "Transactions": [
        "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7"
    ],
    "msg": "Successfuly deleted transaction older than date:2022-04-06T08:17:53Z"
}

Méthodes de gestion du comportement des jetons - Comportement mentable

Create<Token Name>Token
Cette méthode crée (exploite) un NFT. La ressource et les propriétés associées sont enregistrées dans la base de données d'état. L'appelant de cette transaction doit avoir un compte de jeton. L'appelant de cette transaction devient le propriétaire du NFT. Si le fichier de spécification de jeton inclut la section roles pour behaviors et la propriété minter_role_name pour roles, l'appelant de la transaction doit avoir le rôle de filtre. Sinon, tout appelant peut extraire des NFT. 
func (t *Controller) Create<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
      return t.Ctx.ERC721Token.CreateToken(&tokenAsset)
}
Paramètres :
  • tokenAsset: <Token Class> – Ressource de jeton à extraire. Pour plus d'informations sur les propriétés de la ressource de jeton, voir le fichier de spécification d'entrée.
Retourne :
  • En cas de succès, un objet de ressource de jeton JSON qui inclut les propriétés suivantes :
  • Behavior - Description de tous les comportements de jeton.
  • CreatedBy - ID compte de l'utilisateur qui a appelé la transaction pour extraire le jeton.
  • CreationDate – Horodatage de la transaction.
  • IsBurned – Valeur booléenne indiquant si la valeur NFT identifiée par tokenId est brûlée.
  • Mintable - Description des propriétés du comportement de mintable. La propriété max_mint_quantity spécifie le nombre maximal de fichiers NFT de cette classe de jeton pouvant être créés.
  • Owner - ID compte du responsable courant du jeton. Au cours du processus de frappe, l'appelant de cette méthode devient le propriétaire du jeton.
  • Symbol – Symbole du jeton.
  • TokenDesc – Description du jeton.
  • TokenMetadata – Informations JSON décrivant le jeton.
  • TokenName – Nom du jeton.
  • TokenStandard - Norme du jeton.
  • TokenType – Type de jeton détenu par ce compte.
  • TokenUnit – Unité du jeton.
  • TokenUri – URI du jeton.
Exemple de valeur renvoyée :
{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",        
    "CreationDate": "2022-04-06T08:16:53Z",
    "IsBurned": false,
     "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 100,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
}
Update<Token Name>Token
Cette méthode met à jour les propriétés du jeton. Cette méthode ne peut être appelée que par l'utilisateur qui est le propriétaire ou le créateur du jeton. Après la création d'une ressource de jeton, seul le responsable du jeton peut mettre à jour les propriétés personnalisées du jeton. Si l'utilisateur est à la fois responsable et créateur d'un jeton, il peut également mettre à jour la propriété TokenDesc. Les métadonnées du jeton ne peuvent pas être mises à jour. Vous devez transmettre toutes les propriétés de jeton à cette méthode, même si vous souhaitez mettre à jour uniquement certaines propriétés. 
func (t *Controller) Update<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
      return t.Ctx.ERC721Token.UpdateToken(&tokenAsset)
}
Paramètres :
  • tokenAsset: <Token Class> – Ressource de jeton à mettre à jour. Pour plus d'informations sur les propriétés de la ressource de jeton, voir le fichier de spécification d'entrée.
Retourne :
  • En cas de succès, un objet de ressource de jeton JSON mis à jour
Exemple de valeur renvoyée :
{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",      
    "CreationDate": "2022-04-06T08:16:53Z",
    "IsBurned": false,    
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 200,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "Token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
}

Méthodes de gestion du comportement des jetons - Comportement transférable

SafeTransferFrom
Cette méthode transfère la propriété du NFT spécifié de l'appelant à un autre compte. Cette méthode comprend les validations suivantes :
  • Le jeton existe et n'est pas brûlé.
  • Le compte de l'expéditeur et le compte destinataire existent et ne sont pas le même compte.
  • Le compte de l'expéditeur est responsable du jeton.
  • L'appelant de la fonction est l'expéditeur.
func (t *Controller) SafeTransferFrom(fromOrgId string, fromUserId string, toOrgId string, toUserId string, tokenId string, data ...string) (interface{}, error) {
      tokenAssetValue, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      fromAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(fromOrgId, fromUserId)
      if err != nil {
            return nil, err
      }
      toAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(toOrgId, toUserId)
      if err != nil {
            return nil, err
      }
      return t.Ctx.ERC721Token.SafeTransferFrom(fromAccountId, toAccountId, tokenAssetValue.Interface(), data...)
}
Paramètres :
  • fromOrgId: string – ID fournisseur de services d'adhésion (MSP) de l'expéditeur dans l'organisation courante.
  • fromUserId: string – Nom d'utilisateur ou ID courriel de l'expéditeur.
  • toOrgId: string – ID fournisseur de services d'adhésion (MSP) du destinataire dans l'organisation courante.
  • toUserId: string – Nom d'utilisateur ou ID courriel du destinataire.
  • tokenId: string – ID du jeton à transférer.
  • data: string – Informations supplémentaires facultatives à stocker dans l'enregistrement de transaction.
Retourne :
  • En cas de succès, un message contenant les détails du compte de l'expéditeur et du destinataire.
Exemple de valeur renvoyée :
{"msg": "Successfully transferred NFT token: 'monalisa' from Account-Id: oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (Org-Id: Org1MSP, User-Id: admin) to Account-Id: oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba (Org-Id: Org1MSP, User-Id: user1)"}
TransferFrom
Cette méthode transfère la propriété du NFT spécifié d'un compte d'expéditeur à un compte de destinataire. Il est de la responsabilité de l'appelant de transmettre les paramètres corrects. Cette méthode peut être appelée par n'importe quel utilisateur, pas seulement par le propriétaire du jeton. Cette méthode comprend les validations suivantes :
  • Le jeton existe et n'est pas brûlé.
  • Le compte de l'expéditeur et le compte destinataire existent et ne sont pas le même compte.
  • Le compte de l'expéditeur est responsable du jeton.
func (t *Controller) TransferFrom(fromOrgId string, fromUserId string, toOrgId string, toUserId string, tokenId string) (interface{}, error) {
      tokenAssetValue, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      fromAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(fromOrgId, fromUserId)
      if err != nil {
            return nil, err
      }
      toAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(toOrgId, toUserId)
      if err != nil {
            return nil, err
      }
      return t.Ctx.ERC721Token.TransferFrom(fromAccountId, toAccountId, tokenAssetValue.Interface())
}
Paramètres :
  • fromOrgId: string – ID fournisseur de services d'adhésion (MSP) de l'expéditeur dans l'organisation courante.
  • fromUserId: string – Nom d'utilisateur ou ID courriel de l'expéditeur.
  • toOrgId: string – ID fournisseur de services d'adhésion (MSP) du destinataire dans l'organisation courante.
  • toUserId: string – Nom d'utilisateur ou ID courriel du destinataire.
  • tokenId: string – ID du jeton à transférer.
Retourne :
  • En cas de succès, un message contenant les détails du compte de l'expéditeur et du destinataire.
Exemple de valeur renvoyée :
{"msg": "Successfully transferred NFT token: 'monalisa' from Account-Id: oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (Org-Id: Org1MSP, User-Id: admin) to Account-Id: oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba (Org-Id: Org1MSP, User-Id: user1)"}

Méthodes pour Token Behavior Management - Burnable Behavior

Burn
Cette méthode désactive ou brûle le NFT spécifié à partir du compte de l'appelant. L'appelant de cette méthode doit avoir un compte. Un jeton ne peut pas être gravé sauf si le fichier de spécification de jeton inclut le comportement burnable. Si aucune propriété burner_role_name n'est spécifiée dans la section roles du fichier de spécification, le responsable du jeton peut graver le jeton. Si une propriété burner_role_name est spécifiée dans la section roles, l'utilisateur a affecté le rôle de brûleur qui est également le créateur du jeton peut graver le jeton. 
func (t *Controller) Burn(tokenId string) (interface{}, error) {
      tokenAssetValue, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      return t.Ctx.ERC721Token.Burn(tokenAssetValue.Interface())
}
Paramètres :
  • tokenId: string - ID du jeton à graver.
Retourne :
  • En cas de succès, un message avec les détails du compte.
Exemple de valeur renvoyée :
{"msg": "Successfully burned NFT token: 'monalisa' from Account-Id: oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (Org-Id: Org1MSP, User-Id: admin"}
BurnNFT
Cette méthode désactive ou grave le NFT spécifié à partir du compte de l'appelant et retourne un objet de jeton et un historique de jeton. L'appelant de cette méthode doit avoir un compte. Un jeton ne peut pas être gravé sauf si le fichier de spécification de jeton inclut le comportement burnable. Si aucune propriété burner_role_name n'est spécifiée dans la section roles du fichier de spécification, le responsable du jeton peut graver le jeton. Si une propriété burner_role_name est spécifiée dans la section roles, l'utilisateur a affecté le rôle de brûleur qui est également le créateur ou le responsable du jeton peut graver le jeton. 
func (t *Controller) BurnNFT(tokenId string) (interface{}, error) {
      tokenAsset, err := t.Ctx.ERC721Token.Get(tokenId)
      if err != nil {
            return nil, err
      }
      tokenHistory, err := t.Ctx.ERC721Token.History(tokenId)
      if err != nil {
            return nil, err
      }
      token := tokenAsset.(map[string]interface{})
      if token[constants.IsBurned] == true {
            return nil, fmt.Errorf("token with tokenId %s is already burned", tokenId)
      }
      token[constants.TokenId], err = strconv.Atoi(token[constants.TokenId].(string))
      if err != nil {
            return nil, fmt.Errorf("tokenId is expected to be integer but found %s", tokenId)
      }
      tokenHistoryBytes, err := json.Marshal(tokenHistory)
      if err != nil {
            return nil, err
      }
      var tokenHistoryAsRawJson json.RawMessage
      err = json.Unmarshal(tokenHistoryBytes, &tokenHistoryAsRawJson)
      if err != nil {
            return nil, err
      }
      token[constants.TokenHistory] = string(tokenHistoryAsRawJson)
      token[constants.IsBurned] = true
      _, err = t.Burn(tokenId)
      if err != nil {
            return nil, err
      }
      return token, nil
}
Paramètres :
  • tokenId: string - ID du jeton à graver.
Retourne :
  • En cas de succès, un objet de jeton qui inclut des informations d'historique de jeton.
Exemple de valeur renvoyée :
{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2023-08-22T13:19:33+05:30",
    "IsBurned": true,
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "On_sale_flag": false,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Price": 120,
    "Roles": {
        "minter_role_name": "minter"
    },
    "Symbol": "ART",
    "TokenDesc": "",
    "TokenHistory": "[{\"IsDelete\":\"false\",\"Timestamp\":\"2023-08-22T13:19:33+05:30\",\"TxId\":\"0219099bcaaecd5f76f7f08d719384fd5ed34103a55bd8d3754eca0bfc691594\",\"Value\":{\"AssetType\":\"otoken\",\"Behavior\":[\"indivisible\",\"singleton\",\"mintable\",\"transferable\",\"burnable\",\"roles\"],\"CreatedBy\":\"oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d\",\"CreationDate\":\"2023-08-22T13:19:33+05:30\",\"IsBurned\":false,\"Mintable\":{\"Max_mint_quantity\":20000},\"On_sale_flag\":false,\"Owner\":\"oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d\",\"Price\":120,\"Roles\":{\"minter_role_name\":\"minter\"},\"Symbol\":\"ART\",\"TokenDesc\":\"\",\"TokenId\":\"1\",\"TokenMetadata\":{\"Description\":\"\",\"Image\":\"\",\"Painter_name\":\"\",\"Painting_name\":\"\"},\"TokenName\":\"artcollection\",\"TokenStandard\":\"erc721+\",\"TokenType\":\"nonfungible\",\"TokenUnit\":\"whole\",\"TokenUri\":\"example.com\"}}]",
    "TokenId": 1,
    "TokenMetadata": {
        "Description": "",
        "Image": "",
        "Painter_name": "",
        "Painting_name": ""
    },
    "TokenName": "artcollection",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "example.com"
}

Méthodes personnalisées

Vous pouvez utiliser les méthodes de la trousse SDK de jeton pour écrire des méthodes personnalisées pour votre application d'affaires.

L'exemple suivant montre comment utiliser des méthodes de trousse SDK de jeton dans des méthodes personnalisées. Lorsque la méthode Sell est appelée, elle publie un jeton à vendre pour un prix spécifié. 

func (t *Controller) Sell(tokenId string, sellingPrice int) (interface{}, error) {
	var tokenAsset ArtCollection
	_, err := t.Ctx.ERC721Token.Get(tokenId, &tokenAsset)
    if err != nil {
       return nil, err
	}

 /**  * price is a custom asset
      attribute to set the price of a non-fungible token in the
      marketplace  */
	tokenAsset.Price = sellingPrice
 /**  * on_sale_flag is a
      custom asset attribute that maintains non-fungible token selling status in the
      marketplace  */
	tokenAsset.On_sale_flag = true

	_, err = t.Ctx.ERC721Token.UpdateToken(tokenAsset)
    if err != nil {
		return nil, err
	}
	
	msg := fmt.Sprintf("Token ID : %s has been posted for selling in the marketplace", tokenId)
	return msg, nil
}

Méthodes de trousse SDK NFT

Méthodes de gestion du contrôle d'accès

La trousse SDK NFT fournit une fonction de contrôle d'accès. Certaines méthodes ne peuvent être appelées que par Token Admin ou Account Owner du jeton. Vous pouvez utiliser cette fonction pour vous assurer que les opérations ne sont effectuées que par les utilisateurs prévus. Tout accès non autorisé entraîne une erreur. Pour utiliser la fonction de contrôle d'accès, importez la classe Authorization à partir du module ../lib/auth.
import { ERC721Authorization } from '../lib/erc721-auth';
AddAdmin
Cette méthode ajoute un utilisateur en tant qu'Token Admin du code de chaîne de jeton. 
Ctx.ERC721Admin.AddAdmin(orgId string, userId string) (interface{}, error)
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de réussite, un message qui répertorie les détails pour l'utilisateur ajouté en tant que Token Admin du code de chaîne de jeton. En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Admin.AddAdmin(orgId, userId)

{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveAdmin
Cette méthode supprime un utilisateur en tant qu'Token Admin du code de chaîne de jeton. 
Ctx.ERC721Admin.RemoveAdmin(orgId string, userId string) (interface{}, error)
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de réussite, un message qui répertorie les détails pour l'utilisateur supprimé en tant que Token Admin du code de chaîne de jeton. En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Admin.RemoveAdmin(orgId, userId)

{"msg":"Successfuly removed Admin (OrgId Org1MSP UserId user1)"}
IsUserTokenAdmin
Cette méthode retourne un mappage avec la valeur booléenne true si l'appelant de la fonction est Token Admin. Sinon, la méthode retourne false. 
Ctx.ERC721Auth.IsUserTokenAdmin(orgId string, userId string)  (interface{}, error)
Paramètres :
  • orgId – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation réseau courante.
  • userId – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • Réponse booléenne.
Exemple :

t.Ctx.ERC721Auth.IsUserTokenAdmin(orgId, userId)

{"result":true}
GetAllAdmins
Cette méthode retourne une liste de tous les utilisateurs Token Admin. 
Ctx.ERC721Admin.GetAllAdmins() (Admin[], error)
Paramètres :
  • aucune
Retourne :
  • En cas de succès, une liste de tous les utilisateurs Token Admin. En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Admin.GetAllAdmins()

{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}
GetAllAdminUsers
Cette méthode retourne une liste de tous les utilisateurs Token Admin. 
Ctx.ERC721Admin.GetAllAdminUsers() (interface{}, error)
Paramètres :
  • aucune
Retourne :
  • En cas de succès, une liste de tous les utilisateurs Token Admin au format map[string]interface{}. En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Admin.GetAllAdminUsers()

{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}
CheckAuthorization
Utilisez cette méthode pour ajouter une vérification de contrôle d'accès à une opération. La plupart des méthodes générées automatiquement incluent le contrôle d'accès. Certaines méthodes de jeton ne peuvent être exécutées que par ERC721Admin ou Account Owner du jeton ou par MultipleAccountOwner pour les utilisateurs ayant plusieurs comptes. La méthode CheckAuthorization fait partie de l'ensemble erc721Auth, auquel vous accédez au moyen de la structure Ctx (émetteur-récepteur). Le mappage du contrôle d'accès est décrit dans le fichier oChainUtil.go, comme indiqué dans le texte suivant. Vous pouvez modifier le contrôle d'accès en modifiant le fichier oChainUtil.go. Pour utiliser votre propre contrôle d'accès ou pour désactiver le contrôle d'accès, supprimez le code de contrôle d'accès des méthodes de contrôleur et des méthodes personnalisées générées automatiquement.
  var t TokenAccess
      var r RoleAccess
      var a AccountAccess
      var as AccountStatusAccess
      var h HoldAccess
      var ad AdminAccess
      var trx TransactionAccess
      var tc TokenConversionAccess
      var auth AuthAccess
      var erc721ad ERC721AdminAccess
      var erc721t ERC721TokenAccess
      var erc721r ERC721RoleAccess
      var erc721a ERC721AccountAccess
      var erc721as ERC721AccountStatusAccess
      var erc721trx ERC721TransactionAccess
     auth.IsTokenAdmin = []string{"Admin", "MultipleAccountOwner"}

      trx.DeleteHistoricalTransactions = []string{"Admin"}
      ad.AddAdmin = []string{"Admin"}
      ad.RemoveAdmin = []string{"Admin"}
      ad.GetAllAdmins = []string{"Admin", "OrgAdmin"}
      ad.AddOrgAdmin = []string{"Admin", "OrgAdminOrgIdCheck"}
      ad.RemoveOrgAdmin = []string{"Admin", "OrgAdminOrgIdCheck"}
      ad.GetOrgAdmins = []string{"Admin", "OrgAdmin"}
      ad.IsTokenAdmin = []string{"Admin", "MultipleAccountOwner", "OrgAdmin"}
      t.Save = []string{"Admin"}
      t.GetAllTokens = []string{"Admin", "OrgAdmin"}
      t.Update = []string{"Admin"}
      t.GetTokenDecimals = []string{"Admin", "OrgAdmin"}
      t.GetTokensByName = []string{"Admin", "OrgAdmin"}
      t.AddRoleMember = []string{"Admin", "OrgAdminRoleCheck"}
      t.RemoveRoleMember = []string{"Admin", "OrgAdminRoleCheck"}
      t.IsInRole = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      t.GetTotalMintedTokens = []string{"Admin", "OrgAdmin"}
      t.GetNetTokens = []string{"Admin", "OrgAdmin"}
      t.Get = []string{"Admin", "OrgAdmin"}
      t.GetTokenHistory = []string{"Admin", "OrgAdmin"}
      a.CreateAccount = []string{"Admin", "OrgAdminOrgIdCheck"}
      a.AssociateToken = []string{"Admin", "OrgAdminAccountIdCheck"}
      a.GetAllAccounts = []string{"Admin"}
      a.GetAllOrgAccounts = []string{"Admin", "OrgAdminOrgIdCheck"}
      a.GetAccount = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.History = []string{"Admin", "AccountOwner"}
      a.GetAccountTransactionHistory = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetAccountTransactionHistoryWithFilters = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetSubTransactionsById = []string{"Admin", "TransactionInvoker"}
      a.GetSubTransactionsByIdWithFilters = []string{"Admin", "TransactionInvoker"}
      a.GetAccountBalance = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetAccountOnHoldBalance = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetOnHoldIds = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      a.GetAccountsByUser = []string{"Admin", "OrgAdminOrgIdCheck", "MultipleAccountOwner"}

      as.Get = []string{"Admin", "OrgAdminAccountIdCheck", "AccountOwner"}
      as.ActivateAccount = []string{"Admin", "OrgAdminOrgIdCheck"}
      as.SuspendAccount = []string{"Admin", "OrgAdminOrgIdCheck"}
      as.DeleteAccount = []string{"Admin", "OrgAdminOrgIdCheck"}
      r.GetAccountsByRole = []string{"Admin"}
      r.GetUsersByRole = []string{"Admin"}
      r.GetOrgAccountsByRole = []string{"Admin", "OrgAdminOrgIdCheck"}
      r.GetOrgUsersByRole = []string{"Admin", "OrgAdminOrgIdCheck"}

      tc.InitializeExchangePoolUser = []string{"Admin"}
      tc.AddConversionRate = []string{"Admin"}
      tc.UpdateConversionRate = []string{"Admin"}
      tc.GetConversionRate = []string{"Admin", "OrgAdmin", "AnyAccountOwner"}
      tc.GetConversionRateHistory = []string{"Admin", "OrgAdmin", "AnyAccountOwner"}
      tc.TokenConversion = []string{"Admin", "AnyAccountOwner"}
      tc.GetExchangePoolUser = []string{"Admin"}
      erc721ad.AddAdmin = []string{"Admin"}
      erc721ad.GetAllAdmins = []string{"Admin"}
      erc721ad.IsTokenAdmin = []string{"Admin"}
      erc721ad.RemoveAdmin = []string{"Admin"}
      erc721trx.DeleteHistoricalTransactions = []string{"Admin"}
      erc721t.Save = []string{"Admin"}
      erc721t.GetAllTokens = []string{"Admin"}
      erc721t.Update = []string{"Admin"}
      erc721t.GetTokensByName = []string{"Admin"}
      erc721t.AddRoleMember = []string{"Admin"}
      erc721t.RemoveRoleMember = []string{"Admin"}
      erc721t.IsInRole = []string{"Admin", "AccountOwner"}
      erc721t.Get = []string{"Admin", "TokenOwner"}
      erc721t.GetAllTokensByUser = []string{"Admin", "AccountOwner"}
      erc721t.TotalSupply = []string{"Admin"}
      erc721t.TotalNetSupply = []string{"Admin"}
      erc721t.History = []string{"Admin"}

      erc721a.CreateAccount = []string{"Admin"}
      erc721a.CreateUserAccount = []string{"Admin"}
      erc721a.CreateTokenAccount = []string{"Admin"}
      erc721a.AssociateFungibleTokenToAccount = []string{"Admin", "AccountOwner"}
      erc721a.GetAllAccounts = []string{"Admin"}
      erc721a.History = []string{"Admin", "AccountOwner"}
      erc721a.GetAccountTransactionHistory = []string{"Admin", "AccountOwner"}
      erc721a.GetAccountTransactionHistoryWithFilters = []string{"Admin", "AccountOwner"}
      erc721a.GetAccountByUser = []string{"Admin", "MultipleAccountOwner"}
      erc721a.BalanceOf = []string{"Admin", "MultipleAccountOwner"}
      erc721as.Get = []string{"Admin", "AccountOwner"}
      erc721as.ActivateAccount = []string{"Admin"}
      erc721as.SuspendAccount = []string{"Admin"}
      erc721as.DeleteAccount = []string{"Admin"}

      erc721r.GetAccountsByRole = []string{"Admin"}
      erc721r.GetUsersByRole = []string{"Admin"}

      var accessMap TokenAccessControl
      accessMap.Token = t
      accessMap.Account = a
      accessMap.AccountStatus = as
      accessMap.Hold = h
      accessMap.Role = r
      accessMap.Admin = ad
      accessMap.Auth = auth
      accessMap.TokenConversion = tc
      accessMap.ERC721ADMIN = erc721ad
      accessMap.ERC721TOKEN = erc721t
      accessMap.ERC721ACCOUNT = erc721a
      accessMap.ERC721AccountStatus = erc721as
      accessMap.ERC721ROLE = erc721r
      accessMap.ERC721TRANSACTION = erc721trx
Ctx.ERC721Auth.CheckAuthorization(funcName string, args []string) (bool, error)
Paramètres :
  • funcName: string – Valeur de mappage entre les récepteurs et les méthodes, comme décrit dans le fichier oChainUtil.go.
  • ...args – Argument de variable où args[0] prend la constante 'TOKEN' et args[1] prend le paramètre accountId pour ajouter une vérification de contrôle d'accès pour un AccountOwner. Pour ajouter une vérification de contrôle d'accès pour un MultipleAccountOwner, args[1] prend le paramètre orgId et args[2] prend le paramètre userId. Pour ajouter une vérification de contrôle d'accès pour un TokenOwner, args[1] prend le paramètre tokenId.
Retourne :
  • Réponse booléenne et, si nécessaire, erreur.
Exemples :
t.Ctx.ERC721Auth.CheckAuthorization(<parameters>)

Accès à Admin 

t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetAllTokens", "TOKEN")

Accès à AccountOwner 

t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.History", "TOKEN", accountId)

Accès à MultipleAccountOwner 

t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.BalanceOf", "TOKEN", orgId, userId)

Accès à TokenOwner 

t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.Get", "TOKEN", tokenId)

Méthodes de gestion de la configuration de jeton

CreateToken
Cette méthode crée un jeton et enregistre ses propriétés dans la base de données d'état. Cette méthode ne peut être appelée que par les utilisateurs ayant le rôle de minter.
Ctx.ERC721Token.CreateToken(args ...interface{})
Paramètres :
  • Argument de variable où args[0] contient une référence au jeton struct du type requis.
Retourne :
  • En cas de succès, un élément interface[] avec les détails du jeton. En cas d'erreur, un objet non vide avec un message d'erreur.
Exemple :

t.Ctx.ERC721Token.CreateToken(&tokenAsset)

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",        
    "CreationDate": "2022-04-06T08:16:53Z",
    "IsBurned": false,
     "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 100,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
}
GetAllTokens
Cette méthode retourne toutes les ressources de jeton enregistrées dans la base de données d'état. Cette méthode utilise des interrogations Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau distant Oracle Blockchain Platform.
Ctx.ERC721Token.GetAllTokens()  (interface{}, error)
Paramètres :
  • aucune
Retourne :
  • Avec succès, une carte de toutes les ressources de jeton. En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Token.GetAllTokens()

[
    {
        "key": "monalisa",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintab
 
le",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:01:42Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "token Description",
            "TokenId": "monalisa",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
    },
    {
        "key": "monalisa2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:04:44Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "monalisa1",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
        }
    }
]
GetAllTokensByUser
Cette méthode retourne tous les jetons appartenant à un ID compte spécifié. Cette méthode utilise des interrogations Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau distant Oracle Blockchain Platform.
Ctx.ERC721Token.GetAllTokensByUser(accountId string) (interface{}, error)
Paramètres :
  • accountId: string – ID du compte.
Retourne :
  • En cas de succès, une carte des ressources de jeton pour le compte spécifié. En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Token.GetAllTokensByUser(accountId)

[
    {
        "key": "monalisa",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:01:42Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "token Description",
            "TokenId": "monalisa",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
    },
    {
        "key": "monalisa2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:04:44Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "monalisa1",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
        }
    }
]
GetTokenUri
Cette méthode retourne l'URI de jeton pour un jeton spécifié.
Ctx.ERC721Token.GetTokenURI(tokenId string) (interface{}, error)
Paramètres :
  • tokenId: string – ID du jeton.
Retourne :
  • En cas de succès, il retourne une carte du nouvel URI de jeton dans le type de données de chaîne. En cas d'erreur, un objet non vide avec un message d'erreur.
Exemple :

t.Ctx.ERC721Token.GetTokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
History
Cette méthode retourne l'historique du jeton spécifié.
Ctx.ERC721Token.History(tokenId: string)  (interface{}, error)
Paramètres :
  • tokenId: string – ID du jeton.
Retourne :
  • Sur le succès, un tableau de cartes. En cas d'erreur, un rejet avec un message d'erreur.
Exemple :

t.Ctx.ERC721Token.History(tokenId)

[
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T11:34:06z",
        "TxId": "3184eac8738c73ef45501fe23c9e14517892e04e4eb03ec9be834b89c29ea17b",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "BurnedBy": null,
            "BurnedDate": null,
            "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "CreationDate": "2022-04-06T11:33:40+05:30",
            "IsBurned": null,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "t1",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "PainterName": "",
                "PaintingName": ""
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "",
            "TransferredBy": null,
            "TransferredDate": null
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T11:33:40z",
        "TxId": "d37dba907a849c308b2a38d47cf8a68cdcb4e3d93fa74050774379fccfcd43be",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "CreationDate": "2022-04-06T11:33:40+05:30",
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "t1",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "PainterName": "",
                "PaintingName": ""
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": ""
        }
    }
]
Get
Cette méthode retourne l'objet de jeton spécifié s'il est présent dans la base de données d'état.
Ctx.Get(Id string, result ...interface{}) (interface{}, error)
Paramètres :
  • tokenId: string – ID du jeton.
  • result – Argument de variable, où le premier argument result[0] est une référence à un objet Token vide de type correct, qui contiendra les données du jeton après un appel réussi de la méthode.
Retourne :
  • En cas de succès, une carte avec les données de la ressource de jeton. De plus, si result[0] est transmis, les données sont affectées à result[0]. En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Token.Get(tokenId, &asset)

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2022-04-06T00:35:42z",
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 200,
    "Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "Token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
    "TransferredBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "TransferredDate": "2022-04-06T00:51:56z"
}
OwnerOf
Cette méthode retourne l'ID compte du responsable d'un jeton spécifié.
Ctx.ERC721Token.OwnerOf(tokenId string) (interface{}, error)
Paramètres :
  • tokenId: string – ID du jeton.
Retourne :
  • En cas de succès, une carte de l'ID compte du responsable dans le type de données de chaîne. En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Token.OwnerOf(tokenId)

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
Name
Cette méthode retourne le nom de la classe de jeton.
Ctx.ERC721Token.Name() (interface{}, error)
Paramètres :
  • aucune
Retourne :
  • En cas de succès, une carte du nom du jeton dans le type de données de chaîne. En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Token.Name()

{"TokenName": "paintingnft"}
Symbol
Cette méthode retourne le symbole de la classe de jeton.
Ctx.ERC721Token.Symbol() (interface{}, error)
Paramètres :
  • aucune
Retourne :
  • En cas de succès, une carte du symbole dans le type de données de chaîne. En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}
TokenUri
Cette méthode retourne l'URI de jeton pour un jeton spécifié.
Ctx.ERC721Token.TokenURI(tokenId string) (interface{}, error)
Paramètres :
  • tokenId: string – ID du jeton.
Retourne :
  • En cas de succès, il retourne une carte du nouvel URI de jeton dans le type de données de chaîne. En cas d'erreur, un objet non vide avec un message d'erreur.
Exemple de valeur renvoyée :

t.Ctx.ERC721Token.TokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
TotalSupply
Cette méthode retourne le nombre total d'opérations de transfert de fonds (NFT) minées.
Ctx.ERC721Token.TotalSupply() (map[string]interface{}, error)
Paramètres :
  • tokenId: string – ID du jeton.
Retourne :
  • En cas de succès, une carte de l'approvisionnement total de jetons dans le type de données numérique. En cas d'erreur, un rejet avec un message d'erreur.
Exemple :

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}
UpdateToken
Cette méthode met à jour les propriétés du jeton. Cette méthode ne peut être appelée que par le propriétaire ou le créateur du jeton. Après la création d'une ressource de jeton, seul le responsable du jeton peut mettre à jour les propriétés personnalisées du jeton. Si l'utilisateur est à la fois responsable et créateur d'un jeton, il peut également mettre à jour la propriété TokenDesc. Les métadonnées du jeton ne peuvent pas être mises à jour. Vous devez transmettre toutes les propriétés de jeton à cette méthode, même si vous souhaitez mettre à jour uniquement certaines propriétés. 
Ctx.ERC721Token.UpdateToken(asset interface{}) (interface{}, error)
Paramètres :
  • Référence aux données de structure de jeton du type requis
Retourne :
  • En cas de succès, un message de promesse avec les détails du jeton. En cas d'erreur, un rejet avec un message d'erreur.
Exemple :

t.Ctx.ERC721Token.UpdateToken(&asset)

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",     
    "CreationDate": "2022-04-06T08:16:53Z",
    "IsBurned": false,   
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 200,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "Token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
}
GetNewCtx
Cette méthode retourne un nouvel objet TrxContext. La structure trxcontext contient des références à toutes les bibliothèques SDK. Accédez aux méthodes de la trousse SDK en utilisant uniquement cet objet. L'objet trxcontext conserve l'exclusivité mutuelle des talons de transaction dans les bibliothèques SDK lors de l'exécution de transactions concurrentes. 
GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext
Paramètres :
  • stub – Tête de transaction.
Retourne :
  • Une structure trxcontext.
Exemple :

trxcontext.GetNewCtx(stub)

trxcontext object.

Méthodes de gestion des comptes

GenerateAccountId
Cette méthode retourne un ID compte, formé par la concaténation de l'ID fournisseur de services d'adhésion (orgId) et du nom d'utilisateur ou de l'ID courriel (userId), puis la création d'un hachage SHA-256. 
Ctx.ERC721Account.GenerateAccountId(orgId string, userId string) (string, error)
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, l'ID compte généré. En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)

oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507
CreateAccount
Cette méthode crée un compte pour un utilisateur spécifié. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Les comptes suivent le nombre d'opérations de transfert de fonds (NFT) dont dispose un utilisateur. Les utilisateurs doivent avoir des comptes dans le réseau pour effectuer des opérations liées au jeton. Vous ne pouvez créer qu'un seul compte NFT par utilisateur.

Un ID compte est un jeu alphanumérique de caractères, précédé de oaccount~ et suivi d'un hachage SHA-256 de l'ID fournisseur de services d'adhésion (org_id) de l'utilisateur dans l'organisation réseau courante, du nom d'utilisateur ou de l'ID courriel (userId) du responsable de l'instance ou de l'utilisateur connecté à l'instance, et de la chaîne constante nft. 

Ctx.ERC721Account.CreateAccount(orgId string, userId string, tokenType string) (ERC721Account, error)
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
  • tokenType: string – Le seul type de jeton pris en charge est nonfungible.
Retourne :
  • En cas de succès, le nouvel objet de compte. En cas d'erreur, un objet non vide contenant un message d'erreur
Exemple :

t.Ctx.ERC721Account.CreateAccount(orgId, userId, tokenType)

{
    "AssetType": "oaccount",
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "BapAccountVersion" : 0,
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
BalanceOf
Cette méthode retourne le nombre total de NFT bloqués par l'utilisateur spécifié.
Ctx.ERC721Account.BalanceOf(accountId string) (interface{}, error)
Paramètres :
  • accountId: string – ID compte de l'utilisateur.
Retourne :
  • En cas de succès, une interface avec un message et le nombre total de NFT. En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Account.BalanceOf(accountId)

{"TotalNfts": 0}
GetAllAccounts
Cette méthode retourne une liste de tous les comptes. Cette méthode utilise des interrogations Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau distant Oracle Blockchain Platform.
Ctx.ERC721Account.GetAllAccounts() (interface{}, error)
Paramètres :
  • aucune
Retourne :
  • Tableau JSON de tous les comptes.
Exemple :

t.Ctx.ERC721Account.GetAllAccounts()

[
    {
        "key": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "valueJson": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "BapAccountVersion" : 0,
            "AssetType": "oaccount",
            "NoOfNfts": 5,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    },
    {
        "key": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "valueJson": {
            "AccountId": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user_minter"
        }
    },
    {
        "key": "oaccount~5541fb520058d83664b844e7a55fe98d574ddeda765d0e795d4779e9ccc271ce",
        "valueJson": {
            "AccountId": "oaccount~5541fb520058d83664b844e7a55fe98d574ddeda765d0e795d4779e9ccc271ce",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user_burner"
        }
    }
]
GetAccountByUser
Cette méthode retourne les détails du compte pour un utilisateur spécifié. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne ou le Account Owner du compte. 
Ctx.ERC721Account.GetAccountByUser(orgId, userId) (ERC721Account, error)
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, un objet de compte JSON qui inclut les propriétés suivantes :
  • AccountId – ID du compte d'utilisateur.
  • UserId – Nom d'utilisateur ou ID courriel de l'utilisateur.
  • OrgId – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • TokenType – Type de jeton que le compte détient.
  • NoOfNfts – Le nombre total de NFT détenus par le compte.
  • En cas d'erreur, un objet non vide qui contient un message d'erreur.
Exemple :
{
    "AssetType": "oaccount",
    "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "BapAccountVersion" : 0,
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
GetUserByAccountId
Cette méthode retourne les détails de l'utilisateur pour un compte spécifié.
Ctx.ERC721Account.GetUserByAccountId(accountId string) (interface{}, error)
Paramètres :
  • accountId: string – ID du compte.
Retourne :
  • En cas de succès, un objet JSON qui inclut les détails de l'utilisateur dans les propriétés suivantes :
    • OrgId – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation réseau courante.
    • UserId – Nom d'utilisateur ou ID courriel de l'utilisateur.
  • En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
History
Cette méthode retourne un tableau des détails de l'historique de compte pour un compte spécifié.
Ctx.ERC721Account.History(accountId string) (interface{}, error)
Paramètres :
  • accountId: string – ID du compte.
Retourne :
  • En cas de succès, un tableau map[string]interface{} qui contient les détails de l'historique du compte spécifié. Les données du compte sont affichées sous la clé value dans la carte. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Account.History(accountId)

[
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T08:16:53Z",
        "TxId": "750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "Value": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "BapAccountVersion" : 1,
            "NoOfNfts": 1,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T08:15:19Z",
        "TxId": "49eb84c42d452e5ba0028d8ebb4190454cf9013a11c0bad3e96594af452d4982",
        "Value": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "NoOfNfts": 0,
            "BapAccountVersion" : 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    }
]
GetAccountWithStatusByUser
Cette méthode retourne les détails du compte pour un utilisateur spécifié, notamment le statut du compte. Cette méthode ne peut être appelée que par un Token Admin du code de chaîne ou le Account Owner du compte. 
Ctx.ERC721Account.GetAccountWithStatusByUser(orgId, userId) (interface{}, error)
Paramètres :
  • orgId: string – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • userId: string – Nom d'utilisateur ou ID courriel de l'utilisateur.
Retourne :
  • En cas de succès, un objet de compte JSON qui inclut les propriétés suivantes :
  • AccountId – ID du compte d'utilisateur.
  • UserId – Nom d'utilisateur ou ID courriel de l'utilisateur.
  • OrgId – ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
  • TokenType – Type de jeton que le compte détient.
  • NoOfNfts – Le nombre total de NFT détenus par le compte.
  • BapAccountVersion – Paramètre d'objet de compte à usage interne.
  • Status – Le statut actuel du compte d'utilisateur.
  • En cas d'erreur, un objet non vide qui contient un message d'erreur.
Exemple :
{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}

Méthodes de gestion des rôles

AddRoleMember
Cette méthode ajoute un rôle à un utilisateur spécifié.
Ctx.ERC721Token.AddRoleMember(role string, accountId string) (interface{}, error)
Paramètres :
  • role: string – Nom du rôle à ajouter à l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
  • accountId: number – ID compte sur lequel opérer.
Retourne :
  • En cas de succès, une carte avec un message de réussite. En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Token.AddRoleMember(userRole, accountId)

{"msg": "Successfully added role minter to oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin)"}
RemoveRoleMember
Cette méthode supprime un rôle d'un utilisateur et d'un jeton spécifiés. Un ID compte est formé par la création d'un hachage SHA-256 de l'ID fournisseur de services d'adhésion concaténé (orgId) et du nom d'utilisateur ou de l'ID courriel (userId). 
Ctx.Token.RemoveRoleMember(role string, accountId string) (interface{}, error)
Paramètres :
  • role: string – Nom du rôle à supprimer de l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
  • accountId: number – ID compte sur lequel opérer.
Retourne :
  • En cas de succès, une carte avec un message de réussite. En cas d'erreur, un objet non vide contenant un message d'erreur.
Exemple :

t.Ctx.ERC721Token.RemoveRoleMember(userRole, accountId)

{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}
GetAccountsByRole
Cette méthode retourne une liste de tous les ID compte pour un rôle spécifié.
Ctx.ERC721Role.GetAccountsByRole(roleName string) (interface{}, error)
Paramètres :
  • roleName: string – Nom du rôle à rechercher.
Retourne :
  • En cas de succès, un tableau JSON d'ID compte. En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Role.GetAccountsByRole(userRole)

{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
Cette méthode retourne une liste de tous les utilisateurs pour un rôle spécifié.
Ctx.ERC721Role.GetUsersByRole(roleName string) (interface{}, error)
Paramètres :
  • roleName: string – Nom du rôle à rechercher.
Retourne :
  • En cas de succès, un tableau JSON d'objets utilisateur. Chaque objet contient le code d'utilisateur et le code d'organisation. En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Role.GetUsersByRole(userRole)

{
    "Users": [
        {
            "OrgId": "Org1MSP",
            "UserId": "admin"
        }
    ]
}
IsInRole
Cette méthode retourne une valeur booléenne pour indiquer si un utilisateur et un jeton ont un rôle spécifié. Un ID compte est formé par la création d'un hachage SHA-256 de l'ID fournisseur de services d'adhésion concaténé (orgId) et du nom d'utilisateur ou de l'ID courriel (userId). 
Ctx.ERC721Token.IsInRole(role string, accountId string) (bool, error)
Paramètres :
  • role: string – Nom du rôle à vérifier pour l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
  • accountId: number – ID compte sur lequel opérer.
Retourne :
  • En cas de succès, une valeur booléenne qui est vraie si le rôle est présent pour l'ID compte spécifié, sinon fausse. En cas d'erreur, un objet non vide contenant un message d'erreur
Exemple :

t.Ctx.ERC721Token.IsInRole(userRole, accountId)

{"result": false}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory
Cette méthode retourne un tableau des détails de l'historique des transactions pour un compte spécifié.
Ctx.ERC721Account.GetAccountTransactionHistory(accountId string) (interface{}, error)
Paramètres :
  • accountId: string – ID du compte.
Retourne :
  • En cas de succès, un tableau d'objets de transaction de compte au format JSON :
    • TransactionId – ID de la transaction.
    • TransactedAccount – Compte avec lequel la transaction a eu lieu.
    • TransactionType – Le type de transaction.
    • Timestamp – Heure de la transaction.
    • En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Account.GetAccountTransactionHistory(accountId)

[
     {
        "Timestamp": "2022-04-06T08:31:39Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
        "TransactionType": "DEBIT"
    }
    {
        "Timestamp": "2022-04-06T08:16:53Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "TransactionId": "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "TransactionType": "MINT"
    }
]
GetAccountTransactionHistoryWithFilters
Cette méthode retourne l'historique des transactions de compte pour un utilisateur spécifié, filtré par PageSize, Bookmark, startTime et endTime. Cette méthode ne peut être appelée que si elle est connectée au réseau Oracle Blockchain Platform distant. 
Ctx.ERC721Account.GetAccountTransactionHistoryWithFilters(accountId string, filters ...erc721Account.AccountHistoryFilters)
Paramètres :
  • accountId: string – ID du compte.
  • filters: string – Paramètre facultatif. Si vide, tous les enregistrements sont retournés. La propriété PageSize détermine le nombre d'enregistrements à retourner. Si PageSize a la valeur 0, la taille de page par défaut est 20. La propriété Bookmark détermine l'index de début des enregistrements à retourner. Pour plus d'informations, consultez la documentation sur Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.
Retourne :
  • En cas de succès, un tableau d'objets de transaction de compte au format JSON :
    • TransactionId – ID de la transaction.
    • TransactedAccount – Compte avec lequel la transaction a eu lieu.
    • TransactionType – Le type de transaction.
    • Timestamp – Heure de la transaction.
    • En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Account.GetAccountTransactionHistoryWithFilters(accountId, filters...)

[
     {
        "Timestamp": "2022-04-06T08:31:39Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
        "TransactionType": "DEBIT"
    }
    {
        "Timestamp": "2022-04-06T08:16:53Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "TransactionId": "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "TransactionType": "MINT"
    }
]
GetTransactionById
Cette méthode retourne l'historique d'une ressource Transaction. 
Ctx.ERC721Transaction.GetTransactionById(trxId string) (interface{}, error)
Paramètres :
  • trxId: string – ID de la ressource de transaction.
Retourne :
  • En cas de succès, un tableau de mappages d'actifs de transaction. En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Transaction.GetTransactionById(transactionId)

{
    "History": [
        {
            "IsDelete": "false",
            "Timestamp": "2022-04-06T08:31:39Z",
            "TxId": "5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
            "Value": {
                "AssetType": "otransaction",
                "Data": "",
                "FromAccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
                "Timestamp": "2022-04-06T08:31:39Z",
                "ToAccountId": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
                "TokenId": "monalisa",
                "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
                "TransactionType": "TRANSFER",
                "TriggeredByAccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1"
            }
        }
    ],
    "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7"
}
DeleteHistoricalTransactions
Cette méthode supprime de la base de données d'état les transactions antérieures à une date spécifiée.
func (t *Controller) DeleteHistoricalTransactions(referenceTime string) (interface{}, error)
Paramètres :
  • referenceTime: string – Les transactions antérieures à l'heure spécifiée seront supprimées.
Retourne :
  • En cas de succès, un tableau des ID transaction supprimés et un message de réussite. En cas d'erreur, un objet d'erreur non vide qui contient un message d'erreur.
Exemple :

t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)

{
    "Transactions": [
        "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7"
    ],
    "msg": "Successfuly deleted transaction older than date:2022-04-06T08:17:53Z"
}

Gestion du comportement des jetons - Comportement mentable

GetMaxMintQuantity
Cette méthode retourne la quantité minimale maximale d'un jeton. Si le comportement max_mint_quantity n'est pas configuré dans le fichier de spécification, la valeur par défaut est 0 et un nombre infini de jetons peut être extrait. 
Ctx.ERC721Token.GetMaxMintQuantity(id string) (float64, error)
Paramètres :
  • id - ID du jeton sur lequel opérer.
Retourne :
  • En cas de succès, quantité mintable maximale du jeton, dans le type de données numérique. En cas d'erreur, un objet non vide avec un message d'erreur.
Exemple :

t.Ctx.ERC721Token.GetMaxMintQuantity(tokenId);

20000
GetTotalMintedTokens
Cette méthode retourne le nombre net total de jetons disponibles dans le système pour le jeton spécifié. Le nombre net de jetons disponibles est le nombre total de jetons frappés moins le nombre de jetons brûlés.
Ctx.ERC721Token.GetTotalMintedTokens() (map[string]interface{}, error)
Paramètres :
  • aucune
Retourne :
  • En cas de succès, une carte du nombre total de jetons frappés, dans le type de données numérique, et un message de réussite. En cas d'erreur, un objet non vide avec un message d'erreur.
Exemple :

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

Gestion du comportement des jetons - Comportement transférable

SafeTransferFrom
Cette méthode transfère la propriété du NFT spécifié de l'appelant à un autre compte. Cette méthode comprend les validations suivantes :
  • Le jeton existe et n'est pas brûlé.
  • Le compte de l'expéditeur et le compte destinataire existent et ne sont pas le même compte.
  • Le compte de l'expéditeur est responsable du jeton.
  • L'appelant de la fonction est l'expéditeur.
Ctx.ERC721Token.SafeTransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}, data ...string) (interface{}, error)
Paramètres :
  • fromAccountId: string – ID compte de l'expéditeur dans l'organisation courante.
  • toAccountId: string – ID compte du destinataire dans l'organisation courante.
  • tokenAsset - Référence à la ressource de jeton sur laquelle opérer.
  • data: string – Informations supplémentaires facultatives à stocker dans la transaction.
Retourne :
  • En cas de réussite, une promesse avec un message de réussite qui inclut les détails du compte. En cas d'erreur, un objet non vide avec un message d'erreur.
Exemple :

t.Ctx.ERC721Token.SafeTransferFrom(fromAccountId, toAccountId, tokenAssetValue.Interface(), data...)

{"msg": "Successfully transferred NFT token: 'monalisa' from Account-Id: oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (Org-Id: Org1MSP, User-Id: admin) to Account-Id: oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba (Org-Id: Org1MSP, User-Id: user1"}
TransferFrom
Cette méthode transfère la propriété du NFT spécifié d'un compte d'expéditeur à un compte de destinataire. Il est de la responsabilité de l'appelant de transmettre les paramètres corrects. Cette méthode peut être appelée par n'importe quel utilisateur, pas seulement par le propriétaire du jeton. Cette méthode comprend les validations suivantes :
  • Le jeton existe et n'est pas brûlé.
  • Le compte de l'expéditeur et le compte destinataire existent et ne sont pas le même compte.
  • Le compte de l'expéditeur est responsable du jeton.
Ctx.ERC721Token.TransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}) (interface{}, error)
Paramètres :
  • fromAccountId: string – ID compte de l'expéditeur dans l'organisation courante.
  • toAccountId: string – ID compte du destinataire dans l'organisation courante.
  • tokenAsset - Référence à la ressource de jeton sur laquelle opérer.
Retourne :
  • En cas de réussite, une promesse avec un message de réussite qui inclut les détails du compte. Les ID compte ont le préfixe oaccount~. En cas d'erreur, un objet non vide avec un message d'erreur.
\Exemple :

t.Ctx.ERC721Token.TransferFrom(fromAccountId, toAccountId, tokenAssetValue.Interface())

{"msg": "Successfully transferred NFT token: 'monalisa' from Account-Id: oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (Org-Id: Org1MSP, User-Id: admin) to Account-Id: oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba (Org-Id: Org1MSP, User-Id: user1"}

Gestion du comportement des jetons - Comportement Burnable

Burn
Cette méthode désactive ou brûle le NFT spécifié à partir du compte de l'appelant. L'appelant de cette méthode doit avoir un compte. Un jeton ne peut pas être gravé sauf si le fichier de spécification de jeton inclut le comportement burnable. Si aucune propriété burner_role_name n'est spécifiée dans la section roles du fichier de spécification, le responsable du jeton peut graver le jeton. Si une propriété burner_role_name est spécifiée dans la section roles, l'utilisateur a affecté le rôle de brûleur qui est également le créateur du jeton peut graver le jeton. La méthode burn fait partie de l'ensemble ERC721Token, auquel vous accédez au moyen du récepteur de la structure Ctx. 
Ctx.Token.Burn(tokenAsset interface{}) (interface{}, error)
Paramètres :
  • tokenAsset - Référence à la ressource de jeton sur laquelle opérer.
Retourne :
  • En cas de réussite, une promesse avec un message de réussite qui inclut les détails du compte. En cas d'erreur, un objet non vide avec un message d'erreur.
Exemple :

t.Ctx.ERC721Token.Burn(tokenAssetValue.Interface())

{"msg": "Successfully burned NFT token: 'monalisa' from Account-Id: oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (Org-Id: Org1MSP, User-Id: admin"}