1. Utilisation d'Oracle Blockchain Platform
  2. Créer des codes chaîne avec un générateur d'applications de chaîne de blocs avec peu de code
  3. Prise en charge de la création de jetons à l'aide de Blockchain App Builder
  4. ERC-721
  5. Projet d'échafaudage Go NFT pour ERC-721

Projet d'échafaudage 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 chaîne entièrement fonctionnel.

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

Pour plus d'informations sur le projet échafaudé et les méthodes qui ne sont pas directement liées aux NFT, reportez-vous à Projet de code chaîne Go échafaudé.

Référence:

Modèle

La capacité de persistance transparente, ou ORM simplifié, est capturée 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"`
}

Contrôleur

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

type Controller struct {
    Ctx trxcontext.TrxContext
}

Vous pouvez créer autant de classes, de fonctions ou de fichiers que vous le souhaitez, 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 SDK de jeton pour écrire des méthodes personnalisées pour votre application métier.

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 de 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 de cycle de vie NFT sans codage supplémentaire. Les méthodes de contrôleur doivent être publiques pour pouvoir être appelées. Les noms de méthode publics commencent par un caractère majuscule. Les noms de méthode qui commencent 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'utilisateur Token Admin du code chaîne. Cette méthode ne peut être appelée que par un élément Token Admin du code 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • En cas de réussite, message qui inclut les détails de l'utilisateur qui a été ajouté en tant que Token Admin du code chaîne.
Exemple de valeur renvoyée :
{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveTokenAdmin
Cette méthode enlève un utilisateur en tant qu'utilisateur Token Admin du code chaîne. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne. Vous ne pouvez pas utiliser cette méthode pour vous enlever 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • En cas de réussite, message qui inclut les détails de l'utilisateur qui a été enlevé en tant qu'élément Token Admin du code chaîne.
Exemple de valeur renvoyée :
{"msg":"Successfully removed Admin (OrgId Org1MSP UserId user1)"}
IsTokenAdmin
Cette méthode renvoie la valeur booléenne true si l'appelant de la fonction est un Token Admin, sinon elle renvoie false. Un Token Admin peut appeler cette fonction sur n'importe quel autre utilisateur du réseau de chaîne de blocs. D'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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • La méthode renvoie true si l'appelant est un Token Admin, sinon elle renvoie false.
Exemple de valeur renvoyée :
{"result":true}
GetAllTokenAdmins
Cette méthode renvoie la liste de tous les utilisateurs qui sont un Token Admin du code chaîne. Cette méthode ne peut être appelée que par Token Admin du code 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 :
  • Aucun élément
Renvoie :
  • En cas de succès, liste JSON des administrateurs incluant les 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 chaîne est instancié. Chaque élément Token Admin est identifié par les informations UserId et OrgId dans le paramètre adminList. UserId est le nom utilisateur ou l'ID courriel du propriétaire de l'instance ou de l'utilisateur connecté à l'instance. OrgId est l'ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation réseau actuelle. Le paramètre adminList est obligatoire lors du premier déploiement du code chaîne. Si vous mettez à niveau le code 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 indique la liste des administrateurs de jeton. Le tableau adminList est un paramètre obligatoire.
GetAllTokens
Cette méthode renvoie 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 élément Token Admin du code chaîne. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant. 
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 :
  • Aucun élément
Renvoie :
  • 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 renvoie toutes les ressources de jeton appartenant à un utilisateur spécifié. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant. Cette méthode peut uniquement être appelée par un élément Token Admin du code chaîne ou par le propriétaire 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • 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 renvoie 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 un élément Token Admin du code chaîne ou du propriétaire 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.
Renvoie :
  • 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 renvoie l'historique d'un ID de jeton spécifié. Cette méthode ne peut être appelée qu'en cas de connexion 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 utilitaire qui renvoie une instance du jeton pour un ID de jeton spécifié. Cette méthode est utilisée par la plupart des méthodes générées automatiquement pour extraire les objets de jeton. Vous pouvez appeler cette méthode selon vos besoins à partir de vos méthodes personnalisées. Lorsque vous créez une classe ou une ressource avec jeton, mettez à jour la casse du commutateur avec la classe Token correspondante pour renvoyer l'objet de jeton correct. La commande ochain sync dans Blockchain App Builder crée automatiquement un cas de commutateur lorsqu'une ressource avec jeton est créée dans le fichier de spécification. Cette méthode étant privée, elle ne peut pas être appelée directement 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 renvoie l'ID de compte du propriétaire de l'ID de 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.
Renvoie :
  • Objet JSON de l'ID de compte du propriétaire.
Exemple de valeur renvoyée :
{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
Name
Cette méthode renvoie 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 :
  • Aucun élément
Renvoie :
  • Objet JSON du nom de jeton.
Exemple de valeur renvoyée :
{"TokenName": "paintingnft"}
Symbol
Cette méthode renvoie 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 :
  • Aucun élément
Renvoie :
  • Objet JSON du symbole de jeton.
Exemple de valeur renvoyée :
{"Symbol": "PNT"}
TokenURI
Cette méthode renvoie 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.
Renvoie :
  • 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 renvoie le nombre total de jetons extraits. Cette méthode ne peut être appelée que par un élément Token Admin du code 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 :
  • Aucun élément
Renvoie :
  • En cas de succès, un objet JSON du nombre de jetons.
Exemple de valeur renvoyée :
{"TotalSupply": 3}
TotalNetSupply
Cette méthode renvoie 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 élément Token Admin du code 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 :
  • Aucun élément
Renvoie :
  • 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 de NFT dont dispose un utilisateur. Les utilisateurs doivent disposer de comptes sur le réseau pour effectuer les opérations liées aux jetons. Vous ne pouvez créer qu'un seul compte NFT par utilisateur.

Un ID de compte est un ensemble alphanumérique de caractères, préfixé par oaccount~ et suivi d'un hachage SHA-256 de l'ID de fournisseur de services d'appartenance (OrgId) de l'utilisateur dans l'organisation réseau en cours, du nom utilisateur ou de l'ID de courriel (UserId) du propriétaire 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 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
  • tokenType: string : le seul type de jeton pris en charge est nonfungible.
Renvoie :
  • En cas de succès, objet JSON du compte 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 renvoie le nombre total de NFT détenus par un utilisateur spécifié. Cette méthode peut uniquement être appelée par un élément Token Admin du code chaîne ou par le propriétaire 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • Objet JSON du nombre NFT en cours.
Exemple de valeur renvoyée :
{"totalNfts": 0}
GetAllAccounts
Cette méthode renvoie la liste de tous les comptes. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant. 
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 :
  • Aucun élément
Renvoie :
  • 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 renvoie les détails du compte d'un utilisateur spécifié. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • En cas de succès, un objet de compte JSON qui inclut les propriétés suivantes :
  • AccountId : ID du compte utilisateur.
  • UserId : nom utilisateur ou ID courriel de l'utilisateur.
  • OrgId : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • TokenType : type de jeton détenu par le compte.
  • NoOfNfts : nombre total de NFT détenus par le compte.
  • BapAccountVersion : paramètre d'objet de compte à usage interne.
  • Status : statut en cours du compte 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 renvoie les détails utilisateur d'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.
Renvoie :
  • En cas de succès, objet JSON des détails de l'utilisateur (OrgId et UserId).
Exemple de valeur renvoyée :
{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
GetAccountHistory
Cette méthode renvoie l'historique des comptes d'un utilisateur spécifié. Cette méthode peut uniquement être appelée par un élément Token Admin du code chaîne ou par le propriétaire 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • 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 élément Token Admin du code 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 indiqué. 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • En cas de succès, un message contenant 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 élément Token Admin du code 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 à enlever de l'utilisateur indiqué. 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • En cas de succès, un message contenant 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 renvoie la liste de tous les ID de compte pour un rôle spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code 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.
Renvoie :
  • En cas de réussite, un tableau JSON d'ID de compte.
Exemple de valeur renvoyée :
{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
Cette méthode renvoie la liste de tous les utilisateurs pour un rôle spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code 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.
Renvoie :
  • En cas de réussite, tableau JSON des objets utilisateur (orgId et userId).
Exemple de valeur renvoyée :
{
    "Users": [
        {
            "OrgId": "Org1MSP",
            "UserId": "admin"
        }
    ]
}
IsInRole
Cette méthode renvoie une valeur booléenne pour indiquer si un utilisateur a un rôle spécifié. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
  • userRole: string : nom du rôle à rechercher.
Renvoie :
  • En cas de succès, 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 renvoie l'historique des transactions de compte pour un utilisateur spécifié. Cette méthode peut être appelée par le fichier Token Admin du code chaîne ou le propriétaire 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • 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 renvoie 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 qu'en cas de connexion au réseau Oracle Blockchain Platform distant. Cette méthode peut uniquement être appelée par un élément Token Admin du code chaîne ou par le propriétaire 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
  • filters: string : paramètre facultatif. Si ce champ est vide, tous les enregistrements sont renvoyés. La propriété PageSize détermine le nombre d'enregistrements à renvoyer. Si PageSize est égal à 0, la taille de page par défaut est de 20. La propriété Bookmark détermine l'index de début des enregistrements à renvoyer. Pour plus d'informations, reportez-vous à la documentation Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.
Renvoie :
  • 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 renvoie l'historique des transactions pour un ID de transaction spécifié. Cette méthode peut uniquement être appelée par un élément Token Admin du code chaîne ou par le propriétaire 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.
Renvoie :
  • 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 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 : horodatage. Toutes les transactions antérieures à l'horodatage seront supprimées.
Renvoie :
  • 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 Mintable

Create<Token Name>Token
Cette méthode crée 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 de la 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 minter. Sinon, tout appelant peut effectuer des opérations 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 à miner. Pour plus d'informations sur les propriétés de la ressource de jeton, reportez-vous au fichier de spécification d'entrée.
Renvoie :
  • En cas de réussite, objet de ressource de jeton JSON qui inclut les propriétés suivantes :
  • Behavior : description de tous les comportements de jeton.
  • CreatedBy : ID de 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 NFT identifiée par tokenId est brûlée.
  • Mintable : description des propriétés du comportement de la table minimale. La propriété max_mint_quantity indique le nombre maximal de NFT de cette classe de jeton pouvant être créés.
  • Owner : ID de compte du propriétaire actuel du jeton. Pendant le 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 de jeton. Cette méthode ne peut être appelée que par l'utilisateur propriétaire ou créateur du jeton. Après la création d'une ressource de jeton, seul le propriétaire du jeton peut mettre à jour les propriétés personnalisées du jeton. Si l'utilisateur est à la fois propriétaire et créateur d'un jeton, il peut également mettre à jour la propriété TokenDesc. Les métadonnées de 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, reportez-vous au fichier de spécification d'entrée.
Renvoie :
  • En cas de succès, 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é de la NFT spécifiée de l'appelant vers un autre compte. Cette méthode inclut les validations suivantes :
  • Le jeton existe et n'est pas gravé.
  • Le compte expéditeur et le compte destinataire existent et ne sont pas identiques.
  • Le compte expéditeur est propriétaire 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 du fournisseur de services d'adhésion de l'expéditeur dans l'organisation actuelle.
  • fromUserId: string : nom utilisateur ou ID de courriel de l'expéditeur.
  • toOrgId: string : ID du fournisseur de services d'adhésion du destinataire dans l'organisation en cours.
  • toUserId: string : nom utilisateur ou ID de courriel du destinataire.
  • tokenId: string : ID du jeton à transférer.
  • data: string : informations supplémentaires facultatives à stocker dans l'enregistrement de transaction.
Renvoie :
  • 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é de la NFT spécifiée d'un compte expéditeur vers un compte 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 inclut les validations suivantes :
  • Le jeton existe et n'est pas gravé.
  • Le compte expéditeur et le compte destinataire existent et ne sont pas identiques.
  • Le compte expéditeur est propriétaire 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 du fournisseur de services d'adhésion de l'expéditeur dans l'organisation actuelle.
  • fromUserId: string : nom utilisateur ou ID de courriel de l'expéditeur.
  • toOrgId: string : ID du fournisseur de services d'adhésion du destinataire dans l'organisation en cours.
  • toUserId: string : nom utilisateur ou ID de courriel du destinataire.
  • tokenId: string : ID du jeton à transférer.
Renvoie :
  • 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 de gestion du comportement des jetons - Comportement gravable

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 indiquée dans la section roles du fichier de spécification, le propriétaire du jeton peut graver le jeton. Si une propriété burner_role_name est indiquée dans la section roles, l'utilisateur qui a affecté le rôle de brûleur, qui est également le mineurs (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.
Renvoie :
  • En cas de succès, un message contenant 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 brûle le NFT spécifié à partir du compte de l'appelant, et renvoie 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 indiquée dans la section roles du fichier de spécification, le propriétaire du jeton peut graver le jeton. Si une propriété burner_role_name est indiquée dans la section roles, l'utilisateur qui a affecté le rôle de brûleur, qui est également le mineurs (créateur) ou le propriétaire 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.
Renvoie :
  • En cas de succès, 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 SDK de jeton pour écrire des méthodes personnalisées pour votre application métier.

L'exemple suivant montre comment utiliser des méthodes SDK de jeton dans des méthodes personnalisées. Lorsque la méthode Sell est appelée, elle envoie un jeton à la vente 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 SDK NFT

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

Le 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 fonctionnalité pour vous assurer que les opérations sont effectuées uniquement 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';
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 du package erc721Auth, auquel vous accédez via la structure Ctx (récepteur). Le mapping de 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 correspondance entre les récepteurs et les méthodes, comme décrit dans le fichier oChainUtil.go.
  • ...args : argument de variable dans lequel 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 AccountOwner. Afin d'ajouter une vérification de contrôle d'accès pour MultipleAccountOwner, args[1] prend le paramètre orgId et args[2] prend le paramètre userId. Afin d'ajouter une vérification de contrôle d'accès pour un élément TokenOwner, args[1] prend le paramètre tokenId.
Renvoie :
  • Une réponse booléenne et, si nécessaire, une erreur.
Exemples :
t.Ctx.ERC721Auth.CheckAuthorization(<parameters>)

Admin accès 

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)
IsUserTokenAdmin
Cette méthode renvoie une correspondance avec la valeur booléenne true si l'appelant de la fonction est un Token Admin. Sinon, la méthode renvoie false. 
Ctx.ERC721Auth.IsUserTokenAdmin(orgId string, userId string)  (interface{}, error)
Paramètres :
  • orgId : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation réseau actuelle.
  • userId : nom utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • Réponse booléenne.
Par exemple :

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

{"result":true}
AddAdmin
Cette méthode ajoute un utilisateur en tant qu'utilisateur Token Admin du code chaîne de jeton. 
Ctx.ERC721Admin.AddAdmin(orgId string, userId string) (interface{}, error)
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • En cas de réussite, message répertoriant les détails de l'utilisateur ajouté en tant qu'élément Token Admin du code chaîne de jeton. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par exemple :

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

{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveAdmin
Cette méthode enlève un utilisateur en tant qu'utilisateur Token Admin du code chaîne de jeton. 
Ctx.ERC721Admin.RemoveAdmin(orgId string, userId string) (interface{}, error)
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • En cas de réussite, message répertoriant les détails de l'utilisateur enlevé en tant qu'élément Token Admin du code chaîne de jeton. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par exemple :

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

{"msg":"Successfuly removed Admin (OrgId Org1MSP UserId user1)"}
GetAllAdmins
Cette méthode renvoie la liste de tous les utilisateurs Token Admin. 
Ctx.ERC721Admin.GetAllAdmins() (Admin[], error)
Paramètres :
  • Aucun élément
Renvoie :
  • En cas de réussite, liste de tous les utilisateurs Token Admin. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par exemple :

t.Ctx.ERC721Admin.GetAllAdmins()

{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}
GetAllAdminUsers
Cette méthode renvoie la liste de tous les utilisateurs Token Admin. 
Ctx.ERC721Admin.GetAllAdminUsers() (interface{}, error)
Paramètres :
  • Aucun élément
Renvoie :
  • En cas de réussite, liste de tous les utilisateurs Token Admin au format map[string]interface{}. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par exemple :

t.Ctx.ERC721Admin.GetAllAdminUsers()

{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}

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 dotés du rôle minter.
Ctx.ERC721Token.CreateToken(args ...interface{})
Paramètres :
  • Argument de variable dans lequel args[0] contient une référence au jeton struct du type requis.
Renvoie :
  • En cas de succès, interface[] avec les détails du jeton. En cas d'erreur, objet non nul avec un message d'erreur.
Par 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"
}
GetTokenUri
Cette méthode renvoie l'URI de jeton d'un jeton spécifié.
Ctx.ERC721Token.GetTokenURI(tokenId string) (interface{}, error)
Paramètres :
  • tokenId: string : ID du jeton.
Renvoie :
  • En cas de succès, il renvoie une correspondance du nouvel URI de jeton dans le type de données de chaîne. En cas d'erreur, objet non nul avec un message d'erreur.
Par exemple :

t.Ctx.ERC721Token.GetTokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
TokenUri
Cette méthode renvoie l'URI de jeton d'un jeton spécifié.
Ctx.ERC721Token.TokenURI(tokenId string) (interface{}, error)
Paramètres :
  • tokenId: string : ID du jeton.
Renvoie :
  • En cas de succès, il renvoie une correspondance du nouvel URI de jeton dans le type de données de chaîne. En cas d'erreur, objet non nul 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"}
Symbol
Cette méthode renvoie le symbole de la classe de jeton.
Ctx.ERC721Token.Symbol() (interface{}, error)
Paramètres :
  • Aucun élément
Renvoie :
  • En cas de succès, une correspondance du symbole dans le type de données de chaîne. En cas d'erreur, objet non nul contenant un message d'erreur.
Par exemple :

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}
Name
Cette méthode renvoie le nom de la classe de jeton.
Ctx.ERC721Token.Name() (interface{}, error)
Paramètres :
  • Aucun élément
Renvoie :
  • En cas de succès, une correspondance du nom du jeton dans le type de données de chaîne. En cas d'erreur, objet non nul contenant un message d'erreur.
Par exemple :

t.Ctx.ERC721Token.Name()

{"TokenName": "paintingnft"}
OwnerOf
Cette méthode renvoie l'ID de compte du propriétaire d'un jeton spécifié.
Ctx.ERC721Token.OwnerOf(tokenId string) (interface{}, error)
Paramètres :
  • tokenId: string : ID du jeton.
Renvoie :
  • En cas de succès, une correspondance de l'ID de compte du propriétaire dans le type de données de chaîne. En cas d'erreur, objet non nul contenant un message d'erreur.
Par exemple :

t.Ctx.ERC721Token.OwnerOf(tokenId)

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
TotalSupply
Cette méthode renvoie le nombre total de NFT extraits.
Ctx.ERC721Token.TotalSupply() (map[string]interface{}, error)
Paramètres :
  • tokenId: string : ID du jeton.
Renvoie :
  • En cas de succès, une carte de l'offre totale de jetons dans le type de données numérique. En cas d'erreur, rejet avec un message d'erreur.
Par exemple :

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}
GetAllTokens
Cette méthode renvoie toutes les ressources de jeton enregistrées dans la base de données d'état. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant.
Ctx.ERC721Token.GetAllTokens()  (interface{}, error)
Paramètres :
  • Aucun élément
Renvoie :
  • En cas de succès, une carte de toutes les ressources de jeton. En cas d'erreur, objet non nul contenant un message d'erreur.
Par 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 renvoie tous les jetons appartenant à un ID de compte spécifié. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant.
Ctx.ERC721Token.GetAllTokensByUser(accountId string) (interface{}, error)
Paramètres :
  • accountId: string : ID du compte.
Renvoie :
  • En cas de succès, mappage des ressources de jeton pour le compte spécifié. En cas d'erreur, objet non nul contenant un message d'erreur.
Par 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",
        }
        }
    }
]
Get
Cette méthode renvoie 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 du type correct, qui contiendra les données de jeton après un appel réussi de la méthode.
Renvoie :
  • En cas de succès, une correspondance avec les données de ressource de jeton. En outre, si result[0] est transmis, les données sont affectées à result[0]. En cas d'erreur, objet non nul contenant un message d'erreur.
Par 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"
}
UpdateToken
Cette méthode met à jour les propriétés de 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 propriétaire du jeton peut mettre à jour les propriétés personnalisées du jeton. Si l'utilisateur est à la fois propriétaire et créateur d'un jeton, il peut également mettre à jour la propriété TokenDesc. Les métadonnées de 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
Renvoie :
  • En cas de succès, un message de promesse avec des détails de jeton. En cas d'erreur, rejet avec un message d'erreur.
Par 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",
}
History
Cette méthode renvoie l'historique du jeton spécifié.
Ctx.ERC721Token.History(tokenId: string)  (interface{}, error)
Paramètres :
  • tokenId: string : ID du jeton.
Renvoie :
  • En cas de succès, un ensemble de cartes. En cas d'erreur, rejet avec un message d'erreur.
Par 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": ""
        }
    }
]
GetNewCtx
Cette méthode renvoie un nouvel objet TrxContext. La structure trxcontext contient des références à toutes les bibliothèques SDK. Accédez aux méthodes sdk en utilisant uniquement cet objet. L'objet trxcontext conserve l'exclusivité mutuelle des stubs de transaction dans les bibliothèques SDK lorsque des transactions simultanées sont en cours d'exécution. 
GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext
Paramètres :
  • stub : stub de transaction.
Renvoie :
  • Une structure trxcontext.
Par exemple :

trxcontext.GetNewCtx(stub)

trxcontext object.

Méthodes de gestion des comptes

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

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

oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507
CreateAccount
Cette méthode crée un compte pour un utilisateur spécifique. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Les comptes suivent le nombre de NFT dont dispose un utilisateur. Les utilisateurs doivent disposer de comptes sur le réseau pour effectuer les opérations liées aux jetons. Vous ne pouvez créer qu'un seul compte NFT par utilisateur.

Un ID de compte est un ensemble alphanumérique de caractères, préfixé par oaccount~ et suivi d'un hachage SHA-256 de l'ID de fournisseur de services d'appartenance (org_id) de l'utilisateur dans l'organisation réseau en cours, du nom utilisateur ou de l'ID de courriel (userId) du propriétaire 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 du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
  • tokenType: string : le seul type de jeton pris en charge est nonfungible.
Renvoie :
  • En cas de succès, le nouvel objet de compte. En cas d'erreur, objet non nul contenant un message d'erreur
Par exemple :

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

{
    "AssetType": "oaccount",
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "BapAccountVersion" : 0,
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
GetAllAccounts
Cette méthode renvoie la liste de tous les comptes. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant.
Ctx.ERC721Account.GetAllAccounts() (interface{}, error)
Paramètres :
  • Aucun élément
Renvoie :
  • Tableau JSON de tous les comptes.
Par 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"
        }
    }
]
History
Cette méthode renvoie un tableau des détails de l'historique des comptes pour un compte spécifié.
Ctx.ERC721Account.History(accountId string) (interface{}, error)
Paramètres :
  • accountId: string : ID du compte.
Renvoie :
  • En cas de succès, tableau map[string]interface{} contenant les détails de l'historique des comptes pour le compte spécifié. Les données de compte sont affichées sous la clé value dans la carte. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par 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"
        }
    }
]
GetUserByAccountId
Cette méthode renvoie 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.
Renvoie :
  • En cas de succès, objet JSON qui inclut les détails utilisateur dans les propriétés suivantes :
    • OrgId : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation réseau actuelle.
    • UserId : nom utilisateur ou ID courriel de l'utilisateur.
  • En cas d'erreur, objet non nul contenant un message d'erreur.
Par exemple :

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
GetAccountWithStatusByUser
Cette méthode renvoie les détails du compte pour un utilisateur spécifié, y compris le statut du compte. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par Account Owner du compte. 
Ctx.ERC721Account.GetAccountWithStatusByUser(orgId, userId) (interface{}, error)
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • En cas de succès, un objet de compte JSON qui inclut les propriétés suivantes :
  • AccountId : ID du compte utilisateur.
  • UserId : nom utilisateur ou ID courriel de l'utilisateur.
  • OrgId : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • TokenType : type de jeton détenu par le compte.
  • NoOfNfts : nombre total de NFT détenus par le compte.
  • BapAccountVersion : paramètre d'objet de compte à usage interne.
  • Status : statut en cours du compte utilisateur.
  • En cas d'erreur, objet non nul contenant un message d'erreur.
Par exemple :
{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}
GetAccountByUser
Cette méthode renvoie les détails du compte d'un utilisateur spécifié. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par Account Owner du compte. 
Ctx.ERC721Account.GetAccountByUser(orgId, userId) (ERC721Account, error)
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • userId: string : nom d'utilisateur ou ID courriel de l'utilisateur.
Renvoie :
  • En cas de succès, un objet de compte JSON qui inclut les propriétés suivantes :
  • AccountId : ID du compte utilisateur.
  • UserId : nom utilisateur ou ID courriel de l'utilisateur.
  • OrgId : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation en cours.
  • TokenType : type de jeton détenu par le compte.
  • NoOfNfts : nombre total de NFT détenus par le compte.
  • En cas d'erreur, objet non nul contenant un message d'erreur.
Par exemple :
{
    "AssetType": "oaccount",
    "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "BapAccountVersion" : 0,
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
BalanceOf
Cette méthode renvoie le nombre total de NFT détenus par l'utilisateur spécifié.
Ctx.ERC721Account.BalanceOf(accountId string) (interface{}, error)
Paramètres :
  • accountId: string : ID de compte de l'utilisateur.
Renvoie :
  • En cas de succès, une interface avec un message et le nombre total de NFT. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par exemple :

t.Ctx.ERC721Account.BalanceOf(accountId)

{"TotalNfts": 0}

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 indiqué. 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 de compte sur lequel opérer.
Renvoie :
  • En cas de succès, une carte avec un message de succès. En cas d'erreur, objet non nul contenant un message d'erreur.
Par 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 de compte est formé par la création d'un hachage SHA-256 de l'ID de fournisseur de services d'adhésion concaténé (orgId) et du nom utilisateur ou de l'ID de courriel (userId). 
Ctx.Token.RemoveRoleMember(role string, accountId string) (interface{}, error)
Paramètres :
  • role: string : nom du rôle à enlever de l'utilisateur indiqué. 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 de compte sur lequel opérer.
Renvoie :
  • En cas de succès, une carte avec un message de succès. En cas d'erreur, objet non nul contenant un message d'erreur.
Par exemple :

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

{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}
IsInRole
Cette méthode renvoie une valeur booléenne pour indiquer si un utilisateur et un jeton ont un rôle spécifié. Un ID de compte est formé par la création d'un hachage SHA-256 de l'ID de fournisseur de services d'adhésion concaténé (orgId) et du nom utilisateur ou de l'ID de courriel (userId). 
Ctx.ERC721Token.IsInRole(role string, accountId string) (bool, error)
Paramètres :
  • role: string : nom du rôle à vérifier pour l'utilisateur indiqué. 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 de compte sur lequel opérer.
Renvoie :
  • En cas de succès, valeur booléenne qui est True si le rôle est présent pour l'ID de compte spécifié, sinon False. En cas d'erreur, objet non nul contenant un message d'erreur
Par exemple :

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

{"result": false}
GetAccountsByRole
Cette méthode renvoie la liste de tous les ID de compte pour un rôle spécifié.
Ctx.ERC721Role.GetAccountsByRole(roleName string) (interface{}, error)
Paramètres :
  • roleName: string : nom du rôle à rechercher.
Renvoie :
  • En cas de réussite, un tableau JSON d'ID de compte. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par exemple :

t.Ctx.ERC721Role.GetAccountsByRole(userRole)

{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
Cette méthode renvoie la 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.
Renvoie :
  • En cas de succès, un tableau JSON d'objets utilisateur. Chaque objet contient l'ID utilisateur et l'ID organisation. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par exemple :

t.Ctx.ERC721Role.GetUsersByRole(userRole)

{
    "Users": [
        {
            "OrgId": "Org1MSP",
            "UserId": "admin"
        }
    ]
}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory
Cette méthode renvoie 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.
Renvoie :
  • 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 : type de transaction.
    • Timestamp : heure de la transaction.
    • En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par 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 renvoie 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 qu'en cas de connexion 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 ce champ est vide, tous les enregistrements sont renvoyés. La propriété PageSize détermine le nombre d'enregistrements à renvoyer. Si PageSize est égal à 0, la taille de page par défaut est de 20. La propriété Bookmark détermine l'index de début des enregistrements à renvoyer. Pour plus d'informations, reportez-vous à la documentation Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.
Renvoie :
  • 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 : type de transaction.
    • Timestamp : heure de la transaction.
    • En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par 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 renvoie l'historique d'une ressource Transaction. 
Ctx.ERC721Transaction.GetTransactionById(trxId string) (interface{}, error)
Paramètres :
  • trxId: string : ID de la ressource de transaction.
Renvoie :
  • En cas de succès, un tableau de cartes des actifs de transaction. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par 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 les transactions antérieures à une date spécifiée de la base de données d'état.
func (t *Controller) DeleteHistoricalTransactions(referenceTime string) (interface{}, error)
Paramètres :
  • referenceTime: string : les transactions antérieures à l'heure indiquée seront supprimées.
Renvoie :
  • En cas de succès, un tableau des ID de transaction supprimés et un message de succès. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.
Par 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 Mintable

GetMaxMintQuantity
Cette méthode renvoie 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.
Renvoie :
  • En cas de succès, la quantité minimale maximale du jeton, dans le type de données numérique. En cas d'erreur, objet non nul avec un message d'erreur.
Par exemple :

t.Ctx.ERC721Token.GetMaxMintQuantity(tokenId);

20000
GetTotalMintedTokens
Cette méthode renvoie 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 :
  • Aucun élément
Renvoie :
  • En cas de succès, une carte du nombre total de jetons extraits, du type de données numérique et d'un message de succès. En cas d'erreur, objet non nul avec un message d'erreur.
Par exemple :

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

Gestion du comportement des jetons - Comportement transférable

SafeTransferFrom
Cette méthode transfère la propriété de la NFT spécifiée de l'appelant vers un autre compte. Cette méthode inclut les validations suivantes :
  • Le jeton existe et n'est pas gravé.
  • Le compte expéditeur et le compte destinataire existent et ne sont pas identiques.
  • Le compte expéditeur est propriétaire 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 de compte de l'expéditeur dans l'organisation actuelle.
  • toAccountId: string : ID de compte du destinataire dans l'organisation actuelle.
  • tokenAsset : référence à la ressource de jeton sur laquelle opérer.
  • data: string : informations supplémentaires facultatives à stocker dans la transaction.
Renvoie :
  • En cas de succès, promesse avec un message de succès qui inclut les détails du compte. En cas d'erreur, objet non nul avec un message d'erreur.
Par 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é de la NFT spécifiée d'un compte expéditeur vers un compte 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 inclut les validations suivantes :
  • Le jeton existe et n'est pas gravé.
  • Le compte expéditeur et le compte destinataire existent et ne sont pas identiques.
  • Le compte expéditeur est propriétaire du jeton.
Ctx.ERC721Token.TransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}) (interface{}, error)
Paramètres :
  • fromAccountId: string : ID de compte de l'expéditeur dans l'organisation actuelle.
  • toAccountId: string : ID de compte du destinataire dans l'organisation actuelle.
  • tokenAsset : référence à la ressource de jeton sur laquelle opérer.
Renvoie :
  • En cas de succès, promesse avec un message de succès qui inclut les détails du compte. Les ID de compte ont le préfixe oaccount~. En cas d'erreur, objet non nul 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 gravable

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 indiquée dans la section roles du fichier de spécification, le propriétaire du jeton peut graver le jeton. Si une propriété burner_role_name est indiquée dans la section roles, l'utilisateur qui a affecté le rôle de brûleur, qui est également le mineurs (créateur) du jeton, peut graver le jeton. La méthode burn fait partie du package ERC721Token, auquel vous accédez via le 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.
Renvoie :
  • En cas de succès, promesse avec un message de succès qui inclut les détails du compte. En cas d'erreur, objet non nul avec un message d'erreur.
Par exemple :

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

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