Projet échafaudé Go NFT pour ERC-721

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

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

Pour plus d'informations sur le projet échafaudé et les méthodes qui ne sont pas directement liées à des tâches de chaîne, voir Projet de code de chaîne Go échafaudé.

Informations de référence :

Modèle

La capacité de persistance transparente, ou ORM simplifié, est saisie 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 n'importe quel nombre de classes, de fonctions ou de fichiers, mais seules les méthodes définies dans la classe de contrôleur principale peuvent être appelées. Les autres méthodes sont masquées.

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

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

Blockchain App Builder génère automatiquement des méthodes pour prendre en charge les NFT et les cycles de vie NFT. Vous pouvez utiliser ces méthodes pour initialiser les NFT, gérer les rôles et les comptes et effectuer d'autres tâches de cycle de vie NFT sans codage supplémentaire. Les méthodes de contrôleur doivent être publiques pour pouvoir être invoqué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.

Gestion du contrôle d'accès
Gestion de la configuration de jeton
Gestion du compte
Gestion des rôles
Gestion de l'historique des transactions
Gestion du comportement des jetons

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

AddTokenAdmin

Cette méthode ajoute un utilisateur en tant que Token Admin du code de chaîne. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) AddTokenAdmin(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ADMIN.AddAdmin", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Admin.AddAdmin(orgId, userId)
}

Paramètres :

orgId string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

Au succès, un message comprend les détails de l'utilisateur qui a été ajouté comme Token Admin du code de chaîne.

Exemple de valeur renvoyée :

{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}

RemoveTokenAdmin

Cette méthode supprime un utilisateur en tant que Token Admin du code de chaîne. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne. Vous ne pouvez pas utiliser cette méthode pour vous supprimer en tant que Token Admin.

func (t *Controller) RemoveTokenAdmin(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ADMIN.RemoveAdmin", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Admin.RemoveAdmin(orgId, userId)
}

Paramètres :

orgId string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message contenant les détails de l'utilisateur qui a été supprimé comme Token Admin du code de chaîne.

Exemple de valeur renvoyée :

{"msg":"Successfully removed Admin (OrgId Org1MSP UserId user1)"}

IsTokenAdmin

Cette méthode retourne la valeur booléenne true si l'appelant de la fonction est Token Admin, sinon elle retourne false. Un Token Admin peut appeler cette fonction sur tout autre utilisateur du réseau de chaîne de blocs. Les autres utilisateurs ne peuvent appeler cette méthode que sur leur propre compte.

func (t *Controller) IsTokenAdmin(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ADMIN.IsTokenAdmin", "TOKEN", map[string]string{"orgId": orgId, "userId": userId})
      if err != nil || !auth {
            return false, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Auth.IsUserTokenAdmin(orgId, userId)
}

Paramètres :

orgId string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

La méthode retourne true si l'appelant est un Token Admin, sinon elle retourne false.

Exemple de valeur renvoyée :

{"result":true}

GetAllTokenAdmins

Cette méthode retourne une liste de tous les utilisateurs qui sont des Token Admin du code de chaîne. Cette méthode ne peut être appelée que par la chaîne Token Admin du code de chaîne.

func (t *Controller) GetAllTokenAdmins() (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ADMIN.GetAllAdmins", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Admin.GetAllAdminUsers()
}

Paramètres :

aucune

Retourne :

En cas de réussite, une liste JSON d'administrateurs comprend des objets OrgId et UserId.

Exemple de valeur renvoyée :

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

Méthodes de gestion de la configuration de jeton

Init

Cette méthode est appelée lorsque le code de chaîne est instancié. Chaque valeur Token Admin est identifiée par les informations UserId et OrgId dans le paramètre adminList. UserId est le nom d'utilisateur ou l'ID courriel du responsable de l'instance ou de l'utilisateur qui est connecté à l'instance. OrgId est l'ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante. Le paramètre adminList est obligatoire lors du premier déploiement du code de chaîne. Si vous mettez à niveau le code de chaîne, transmettez une liste vide ([]). Toutes les autres informations du paramètre adminList sont ignorées lors des mises à niveau.

func (t *Controller) Init(adminList []erc721Admin.ERC721TokenAdminAsset) (interface{}, error) {
      list, err := t.Ctx.ERC721Admin.InitAdmin(adminList)
      if err != nil {
            return nil, fmt.Errorf("initialising admin list failed %s", err.Error())
      }
      <Token Name> := <Token Class>{}
      _, err = t.Ctx.ERC721Token.SaveClassInfo(&<Token Name>)
      if err != nil {
            return nil, err
      }
      _, err = t.Ctx.ERC721Token.SaveDeleteTransactionInfo()
      if err != nil {
            fmt.Println("error: ", err)
      }
      return list, nil
}

Paramètres :

adminList array - Tableau d'informations {OrgId, UserId} qui spécifie la liste des administrateurs de jetons. Le tableau adminList est un paramètre obligatoire.

GetAllTokens

Cette méthode retourne toutes les ressources de jeton enregistrées dans la base de données d'état. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée 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 :

aucune

Retourne :

Liste de toutes les ressources de jeton au format JSON.

Exemple de valeur renvoyée :

[
    {
        "key": "monalisa",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:01:42Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "token Description",
            "TokenId": "monalisa",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
    },
    {
        "key": "monalisa2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:04:44Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "monalisa1",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
        }
    }
]

GetAllTokensByUser

Cette méthode retourne toutes les ressources de jeton appartenant à un utilisateur spécifié. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par le responsable du compte.

func (t *Controller) GetAllTokensByUser(orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetAllTokensByUser", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
    return t.Ctx.ERC721Token.GetAllTokensByUser(accountId)
}

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

Liste des ressources de jeton au format JSON.

Exemple de valeur renvoyée :

[
    {
        "key": "monalisa",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:01:42Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "token Description",
            "TokenId": "monalisa",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
    },
    {
        "key": "monalisa2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:04:44Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "monalisa1",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
        }
    }
]

GetTokenById

Cette méthode retourne un objet de jeton si le jeton est présent dans la base de données d'état. Cette méthode ne peut être appelée que par Token Admin du code de chaîne ou du responsable du jeton.

func (t *Controller) GetTokenById(tokenId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.Get", "TOKEN", map[string]string{"tokenId": tokenId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      tokenAsset, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      return tokenAsset.Interface(), nil
}

Paramètres :

tokenId: string - ID du jeton à obtenir.

Retourne :

Ressource de jeton au format JSON.

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2022-04-06T00:35:42Z",
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 200,
    "Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "Token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
    "TransferredBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "TransferredDate": "2022-04-06T00:51:56Z"
}

GetTokenHistory

Cette méthode retourne l'historique pour un ID jeton spécifié. Cette méthode ne peut être appelée que lorsqu'elle est connectée au réseau distant Oracle Blockchain Platform. 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 retourne une instance du jeton pour un ID jeton spécifié. Cette méthode est utilisée par de nombreuses méthodes générées automatiquement pour extraire les objets de jeton. Vous pouvez appeler cette méthode au besoin à partir de vos méthodes personnalisées. Lorsque vous créez une ressource ou une classe segmentée en unités, mettez à jour la casse du commutateur avec la classe Token correspondante pour retourner l'objet de jeton correct. La commande ochain sync dans le générateur d'applications de chaîne de blocs crée automatiquement un cas de commutateur lorsqu'une ressource segmentée en unités est créée dans le fichier de spécification. Comme cette méthode est privée, elle n'est pas directement invokable et ne peut être appelée qu'à partir d'autres méthodes.

func (t *Controller) getTokenObject(tokenId string) (reflect.Value, error) {
      if tokenId == "" {
            return reflect.Value{}, fmt.Errorf("error in retrieving token, token_id cannot be empty")
      }
      tokenAsset, err := t.Ctx.ERC721Token.Get(tokenId)
      if err != nil {
            return reflect.Value{}, fmt.Errorf("no token exists with id %s %s", tokenId, err.Error())
      }
      tokenName := tokenAsset.(map[string]interface{})["TokenName"].(string)
      switch tokenName {
      case "<Token Name>":
            var asset <Token Class>
            _, err := t.Ctx.ERC721Token.Get(tokenId, &asset)
            if err != nil {
                  return reflect.Value{}, err
            }
            return reflect.ValueOf(&asset), nil
      default:
            return reflect.Value{}, fmt.Errorf("no token exists with token name %s", tokenName)
      }
}

Paramètres :

tokenId: string - ID du jeton.

OwnerOf

Cette méthode retourne l'ID compte du responsable de l'ID jeton spécifié. Tout le monde peut appeler cette méthode.

func (t *Controller) Ownerof(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.OwnerOf(tokenId)
}

Paramètres :

tokenId: string - ID du jeton.

Retourne :

Objet JSON de l'ID compte du responsable.

Exemple de valeur renvoyée :

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}

Name

Cette méthode retourne le nom de la classe de jeton. Tout le monde peut appeler cette méthode.

func (t *Controller) Name() (interface{}, error) {
      return t.Ctx.ERC721Token.Name()
}

Paramètres :

aucune

Retourne :

Objet JSON du nom du jeton.

Exemple de valeur renvoyée :

{"TokenName": "paintingnft"}

Symbol

Cette méthode retourne le symbole de la classe de jeton. Tout le monde peut appeler cette méthode.

func (t *Controller) Symbol() (interface{}, error) {
      return t.Ctx.ERC721Token.Symbol()
}

Paramètres :

aucune

Retourne :

Objet JSON du symbole de jeton.

Exemple de valeur renvoyée :

{"Symbol": "PNT"}

TokenURI

Cette méthode retourne l'URI d'un jeton spécifié. Tout le monde peut appeler cette méthode.

func (t *Controller) TokenURI(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.TokenURI(tokenId)
}

Paramètres :

tokenId: string - ID du jeton.

Retourne :

En cas de succès, un objet JSON de l'URI du jeton.

Exemple de valeur renvoyée :

{"TokenURI": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}

TotalSupply

Cette méthode retourne le nombre total de jetons frappés. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) TotalSupply() (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.TotalSupply", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Token.TotalSupply()
}

Paramètres :

aucune

Retourne :

En cas de réussite, un objet JSON du nombre de jetons.

Exemple de valeur renvoyée :

{"TotalSupply": 3}

TotalNetSupply

Cette méthode retourne le nombre total de jetons frappés moins le nombre de jetons brûlés. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) TotalNetSupply() (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.TotalNetSupply", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Token.GetTotalMintedTokens()
}

Paramètres :

aucune

Retourne :

En cas de réussite, 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 transactions NFT d'un utilisateur. Les utilisateurs doivent avoir des comptes dans 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 compte est un jeu de caractères alphanumériques, précédé de oaccount~ et suivi d'un hachage SHA-256 de l'ID fournisseur de services d'adhésion (OrgId) de l'utilisateur dans l'organisation de réseau courante, du nom d'utilisateur ou de l'ID courriel (UserId) du responsable de l'instance ou de l'utilisateur connecté à l'instance, et de la chaîne constante nft. Cette méthode ne peut être appelée que par la chaîne Token Admin du code de chaîne.

func (t *Controller) CreateAccount(orgId string, userId string, tokenType string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.CreateAccount", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Account.CreateAccount(orgId, userId, tokenType)
}

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.
tokenType: string - Le seul type de jeton pris en charge est nonfungible.

Retourne :

En cas de réussite, un objet JSON du compte qui a été créé.

Exemple de valeur renvoyée :

{
    "AssetType": "oaccount",
    "BapAccountVersion" : 0,
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}

BalanceOf

Cette méthode retourne le nombre total de transactions NFT détenues par un utilisateur spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par le responsable du compte.

func (t *Controller) BalanceOf(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.BalanceOf", "TOKEN", map[string]string{"orgId": orgId, "userId": userId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil{
            return nil,err
      }
      return t.Ctx.ERC721Account.BalanceOf(accountId)
}

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

Objet JSON du nombre NFT courant.

Exemple de valeur renvoyée :

{"totalNfts": 0}

GetAllAccounts

Cette méthode retourne une liste de tous les comptes. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée 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 :

aucune

Retourne :

En cas de succès, un tableau JSON de tous les comptes.

Exemple de valeur renvoyée :

[
    {
        "key": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "valueJson": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 5,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    },
    {
        "key": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "valueJson": {
            "AccountId": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user_minter"
        }
    },
    {
        "key": "oaccount~5541fb520058d83664b844e7a55fe98d574ddeda765d0e795d4779e9ccc271ce",
        "valueJson": {
            "AccountId": "oaccount~5541fb520058d83664b844e7a55fe98d574ddeda765d0e795d4779e9ccc271ce",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user_burner"
        }
    }
]

GetAccountByUser

Cette méthode retourne les détails du compte pour un utilisateur spécifié. Cette méthode ne peut être appelée que par Token Admin du code de 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 fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un objet de compte JSON qui inclut les propriétés suivantes :
AccountId - ID du compte d'utilisateur.
UserId - Nom d'utilisateur ou ID courriel de l'utilisateur.
OrgId - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
TokenType - Type de jeton que détient le compte.
NoOfNfts - Nombre total de NFT détenues par le compte.
BapAccountVersion - Paramètre d'objet de compte à usage interne.
Status - Statut courant du compte d'utilisateur.

Exemple de valeur renvoyée :

{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}

GetUserByAccountId

Cette méthode retourne les détails de l'utilisateur 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.

Retourne :

En cas de réussite, un objet JSON contenant les détails de l'utilisateur (OrgId et UserId).

Exemple de valeur renvoyée :

{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}

GetAccountHistory

Cette méthode retourne l'historique du compte pour un utilisateur spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par le responsable du compte.

func (t *Controller) GetAccountHistory(orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.History", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Account.History(accountId)
}

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, une liste d'objets.

Exemple de valeur renvoyée :

[
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T08:16:53Z",
        "TxId": "750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "Value": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "BapAccountVersion" : 1,
            "NoOfNfts": 1,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T08:15:19Z",
        "TxId": "49eb84c42d452e5ba0028d8ebb4190454cf9013a11c0bad3e96594af452d4982",
        "Value": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    }
]

Méthodes pour la 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 de chaîne.

func (t *Controller) AddRole(role string, orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.AddRoleMember", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Token.AddRoleMember(role, accountId)
}

Paramètres :

userRole: string - Nom du rôle à ajouter à l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, un message 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 de chaîne.

func (t *Controller) RemoveRole(userRole string, orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.RemoveRoleMember", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Token.RemoveRoleMember(userRole, accountId)
}

Paramètres :

userRole: string - Nom du rôle à supprimer de l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, un message 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 retourne une liste de tous les ID compte pour un rôle spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) GetAccountsByRole(userRole string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ROLE.GetAccountsByRole", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Role.GetAccountsByRole(userRole)
}

Paramètres :

userRole: string - Nom du rôle à rechercher.

Retourne :

En cas de succès, un tableau JSON d'ID compte.

Exemple de valeur renvoyée :

{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}

GetUsersByRole

Cette méthode retourne une liste de tous les utilisateurs pour un rôle spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne.

func (t *Controller) GetUsersByRole(userRole string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ROLE.GetUsersByRole", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Role.GetUsersByRole(userRole)
}

Paramètres :

userRole: string - Nom du rôle à rechercher.

Retourne :

En cas de succès, un tableau JSON des objets utilisateur (orgId et userId).

Exemple de valeur renvoyée :

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

IsInRole

Cette méthode retourne une valeur booléenne pour indiquer si un utilisateur a un rôle spécifié. Cette méthode ne peut être appelée que par Token Admin du code de 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 fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.
userRole: string - Nom du rôle à rechercher.

Retourne :

En cas de succès, une chaîne JSON du résultat booléen.

Exemple de valeur renvoyée :

{"result":"true"}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory

Cette méthode retourne l'historique des transactions de compte pour un utilisateur spécifié. Cette méthode peut être appelée par Token Admin du code de chaîne ou par le responsable du compte.

func (t *Controller) GetAccountTransactionHistory(orgId string, userId string) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.GetAccountTransactionHistory", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }

      transactionArray, err := t.Ctx.ERC721Account.GetAccountTransactionHistory(accountId)
      return transactionArray, err
}

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de succès, une liste d'objets.

Exemple de valeur renvoyée :

[
     {
        "Timestamp": "2022-04-06T08:31:39Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
        "TransactionType": "DEBIT"
    }
    {
        "Timestamp": "2022-04-06T08:16:53Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "TransactionId": "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "TransactionType": "MINT"
    }
]

GetAccountTransactionHistoryWithFilters

Cette méthode retourne l'historique des transactions de compte pour un utilisateur spécifié, filtré par PageSize, Bookmark, StartTime et EndTime. Cette méthode ne peut être appelée que lorsqu'elle est connectée au réseau distant Oracle Blockchain Platform. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par le responsable du compte.

func (t *Controller) GetAccountTransactionHistoryWithFilters(orgId string, userId string, filters ...erc721Account.AccountHistoryFilters) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.GetAccountTransactionHistoryWithFilters", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }

      transactionArray, err := t.Ctx.ERC721Account.GetAccountTransactionHistoryWithFilters(accountId, filters...)
      return transactionArray, err
}

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.
filters: string - Paramètre facultatif. Si vide, tous les enregistrements sont retournés. La propriété PageSize détermine le nombre d'enregistrements à retourner. Si PageSize a la valeur 0, la taille de page par défaut est 20. La propriété Bookmark détermine l'index de départ des enregistrements à retourner. Pour plus d'informations, voir la documentation relative à Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.

Retourne :

En cas de succès, une liste d'objets.

Exemple de valeur renvoyée :

[
     {
        "Timestamp": "2022-04-06T08:31:39Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
        "TransactionType": "DEBIT"
    }
    {
        "Timestamp": "2022-04-06T08:16:53Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "TransactionId": "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "TransactionType": "MINT"
    }
]

GetTransactionById

Cette méthode retourne l'historique des transactions pour un ID transaction spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code de chaîne ou par le responsable du compte.

func (t *Controller) GetTransactionById(transactionId string) (interface{}, error) {
      return t.Ctx.ERC721Transaction.GetTransactionById(transactionId)
}

Paramètres :

transactionId: string - ID de l'immobilisation de transaction.

Retourne :

En cas de succès, une liste d'objets.

Exemple de valeur renvoyée :

{
    "History": [
        {
            "IsDelete": "false",
            "Timestamp": "2022-04-06T08:31:39Z",
            "TxId": "5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
            "Value": {
                "AssetType": "otransaction",
                "Data": "",
                "FromAccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
                "Timestamp": "2022-04-06T08:31:39Z",
                "ToAccountId": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
                "TokenId": "monalisa",
                "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
                "TransactionType": "TRANSFER",
                "TriggeredByAccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1"
            }
        }
    ],
    "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7"
}

DeleteHistoricalTransactions

Cette méthode supprime les transactions antérieures à un horodatage spécifié dans la base de données d'état. Cette méthode ne peut être appelée que par la chaîne Token Admin du code de chaîne.

func (t *Controller) DeleteHistoricalTransactions(timestamp string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TRANSACTION.DeleteHistoricalTransactions", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)
}

Paramètres :

timestamp: Date - Horodatage. Toutes les transactions antérieures à l'horodatage seront supprimées.

Retourne :

En cas de succès, une liste d'objets.

Exemple de valeur renvoyée :

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

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

Create<Token Name>Token

Cette méthode crée (mints) 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 de filtre. Sinon, n'importe quel appelant peut extraire des NFT.

func (t *Controller) Create<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
      return t.Ctx.ERC721Token.CreateToken(&tokenAsset)
}

Paramètres :

tokenAsset: <Token Class> - Ressource de jeton à extraire. Pour plus d'informations sur les propriétés de la ressource de jeton, voir le fichier de spécification d'entrée.

Retourne :

En cas de réussite, un objet de ressource de jeton JSON qui inclut les propriétés suivantes :
Behavior - Description de tous les comportements de jeton.
CreatedBy - ID compte de l'utilisateur qui a appelé la transaction pour extraire le jeton.
CreationDate - Horodatage de la transaction.
IsBurned - Valeur booléenne qui indique si la table NFT identifiée par tokenId est brûlée.
Mintable - Description des propriétés du comportement mintable. La propriété max_mint_quantity spécifie le nombre maximal de transactions NFT de cette classe de jeton pouvant être créées.
Owner - ID compte du responsable courant du jeton. Au cours du processus de frappe, l'appelant de cette méthode devient le propriétaire du jeton.
Symbol - Symbole du jeton.
TokenDesc - Description du jeton.
TokenMetadata - Informations JSON décrivant le jeton.
TokenName - Nom du jeton.
TokenStandard - Norme du jeton.
TokenType - Type de jeton détenu par ce compte.
TokenUnit - Unité du jeton.
TokenUri - URI du jeton.

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",        
    "CreationDate": "2022-04-06T08:16:53Z",
    "IsBurned": false,
     "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 100,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
}

Update<Token Name>Token

Cette méthode met à jour les propriétés du jeton. Cette méthode ne peut être appelée que par l'utilisateur responsable ou créateur du jeton. Après la création d'une ressource de jeton, seul le responsable du jeton peut mettre à jour les propriétés personnalisées du jeton. Si l'utilisateur est à la fois le responsable et le 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, voir le fichier de spécification d'entrée.

Retourne :

En cas de succès, un objet de ressource de jeton JSON mis à jour

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",      
    "CreationDate": "2022-04-06T08:16:53Z",
    "IsBurned": false,    
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 200,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "Token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
}

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

SafeTransferFrom

Cette méthode transfère la propriété de la TNF spécifiée de l'appelant à un autre compte. Cette méthode comprend les validations suivantes :

Le jeton existe et n'est pas brûlé.
Le compte expéditeur et le compte destinataire existent et ne sont pas le même compte.
Le compte de l'expéditeur est responsable du jeton.
L'appelant de la fonction est l'expéditeur.

func (t *Controller) SafeTransferFrom(fromOrgId string, fromUserId string, toOrgId string, toUserId string, tokenId string, data ...string) (interface{}, error) {
      tokenAssetValue, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      fromAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(fromOrgId, fromUserId)
      if err != nil {
            return nil, err
      }
      toAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(toOrgId, toUserId)
      if err != nil {
            return nil, err
      }
      return t.Ctx.ERC721Token.SafeTransferFrom(fromAccountId, toAccountId, tokenAssetValue.Interface(), data...)
}

Paramètres :

fromOrgId: string - ID fournisseur de services d'adhésion (MSP) de l'expéditeur dans l'organisation courante.
fromUserId: string - Nom d'utilisateur ou ID courriel de l'expéditeur.
toOrgId: string - ID fournisseur de services d'adhésion (MSP) du destinataire dans l'organisation courante.
toUserId: string - Nom d'utilisateur ou ID courriel du destinataire.
tokenId: string - ID du jeton à transférer.
data: string - Informations supplémentaires facultatives à stocker dans l'enregistrement de transaction.

Retourne :

En cas de succès, un message contenant les détails du compte de l'expéditeur et du destinataire.

Exemple de valeur renvoyée :

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

TransferFrom

Cette méthode transfère la propriété de la transaction de transfert de fonds nationale spécifiée d'un compte d'expéditeur à un compte de destinataire. Il est de la responsabilité de l'appelant de transmettre les paramètres corrects. Cette méthode peut être appelée par n'importe quel utilisateur, pas seulement par le propriétaire du jeton. Cette méthode comprend les validations suivantes :

Le jeton existe et n'est pas brûlé.
Le compte expéditeur et le compte destinataire existent et ne sont pas le même compte.
Le compte de l'expéditeur est responsable du jeton.

func (t *Controller) TransferFrom(fromOrgId string, fromUserId string, toOrgId string, toUserId string, tokenId string) (interface{}, error) {
      tokenAssetValue, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      fromAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(fromOrgId, fromUserId)
      if err != nil {
            return nil, err
      }
      toAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(toOrgId, toUserId)
      if err != nil {
            return nil, err
      }
      return t.Ctx.ERC721Token.TransferFrom(fromAccountId, toAccountId, tokenAssetValue.Interface())
}

Paramètres :

fromOrgId: string - ID fournisseur de services d'adhésion (MSP) de l'expéditeur dans l'organisation courante.
fromUserId: string - Nom d'utilisateur ou ID courriel de l'expéditeur.
toOrgId: string - ID fournisseur de services d'adhésion (MSP) du destinataire dans l'organisation courante.
toUserId: string - Nom d'utilisateur ou ID courriel du destinataire.
tokenId: string - ID du jeton à transférer.

Retourne :

En cas de succès, un message contenant les détails du compte de l'expéditeur et du destinataire.

Exemple de valeur renvoyée :

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

Méthodes de gestion du comportement des jetons - Comportement brûlable

Burn

Cette méthode désactive, ou brûle, le NFT spécifié 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 du jeton inclut le comportement burnable. Si aucune propriété burner_role_name n'est spécifiée dans la section roles du fichier de spécification, le responsable du jeton peut le graver. Si une propriété burner_role_name est spécifiée dans la section roles, l'utilisateur affecté au rôle de brûleur qui est également le créateur du jeton peut brûler le jeton.

func (t *Controller) Burn(tokenId string) (interface{}, error) {
      tokenAssetValue, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      return t.Ctx.ERC721Token.Burn(tokenAssetValue.Interface())
}

Paramètres :

tokenId: string - ID du jeton à graver.

Retourne :

En cas de succès, un message avec les détails du compte.

Exemple de valeur renvoyée :

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

BurnNFT

Cette méthode désactive ou grave le NFT spécifié à partir du compte de l'appelant et retourne un objet de jeton et un historique de jeton. L'appelant de cette méthode doit avoir un compte. Un jeton ne peut pas être gravé sauf si le fichier de spécification du jeton inclut le comportement burnable. Si aucune propriété burner_role_name n'est spécifiée dans la section roles du fichier de spécification, le responsable du jeton peut le graver. Si une propriété burner_role_name est spécifiée dans la section roles, l'utilisateur affecté au rôle de brûleur qui est également le créateur ou le responsable du jeton peut brûler le jeton.

func (t *Controller) BurnNFT(tokenId string) (interface{}, error) {
      tokenAsset, err := t.Ctx.ERC721Token.Get(tokenId)
      if err != nil {
            return nil, err
      }
      tokenHistory, err := t.Ctx.ERC721Token.History(tokenId)
      if err != nil {
            return nil, err
      }
      token := tokenAsset.(map[string]interface{})
      if token[constants.IsBurned] == true {
            return nil, fmt.Errorf("token with tokenId %s is already burned", tokenId)
      }
      token[constants.TokenId], err = strconv.Atoi(token[constants.TokenId].(string))
      if err != nil {
            return nil, fmt.Errorf("tokenId is expected to be integer but found %s", tokenId)
      }
      tokenHistoryBytes, err := json.Marshal(tokenHistory)
      if err != nil {
            return nil, err
      }
      var tokenHistoryAsRawJson json.RawMessage
      err = json.Unmarshal(tokenHistoryBytes, &tokenHistoryAsRawJson)
      if err != nil {
            return nil, err
      }
      token[constants.TokenHistory] = string(tokenHistoryAsRawJson)
      token[constants.IsBurned] = true
      _, err = t.Burn(tokenId)
      if err != nil {
            return nil, err
      }
      return token, nil
}

Paramètres :

tokenId: string - ID du jeton à graver.

Retourne :

En cas de succès, un objet de jeton qui inclut des informations d'historique de jeton.

Exemple de valeur renvoyée :

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2023-08-22T13:19:33+05:30",
    "IsBurned": true,
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "On_sale_flag": false,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Price": 120,
    "Roles": {
        "minter_role_name": "minter"
    },
    "Symbol": "ART",
    "TokenDesc": "",
    "TokenHistory": "[{\"IsDelete\":\"false\",\"Timestamp\":\"2023-08-22T13:19:33+05:30\",\"TxId\":\"0219099bcaaecd5f76f7f08d719384fd5ed34103a55bd8d3754eca0bfc691594\",\"Value\":{\"AssetType\":\"otoken\",\"Behavior\":[\"indivisible\",\"singleton\",\"mintable\",\"transferable\",\"burnable\",\"roles\"],\"CreatedBy\":\"oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d\",\"CreationDate\":\"2023-08-22T13:19:33+05:30\",\"IsBurned\":false,\"Mintable\":{\"Max_mint_quantity\":20000},\"On_sale_flag\":false,\"Owner\":\"oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d\",\"Price\":120,\"Roles\":{\"minter_role_name\":\"minter\"},\"Symbol\":\"ART\",\"TokenDesc\":\"\",\"TokenId\":\"1\",\"TokenMetadata\":{\"Description\":\"\",\"Image\":\"\",\"Painter_name\":\"\",\"Painting_name\":\"\"},\"TokenName\":\"artcollection\",\"TokenStandard\":\"erc721+\",\"TokenType\":\"nonfungible\",\"TokenUnit\":\"whole\",\"TokenUri\":\"example.com\"}}]",
    "TokenId": 1,
    "TokenMetadata": {
        "Description": "",
        "Image": "",
        "Painter_name": "",
        "Painting_name": ""
    },
    "TokenName": "artcollection",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "example.com"
}

Méthodes personnalisées

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

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

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

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

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

Méthodes de trousse SDK NFT

Gestion du contrôle d'accès
Gestion de la configuration de jeton
Gestion du compte
Gestion des rôles
Gestion de l'historique des transactions
Gestion du comportement des jetons

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

La trousse SDK NFT fournit une fonction de contrôle d'accès. Certaines méthodes ne peuvent être appelées que par Token Admin ou Account Owner du jeton. Vous pouvez utiliser cette fonction pour vous assurer que les opérations 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 de l'ensemble erc721Auth, auquel vous accédez au moyen de la structure Ctx (récepteur). Le mappage du contrôle d'accès est décrit dans le fichier oChainUtil.go, comme indiqué dans le texte suivant. Vous pouvez modifier le contrôle d'accès en modifiant le fichier oChainUtil.go. Pour utiliser votre propre contrôle d'accès ou pour désactiver le contrôle d'accès, supprimez le code de contrôle d'accès des méthodes de contrôleur et des méthodes personnalisées générées automatiquement.

  var t TokenAccess
      var r RoleAccess
      var a AccountAccess
      var as AccountStatusAccess
      var h HoldAccess
      var ad AdminAccess
      var trx TransactionAccess
      var tc TokenConversionAccess
      var auth AuthAccess
      var erc721ad ERC721AdminAccess
      var erc721t ERC721TokenAccess
      var erc721r ERC721RoleAccess
      var erc721a ERC721AccountAccess
      var erc721as ERC721AccountStatusAccess
      var erc721trx ERC721TransactionAccess
     auth.IsTokenAdmin = []string{"Admin", "MultipleAccountOwner"}

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

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

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

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

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

      var accessMap TokenAccessControl
      accessMap.Token = t
      accessMap.Account = a
      accessMap.AccountStatus = as
      accessMap.Hold = h
      accessMap.Role = r
      accessMap.Admin = ad
      accessMap.Auth = auth
      accessMap.TokenConversion = tc
      accessMap.ERC721ADMIN = erc721ad
      accessMap.ERC721TOKEN = erc721t
      accessMap.ERC721ACCOUNT = erc721a
      accessMap.ERC721AccountStatus = erc721as
      accessMap.ERC721ROLE = erc721r
      accessMap.ERC721TRANSACTION = erc721trx

Ctx.ERC721Auth.CheckAuthorization(funcName string, args []string) (bool, error)

Paramètres :

funcName: string - Valeur de mappage entre les récepteurs et les méthodes, comme décrit dans le fichier oChainUtil.go.
...args - Argument de variable où args[0] prend la constante 'TOKEN' et args[1] prend le paramètre accountId pour ajouter une vérification de contrôle d'accès pour AccountOwner. Pour 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. Pour ajouter une vérification de contrôle d'accès pour TokenOwner, args[1] utilise le paramètre tokenId.

Retourne :

Une réponse booléenne et, si nécessaire, une erreur.

Exemples :

t.Ctx.ERC721Auth.CheckAuthorization(<parameters>)

Accès Admin

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

Accès AccountOwner

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

Accès MultipleAccountOwner

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

Accès TokenOwner

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

IsUserTokenAdmin

Cette méthode retourne un mappage avec la valeur booléenne true si l'appelant de la fonction est Token Admin. Sinon, la méthode retourne false.

Ctx.ERC721Auth.IsUserTokenAdmin(orgId string, userId string)  (interface{}, error)

Paramètres :

orgId - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante.
userId - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

Réponse booléenne.

Exemple :

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

{"result":true}

AddAdmin

Cette méthode ajoute un utilisateur en tant que Token Admin du code de chaîne du jeton.

Ctx.ERC721Admin.AddAdmin(orgId string, userId string) (interface{}, error)

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message listant les détails de l'utilisateur ajoutés comme Token Admin du code de chaîne du jeton. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

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

{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}

RemoveAdmin

Cette méthode supprime un utilisateur en tant que Token Admin du code de chaîne du jeton.

Ctx.ERC721Admin.RemoveAdmin(orgId string, userId string) (interface{}, error)

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un message listant les détails de l'utilisateur supprimé en tant que Token Admin du code de chaîne du jeton. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

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

{"msg":"Successfuly removed Admin (OrgId Org1MSP UserId user1)"}

GetAllAdmins

Cette méthode retourne une liste de tous les utilisateurs Token Admin.

Ctx.ERC721Admin.GetAllAdmins() (Admin[], error)

Paramètres :

aucune

Retourne :

En cas de succès, une liste de tous les utilisateurs Token Admin. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Admin.GetAllAdmins()

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

GetAllAdminUsers

Cette méthode retourne une liste de tous les utilisateurs Token Admin.

Ctx.ERC721Admin.GetAllAdminUsers() (interface{}, error)

Paramètres :

aucune

Retourne :

En cas de succès, une liste de tous les utilisateurs Token Admin au format map[string]interface{}. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

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 de mineur.

Ctx.ERC721Token.CreateToken(args ...interface{})

Paramètres :

Argument de variable où args[0] contient une référence au jeton struct du type requis.

Retourne :

En cas de réussite, un interface[] avec les détails du jeton. En cas d'erreur, un objet non vide avec un message d'erreur.

Exemple :

t.Ctx.ERC721Token.CreateToken(&tokenAsset)

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",        
    "CreationDate": "2022-04-06T08:16:53Z",
    "IsBurned": false,
     "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 100,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
}

GetTokenUri

Cette méthode retourne l'URI du jeton pour un jeton spécifié.

Ctx.ERC721Token.GetTokenURI(tokenId string) (interface{}, error)

Paramètres :

tokenId: string - ID du jeton.

Retourne :

En cas de succès, il retourne un mappage du nouvel URI de jeton dans le type de données de chaîne. En cas d'erreur, un objet non vide avec un message d'erreur.

Exemple :

t.Ctx.ERC721Token.GetTokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}

TokenUri

Cette méthode retourne l'URI du jeton pour un jeton spécifié.

Ctx.ERC721Token.TokenURI(tokenId string) (interface{}, error)

Paramètres :

tokenId: string - ID du jeton.

Retourne :

En cas de succès, il retourne un mappage du nouvel URI de jeton dans le type de données de chaîne. En cas d'erreur, un objet non vide avec un message d'erreur.

Exemple de valeur renvoyée :

t.Ctx.ERC721Token.TokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}

Symbol

Cette méthode retourne le symbole de la classe de jeton.

Ctx.ERC721Token.Symbol() (interface{}, error)

Paramètres :

aucune

Retourne :

En cas de succès, une carte du symbole dans le type de données de la chaîne. En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}

Name

Cette méthode retourne le nom de la classe de jeton.

Ctx.ERC721Token.Name() (interface{}, error)

Paramètres :

aucune

Retourne :

En cas de succès, mappage du nom du jeton dans le type de données de chaîne. En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Token.Name()

{"TokenName": "paintingnft"}

OwnerOf

Cette méthode retourne l'ID compte du responsable d'un jeton spécifié.

Ctx.ERC721Token.OwnerOf(tokenId string) (interface{}, error)

Paramètres :

tokenId: string - ID du jeton.

Retourne :

Au succès, mappage de l'ID compte du responsable dans le type de données de chaîne. En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Token.OwnerOf(tokenId)

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}

TotalSupply

Cette méthode retourne le nombre total de transactions NFT frappées.

Ctx.ERC721Token.TotalSupply() (map[string]interface{}, error)

Paramètres :

tokenId: string - ID du jeton.

Retourne :

En cas de succès, une carte de l'approvisionnement total de jetons dans le type de données Nombre. En cas d'erreur, un rejet avec un message d'erreur.

Exemple :

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}

GetAllTokens

Cette méthode retourne toutes les ressources de jeton enregistrées dans la base de données d'état. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.

Ctx.ERC721Token.GetAllTokens()  (interface{}, error)

Paramètres :

aucune

Retourne :

En cas de succès, une carte de toutes les ressources de jeton. En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Token.GetAllTokens()

[
    {
        "key": "monalisa",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintab
 
le",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:01:42Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "token Description",
            "TokenId": "monalisa",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
    },
    {
        "key": "monalisa2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:04:44Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "monalisa1",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
        }
    }
]

GetAllTokensByUser

Cette méthode retourne tous les jetons appartenant à un ID compte spécifié. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.

Ctx.ERC721Token.GetAllTokensByUser(accountId string) (interface{}, error)

Paramètres :

accountId: string - ID du compte.

Retourne :

En cas de succès, une carte des ressources de jeton pour le compte spécifié. En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Token.GetAllTokensByUser(accountId)

[
    {
        "key": "monalisa",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:01:42Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "token Description",
            "TokenId": "monalisa",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
    },
    {
        "key": "monalisa2",
        "valueJson": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "CreationDate": "2022-04-10T11:04:44Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 100,
            "Owner": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "monalisa1",
            "TokenMetadata": {
                 "Description": "Mona Lisa Painting",
                 "Image": "monalisa.jpeg",
                 "PainterName": "Leonardo_da_Vinci",
                 "PaintingName": "Mona_Lisa"
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
        }
        }
    }
]

Get

Cette méthode retourne l'objet de jeton spécifié s'il est présent dans la base de données d'état.

Ctx.Get(Id string, result ...interface{}) (interface{}, error)

Paramètres :

tokenId: string - ID du jeton.
result - Argument de variable, où le premier argument result[0] est une référence à un objet Token vide du type correct, qui contiendra les données du jeton après un appel réussi de la méthode.

Retourne :

En cas de succès, mappage avec les données de ressource de jeton. De plus, si result[0] est transmis, les données sont affectées à result[0]. En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

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

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2022-04-06T00:35:42z",
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 200,
    "Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "Token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
    "TransferredBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "TransferredDate": "2022-04-06T00:51:56z"
}

UpdateToken

Cette méthode met à jour les propriétés du jeton. Cette méthode ne peut être appelée que par le propriétaire ou le créateur du jeton. Après la création d'une ressource de jeton, seul le responsable du jeton peut mettre à jour les propriétés personnalisées du jeton. Si l'utilisateur est à la fois le responsable et le 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

Retourne :

En cas de succès, un message de promesse contenant les détails du jeton. En cas d'erreur, un rejet avec un message d'erreur.

Exemple :

t.Ctx.ERC721Token.UpdateToken(&asset)

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",     
    "CreationDate": "2022-04-06T08:16:53Z",
    "IsBurned": false,   
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 200,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "Token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
}

History

Cette méthode retourne l'historique pour le jeton spécifié.

Ctx.ERC721Token.History(tokenId: string)  (interface{}, error)

Paramètres :

tokenId: string - ID du jeton.

Retourne :

Sur le succès, un tableau de cartes. En cas d'erreur, un rejet avec un message d'erreur.

Exemple :

t.Ctx.ERC721Token.History(tokenId)

[
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T11:34:06z",
        "TxId": "3184eac8738c73ef45501fe23c9e14517892e04e4eb03ec9be834b89c29ea17b",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "BurnedBy": null,
            "BurnedDate": null,
            "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "CreationDate": "2022-04-06T11:33:40+05:30",
            "IsBurned": null,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "t1",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "PainterName": "",
                "PaintingName": ""
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "",
            "TransferredBy": null,
            "TransferredDate": null
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T11:33:40z",
        "TxId": "d37dba907a849c308b2a38d47cf8a68cdcb4e3d93fa74050774379fccfcd43be",
        "Value": {
            "AssetType": "otoken",
            "Behavior": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "CreationDate": "2022-04-06T11:33:40+05:30",
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "NftBasePrice": 0,
            "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "Symbol": "PNT",
            "TokenDesc": "",
            "TokenId": "t1",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "PainterName": "",
                "PaintingName": ""
            },
            "TokenName": "paintingnft",
            "TokenStandard": "erc721+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": ""
        }
    }
]

GetNewCtx

Cette méthode retourne un nouvel objet TrxContext. La structure trxcontext contient des références à toutes les bibliothèques SDK. Accédez aux méthodes de la trousse SDK en utilisant uniquement cet objet. L'objet trxcontext maintient l'exclusivité mutuelle des talons de transaction dans les bibliothèques SDK lorsque des transactions concurrentes sont en cours d'exécution.

GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext

Paramètres :

stub - Le talon de transaction.

Retourne :

Une structure trxcontext.

Exemple :

trxcontext.GetNewCtx(stub)

trxcontext object.

Méthodes de gestion des comptes

GenerateAccountId

Cette méthode retourne un ID compte, qui est formé par la concaténation de l'ID fournisseur de services d'adhésion (orgId) et du nom d'utilisateur ou de l'ID courriel (userId), puis la création d'un hachage SHA-256.

Ctx.ERC721Account.GenerateAccountId(orgId string, userId string) (string, error)

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

Au succès, l'ID compte généré. En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

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

oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507

CreateAccount

Cette méthode crée un compte pour un utilisateur spécifié. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Les comptes suivent le nombre de transactions NFT d'un utilisateur. Les utilisateurs doivent avoir des comptes dans 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 compte est un jeu de caractères alphanumériques, précédé de oaccount~ et suivi d'un hachage SHA-256 de l'ID fournisseur de services d'adhésion (org_id) de l'utilisateur dans l'organisation de réseau courante, du nom d'utilisateur ou de l'ID courriel (userId) du responsable de l'instance ou de l'utilisateur connecté à l'instance, et de la chaîne constante nft.

Ctx.ERC721Account.CreateAccount(orgId string, userId string, tokenType string) (ERC721Account, error)

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.
tokenType: string - Le seul type de jeton pris en charge est nonfungible.

Retourne :

En cas de succès, nouvel objet de compte. En cas d'erreur, un objet non vide contenant un message d'erreur

Exemple :

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

{
    "AssetType": "oaccount",
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "BapAccountVersion" : 0,
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}

GetAllAccounts

Cette méthode retourne une liste de tous les comptes. Cette méthode utilise des interrogations SQL enrichies Berkeley DB et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.

Ctx.ERC721Account.GetAllAccounts() (interface{}, error)

Paramètres :

aucune

Retourne :

Tableau JSON de tous les comptes.

Exemple :

t.Ctx.ERC721Account.GetAllAccounts()

[
    {
        "key": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "valueJson": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "BapAccountVersion" : 0,
            "AssetType": "oaccount",
            "NoOfNfts": 5,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    },
    {
        "key": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "valueJson": {
            "AccountId": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user_minter"
        }
    },
    {
        "key": "oaccount~5541fb520058d83664b844e7a55fe98d574ddeda765d0e795d4779e9ccc271ce",
        "valueJson": {
            "AccountId": "oaccount~5541fb520058d83664b844e7a55fe98d574ddeda765d0e795d4779e9ccc271ce",
            "AssetType": "oaccount",
            "BapAccountVersion" : 0,
            "NoOfNfts": 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user_burner"
        }
    }
]

History

Cette méthode retourne un tableau des détails de l'historique du compte pour un compte spécifié.

Ctx.ERC721Account.History(accountId string) (interface{}, error)

Paramètres :

accountId: string - ID du compte.

Retourne :

En cas de succès, un tableau map[string]interface{} contenant les détails de l'historique du compte spécifié. Les données de compte sont affichées sous la clé value dans le mappage. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Account.History(accountId)

[
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T08:16:53Z",
        "TxId": "750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "Value": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "BapAccountVersion" : 1,
            "NoOfNfts": 1,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2022-04-06T08:15:19Z",
        "TxId": "49eb84c42d452e5ba0028d8ebb4190454cf9013a11c0bad3e96594af452d4982",
        "Value": {
            "AccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
            "AssetType": "oaccount",
            "NoOfNfts": 0,
            "BapAccountVersion" : 0,
            "OrgId": "apPart",
            "TokenType": "nonfungible",
            "UserId": "user1"
        }
    }
]

GetUserByAccountId

Cette méthode retourne les détails de l'utilisateur pour un compte spécifié.

Ctx.ERC721Account.GetUserByAccountId(accountId string) (interface{}, error)

Paramètres :

accountId: string - ID du compte.

Retourne :

En cas de réussite, un objet JSON qui inclut les détails de l'utilisateur dans les propriétés suivantes :
- OrgId - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation de réseau courante.
- UserId - Nom d'utilisateur ou ID courriel de l'utilisateur.
En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}

GetAccountWithStatusByUser

Cette méthode retourne les détails du compte pour un utilisateur spécifié, y compris le statut du compte. Cette méthode ne peut être appelée que par Token Admin du code de chaîne ou par Account Owner du compte.

Ctx.ERC721Account.GetAccountWithStatusByUser(orgId, userId) (interface{}, error)

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un objet de compte JSON qui inclut les propriétés suivantes :
AccountId - ID du compte d'utilisateur.
UserId - Nom d'utilisateur ou ID courriel de l'utilisateur.
OrgId - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
TokenType - Type de jeton que détient le compte.
NoOfNfts - Nombre total de NFT détenues par le compte.
BapAccountVersion - Paramètre d'objet de compte à usage interne.
Status - Statut courant du compte d'utilisateur.
En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}

GetAccountByUser

Cette méthode retourne les détails du compte pour un utilisateur spécifié. Cette méthode ne peut être appelée que par Token Admin du code de chaîne ou par Account Owner du compte.

Ctx.ERC721Account.GetAccountByUser(orgId, userId) (ERC721Account, error)

Paramètres :

orgId: string - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
userId: string - Nom d'utilisateur ou ID courriel de l'utilisateur.

Retourne :

En cas de réussite, un objet de compte JSON qui inclut les propriétés suivantes :
AccountId - ID du compte d'utilisateur.
UserId - Nom d'utilisateur ou ID courriel de l'utilisateur.
OrgId - ID fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation courante.
TokenType - Type de jeton que détient le compte.
NoOfNfts - Nombre total de NFT détenues par le compte.
En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

{
    "AssetType": "oaccount",
    "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "BapAccountVersion" : 0,
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}

BalanceOf

Cette méthode retourne le nombre total de transactions NFT détenues par l'utilisateur spécifié.

Ctx.ERC721Account.BalanceOf(accountId string) (interface{}, error)

Paramètres :

accountId: string - ID compte de l'utilisateur.

Retourne :

En cas de succès, une interface avec un message et le nombre total de NFT. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Account.BalanceOf(accountId)

{"TotalNfts": 0}

Méthodes pour la gestion des rôles

AddRoleMember

Cette méthode ajoute un rôle à un utilisateur spécifié.

Ctx.ERC721Token.AddRoleMember(role string, accountId string) (interface{}, error)

Paramètres :

role: string - Nom du rôle à ajouter à l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
accountId: number - ID compte sur lequel opérer.

Retourne :

En cas de réussite, une carte avec un message de réussite. En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

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

{"msg": "Successfully added role minter to oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin)"}

RemoveRoleMember

Cette méthode supprime un rôle d'un utilisateur et d'un jeton spécifiés. Un ID compte est formé par la création d'un hachage SHA-256 de l'ID fournisseur de services d'adhésion concaténé (orgId) et du nom d'utilisateur ou de l'ID courriel (userId).

Ctx.Token.RemoveRoleMember(role string, accountId string) (interface{}, error)

Paramètres :

role: string - Nom du rôle à supprimer de l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
accountId: number - ID compte sur lequel opérer.

Retourne :

En cas de réussite, une carte avec un message de réussite. En cas d'erreur, un objet non vide contenant un message d'erreur.

Exemple :

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

{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}

IsInRole

Cette méthode retourne une valeur booléenne pour indiquer si un utilisateur et un jeton ont un rôle spécifié. Un ID compte est formé par la création d'un hachage SHA-256 de l'ID fournisseur de services d'adhésion concaténé (orgId) et du nom d'utilisateur ou de l'ID courriel (userId).

Ctx.ERC721Token.IsInRole(role string, accountId string) (bool, error)

Paramètres :

role: string - Nom du rôle à vérifier pour l'utilisateur spécifié. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
accountId: number - ID compte sur lequel opérer.

Retourne :

En cas de succès, une valeur booléenne est Vrai si le rôle est présent pour l'ID compte spécifié, sinon Faux. En cas d'erreur, un objet non vide contenant un message d'erreur

Exemple :

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

{"result": false}

GetAccountsByRole

Cette méthode retourne une liste de tous les ID compte pour un rôle spécifié.

Ctx.ERC721Role.GetAccountsByRole(roleName string) (interface{}, error)

Paramètres :

roleName: string - Nom du rôle à rechercher.

Retourne :

En cas de succès, un tableau JSON d'ID compte. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Role.GetAccountsByRole(userRole)

{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}

GetUsersByRole

Cette méthode retourne une liste de tous les utilisateurs pour un rôle spécifié.

Ctx.ERC721Role.GetUsersByRole(roleName string) (interface{}, error)

Paramètres :

roleName: string - Nom du rôle à rechercher.

Retourne :

En cas de succès, un tableau JSON d'objets utilisateur. Chaque objet contient le code d'utilisateur et le code d'organisation. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Role.GetUsersByRole(userRole)

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

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory

Cette méthode retourne un tableau des détails de l'historique des transactions pour un compte spécifié.

Ctx.ERC721Account.GetAccountTransactionHistory(accountId string) (interface{}, error)

Paramètres :

accountId: string - ID du compte.

Retourne :

En cas de succès, un tableau d'objets de transaction de compte au format JSON :
- TransactionId - ID de la transaction.
- TransactedAccount - Compte avec lequel la transaction a eu lieu.
- TransactionType - Type de transaction.
- Timestamp - Heure de la transaction.
- En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Account.GetAccountTransactionHistory(accountId)

[
     {
        "Timestamp": "2022-04-06T08:31:39Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
        "TransactionType": "DEBIT"
    }
    {
        "Timestamp": "2022-04-06T08:16:53Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "TransactionId": "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "TransactionType": "MINT"
    }
]

GetAccountTransactionHistoryWithFilters

Cette méthode retourne l'historique des transactions de compte pour un utilisateur spécifié, filtré par PageSize, Bookmark, startTime et endTime. Cette méthode ne peut être appelée que lorsqu'elle est connectée au réseau distant Oracle Blockchain Platform.

Ctx.ERC721Account.GetAccountTransactionHistoryWithFilters(accountId string, filters ...erc721Account.AccountHistoryFilters)

Paramètres :

accountId: string - ID du compte.
filters: string - Paramètre facultatif. Si vide, tous les enregistrements sont retournés. La propriété PageSize détermine le nombre d'enregistrements à retourner. Si PageSize a la valeur 0, la taille de page par défaut est 20. La propriété Bookmark détermine l'index de départ des enregistrements à retourner. Pour plus d'informations, voir la documentation relative à Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.

Retourne :

En cas de succès, un tableau d'objets de transaction de compte au format JSON :
- TransactionId - ID de la transaction.
- TransactedAccount - Compte avec lequel la transaction a eu lieu.
- TransactionType - Type de transaction.
- Timestamp - Heure de la transaction.
- En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

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

[
     {
        "Timestamp": "2022-04-06T08:31:39Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
        "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
        "TransactionType": "DEBIT"
    }
    {
        "Timestamp": "2022-04-06T08:16:53Z",
        "TokenId": "monalisa",
        "TransactedAccount": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
        "TransactionId": "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7",
        "TransactionType": "MINT"
    }
]

GetTransactionById

Cette méthode retourne l'historique d'une ressource Transaction.

Ctx.ERC721Transaction.GetTransactionById(trxId string) (interface{}, error)

Paramètres :

trxId: string - ID de l'immobilisation de transaction.

Retourne :

En cas de succès, un tableau de cartes des actifs de transaction. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Transaction.GetTransactionById(transactionId)

{
    "History": [
        {
            "IsDelete": "false",
            "Timestamp": "2022-04-06T08:31:39Z",
            "TxId": "5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
            "Value": {
                "AssetType": "otransaction",
                "Data": "",
                "FromAccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1",
                "Timestamp": "2022-04-06T08:31:39Z",
                "ToAccountId": "oaccount~0829f0996744ca9dc8b4e9165a7a8f5db3fdffdc46c96b94f5d625041502cec4",
                "TokenId": "monalisa",
                "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7",
                "TransactionType": "TRANSFER",
                "TriggeredByAccountId": "oaccount~543c2258e351c3e7a40ea59b81e62154d38fbfc9d1b5b79f30ac5e08e7d0dfd1"
            }
        }
    ],
    "TransactionId": "otransaction~5a353e02e657c2c8fddce41dd4e7260025fe7beef634ca3351fc366a440e8ac7"
}

DeleteHistoricalTransactions

Cette méthode supprime de la base de données d'état les transactions antérieures à une date spécifiée.

func (t *Controller) DeleteHistoricalTransactions(referenceTime string) (interface{}, error)

Paramètres :

referenceTime: string - Les transactions antérieures à l'heure spécifiée seront supprimées.

Retourne :

En cas de succès, un tableau des ID transaction supprimés et un message de réussite. En cas d'erreur, un objet d'erreur non vide contenant un message d'erreur.

Exemple :

t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)

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

Gestion du comportement des jetons - Comportement à la menthe

GetMaxMintQuantity

Cette méthode retourne la quantité minimale maximale d'un jeton. Si le comportement max_mint_quantity n'est pas configuré dans le fichier de spécification, la valeur par défaut est 0 et un nombre infini de jetons peut être frappé.

Ctx.ERC721Token.GetMaxMintQuantity(id string) (float64, error)

Paramètres :

id - ID du jeton sur lequel exécuter l'opération.

Retourne :

En cas de succès, quantité minimale maximale du jeton, dans le type de données numérique. En cas d'erreur, un objet non vide avec un message d'erreur.

Exemple :

t.Ctx.ERC721Token.GetMaxMintQuantity(tokenId);

GetTotalMintedTokens

Cette méthode retourne le nombre net total de jetons disponibles dans le système pour le jeton spécifié. Le nombre net de jetons disponibles est le nombre total de jetons frappés moins le nombre de jetons brûlés.

Ctx.ERC721Token.GetTotalMintedTokens() (map[string]interface{}, error)

Paramètres :

aucune

Retourne :

En cas de succès, une carte du nombre total de jetons frappés, dans le type de données Nombre et un message de réussite. En cas d'erreur, un objet non vide avec un message d'erreur.

Exemple :

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

Gestion du comportement des jetons - Comportement transférable

SafeTransferFrom

Cette méthode transfère la propriété de la TNF spécifiée de l'appelant à un autre compte. Cette méthode comprend les validations suivantes :

Le jeton existe et n'est pas brûlé.
Le compte expéditeur et le compte destinataire existent et ne sont pas le même compte.
Le compte de l'expéditeur est responsable du jeton.
L'appelant de la fonction est l'expéditeur.

Ctx.ERC721Token.SafeTransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}, data ...string) (interface{}, error)

Paramètres :

fromAccountId: string - ID compte de l'expéditeur dans l'organisation courante.
toAccountId: string - ID compte du destinataire dans l'organisation courante.
tokenAsset - Référence à la ressource de jeton à utiliser.
data: string - Informations supplémentaires facultatives à stocker dans la transaction.

Retourne :

En cas de réussite, une promesse avec un message de réussite qui inclut les détails du compte. En cas d'erreur, un objet non vide avec un message d'erreur.

Exemple :

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

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

TransferFrom

Le jeton existe et n'est pas brûlé.
Le compte expéditeur et le compte destinataire existent et ne sont pas le même compte.
Le compte de l'expéditeur est responsable du jeton.

Ctx.ERC721Token.TransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}) (interface{}, error)

Paramètres :

fromAccountId: string - ID compte de l'expéditeur dans l'organisation courante.
toAccountId: string - ID compte du destinataire dans l'organisation courante.
tokenAsset - Référence à la ressource de jeton à utiliser.

Retourne :

En cas de réussite, une promesse avec un message de réussite qui inclut les détails du compte. Les ID compte ont le préfixe oaccount~. En cas d'erreur, un objet non vide avec un message d'erreur.

\Exemple :

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

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

Gestion du comportement des jetons - Comportement brûlable

Burn

Ctx.Token.Burn(tokenAsset interface{}) (interface{}, error)

Paramètres :

tokenAsset - Référence à la ressource de jeton à utiliser.

Retourne :

En cas de réussite, une promesse avec un message de réussite qui inclut les détails du compte. En cas d'erreur, un objet non vide avec un message d'erreur.

Exemple :

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

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