Projet NFT Scaffolding Go pour ERC-721

Blockchain App Builder utilise l'entrée de votre fichier de spécification NFT et génère un projet de code chaîne à échafaudage 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 sérialisation/désérialisation et la capacité de persistance transparente sont toutes prises en charge automatiquement.

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

Référence:

• Modèle
• Contrôleur
  • Méthodes NFT générées automatiquement
  • Méthodes personnalisées
• Méthodes SDK NFT

Modèle

La fonctionnalité de persistance transparente, ou ORM simplifié, est capturée dans la classe OchainModel.

package model

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

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

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

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

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

	TokenMetadata ArtCollectionMetadata `json:"TokenMetadata"`

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

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

Contrôleur

Il n'existe qu'un seul contrôleur principal.

type Controller struct {
    Ctx trxcontext.TrxContext
}

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

Vous pouvez utiliser les méthodes SDK de jeton pour écrire des méthodes personnalisées pour votre application métier.

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

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

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

• Gestion des contrôles d'accès
• Gestion de la configuration des jetons
• Gestion de comptes
• Gestion des rôles
• Gestion de l'historique des transactions
• Gestion du comportement des jetons
  • Comportement Mintable
  • Comportement transférable
  • Comportement brûlable

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

AddTokenAdmin

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

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

Paramètres :

• orgId string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de réussite, message qui inclut les détails de l'utilisateur ajouté en tant que Token Admin du code chaîne.

Exemple de valeur renvoyée :

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

RemoveTokenAdmin

Cette méthode enlève un utilisateur en tant qu'élément Token Admin du code chaîne. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne. Vous ne pouvez pas utiliser cette méthode pour vous enlever en tant que Token Admin.

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

Paramètres :

• orgId string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de réussite, message qui inclut les détails de l'utilisateur qui a été enlevé en tant que Token Admin du code chaîne.

Exemple de valeur renvoyée :

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

IsTokenAdmin

Cette méthode renvoie la valeur booléenne true si l'appelant de la fonction est un Token Admin, sinon elle renvoie false. Un élément Token Admin peut appeler cette fonction sur n'importe quel autre utilisateur du réseau blockchain. 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 du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

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

Exemple de valeur renvoyée :

{"result":true}

GetAllTokenAdmins

Cette méthode renvoie la liste de tous les utilisateurs qui sont un Token Admin du code chaîne. Cette méthode ne peut être appelée que par l'élément Token Admin du code chaîne.

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

Paramètres :

• Aucun élément

Renvoie :

• En cas de réussite, liste JSON des administrateurs qui inclut les objets OrgId et UserId.

Exemple de valeur renvoyée :

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

Méthodes de gestion de la configuration des jetons

Init

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

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

Paramètres :

• adminList array : tableau d'informations {OrgId, UserId} qui indique la liste des administrateurs de jetons. Le tableau adminList est un paramètre obligatoire.

GetAllTokens

Cette méthode renvoie toutes les ressources de jeton enregistrées dans la base de données d'état. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne. Cette méthode utilise des requêtes enrichies Berkeley DB SQL et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant.

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

Paramètres :

• Aucun élément

Renvoie :

• Liste de toutes les ressources de jeton au format JSON.

Exemple de valeur renvoyée :

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

GetAllTokensByUser

Cette méthode renvoie toutes les ressources de jeton détenues par un utilisateur spécifié. Cette méthode utilise des requêtes enrichies Berkeley DB SQL et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne ou par le propriétaire du compte.

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• Liste des ressources de jeton au format JSON.

Exemple de valeur renvoyée :

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

GetTokenById

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

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

Paramètres :

• tokenId: string : ID du jeton à obtenir.

Renvoie :

• Ressource de jeton au format JSON.

Exemple de valeur renvoyée :

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

GetTokenHistory

Cette méthode renvoie l'historique d'un ID de jeton spécifié. Cette méthode ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant. Tout le monde peut appeler cette méthode.

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

Paramètres :

• tokenId: string : ID du jeton.

Exemple de valeur renvoyée :

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

getTokenObject

Il s'agit d'une méthode utilitaire qui renvoie une instance du jeton pour un ID de jeton spécifié. Cette méthode est utilisée par de nombreuses méthodes générées automatiquement pour extraire des objets de jeton. Vous pouvez appeler cette méthode selon vos besoins à partir de vos méthodes personnalisées. Lorsque vous créez une classe ou une ressource segmentée en jetons, mettez à jour le cas de commutateur avec la classe Token correspondante pour renvoyer l'objet de jeton correct. La commande ochain sync dans Blockchain App Builder crée automatiquement un cas de commutateur lorsqu'une ressource segmentée est créée dans le fichier de spécification. Cette méthode étant privée, elle n'est pas directement appelable et ne peut être appelée qu'à partir d'autres méthodes.

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

Paramètres :

• tokenId: string : ID du jeton.

OwnerOf

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

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

Paramètres :

• tokenId: string : ID du jeton.

Renvoie :

• Objet JSON de l'ID de compte du propriétaire.

Exemple de valeur renvoyée :

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}

Name

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

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

Paramètres :

• Aucun élément

Renvoie :

• Objet JSON du nom du jeton.

Exemple de valeur renvoyée :

{"TokenName": "paintingnft"}

Symbol

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

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

Paramètres :

• Aucun élément

Renvoie :

• Objet JSON du symbole de jeton.

Exemple de valeur renvoyée :

{"Symbol": "PNT"}

TokenURI

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

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

Paramètres :

• tokenId: string : ID du jeton.

Renvoie :

• En cas de réussite, objet JSON de l'URI de jeton.

Exemple de valeur renvoyée :

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

TotalSupply

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

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

Paramètres :

• Aucun élément

Renvoie :

• En cas de succès, objet JSON du nombre de jetons.

Exemple de valeur renvoyée :

{"TotalSupply": 3}

TotalNetSupply

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

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

Paramètres :

• Aucun élément

Renvoie :

• En cas de succès, 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 l'utilisateur et le jeton spécifiés. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Les comptes assurent le suivi du nombre de TEF dont dispose un utilisateur. Les utilisateurs doivent avoir des comptes sur le réseau pour effectuer des opérations liées aux jetons. Vous ne pouvez créer qu'un seul compte NFT par utilisateur.

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

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.
• tokenType: string : le seul type de jeton pris en charge est nonfungible.

Renvoie :

• En cas de succès, objet JSON du compte créé.

Exemple de valeur renvoyée :

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

BalanceOf

Cette méthode renvoie le nombre total de TFN qu'un utilisateur spécifié détient. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne ou par le propriétaire du compte.

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• Objet JSON du nombre de TFN en cours.

Exemple de valeur renvoyée :

{"totalNfts": 0}

GetAllAccounts

Cette méthode renvoie la liste de tous les comptes. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne. Cette méthode utilise des requêtes enrichies Berkeley DB SQL et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant.

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

Paramètres :

• Aucun élément

Renvoie :

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

Exemple de valeur renvoyée :

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

GetAccountByUser

Cette méthode renvoie les détails du compte d'un utilisateur spécifié. Cette méthode ne peut être appelée que par une chaîne (Token Admin) du code chaîne ou par la chaîne (Account Owner) du compte.

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de succès, un objet de compte JSON qui inclut les propriétés suivantes :
• AccountId : ID du compte utilisateur.
• UserId : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.
• OrgId : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• TokenType : type de jeton détenu par le compte.
• NoOfNfts – Nombre total de NFT détenues par le compte.
• BapAccountVersion : paramètre d'objet de compte à usage interne.
• Status – Statut actuel du compte utilisateur.

Exemple de valeur renvoyée :

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

GetUserByAccountId

Cette méthode renvoie les détails utilisateur d'un compte spécifié. Cette méthode peut être appelée par n'importe quel utilisateur.

func (t *Controller) GetUserByAccountId(accountId string) (interface{}, error) {
      return t.Ctx.ERC721Account.GetUserByAccountById(accountId)
}

Paramètres :

• accountId: string : ID du compte.

Renvoie :

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

Exemple de valeur renvoyée :

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

GetAccountHistory

Cette méthode renvoie l'historique des comptes d'un utilisateur spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne ou par le propriétaire du compte.

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de succès, liste des objets.

Exemple de valeur renvoyée :

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

Méthodes de gestion des rôles

AddRole

Cette méthode ajoute un rôle à un utilisateur spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne.

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

Paramètres :

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

Renvoie :

• En cas de succès, un message contenant les détails de l'utilisateur.

Exemple de valeur renvoyée :

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

RemoveRole

Cette méthode supprime un rôle d'un utilisateur spécifié. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne.

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

Paramètres :

• userRole: string : nom du rôle à enlever de l'utilisateur indiqué. Les comportements mintable et burnable correspondent aux propriétés minter_role_name et burner_role_name du fichier de spécification.
• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de succès, un message contenant les détails de l'utilisateur.

Exemple de valeur renvoyée :

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

GetAccountsByRole

Cette méthode renvoie la liste de tous les ID de compte pour un rôle donné. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne.

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

Paramètres :

• userRole: string : nom du rôle à rechercher.

Renvoie :

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

Exemple de valeur renvoyée :

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

GetUsersByRole

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

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

Paramètres :

• userRole: string : nom du rôle à rechercher.

Renvoie :

• En cas de réussite, tableau JSON des objets utilisateur (orgId et userId).

Exemple de valeur renvoyée :

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

IsInRole

Cette méthode renvoie une valeur booléenne pour indiquer si un utilisateur a un rôle spécifié. Cette méthode ne peut être appelée que par une chaîne (Token Admin) du code chaîne ou par la chaîne (Account Owner) du compte.

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.
• userRole: string : nom du rôle à rechercher.

Renvoie :

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

Exemple de valeur renvoyée :

{"result":"true"}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory

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

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

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de succès, liste des objets.

Exemple de valeur renvoyée :

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

GetAccountTransactionHistoryWithFilters

Cette méthode renvoie l'historique des transactions de compte pour un utilisateur spécifié, filtré par PageSize, Bookmark, StartTime et EndTime. Cette méthode ne peut être appelée 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 chaîne ou par le propriétaire du compte.

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

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.
• filters: string : paramètre facultatif. S'il est vide, tous les enregistrements sont renvoyés. La propriété PageSize détermine le nombre d'enregistrements à renvoyer. Si PageSize a la valeur 0, la taille de page par défaut est 20. La propriété Bookmark détermine l'index de début des enregistrements à renvoyer. Pour plus d'informations, reportez-vous à la documentation d'Hyperledger Fabric. Les propriétés StartTime et EndTime doivent être spécifiées au format RFC-3339.

Renvoie :

• En cas de succès, liste des objets.

Exemple de valeur renvoyée :

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

GetTransactionById

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

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

Paramètres :

• transactionId: string : ID de la ressource de transaction.

Renvoie :

• En cas de succès, liste des 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 l'élément Token Admin du code chaîne.

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

Paramètres :

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

Renvoie :

• En cas de succès, liste des 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 (minte) une NFT. La ressource et les propriétés associées sont enregistrées dans la base de données d'état. L'appelant de cette transaction doit avoir un compte de jeton. L'appelant de cette transaction devient le propriétaire du NFT. Si le fichier de spécification de jeton inclut la section roles pour behaviors et la propriété minter_role_name pour roles, l'appelant de la transaction doit avoir le rôle minter. Sinon, n'importe quel appelant peut frapper 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, reportez-vous au fichier de spécification d'entrée.

Renvoie :

• En cas de réussite, objet de ressource de jeton JSON qui inclut les propriétés suivantes :
• Behavior : description de tous les comportements de jeton.
• CreatedBy : ID de compte de l'utilisateur qui a appelé la transaction pour extraire le jeton.
• CreationDate : horodatage de la transaction.
• IsBurned : valeur booléenne indiquant si le fichier NFT identifié par tokenId est brûlé.
• Mintable : description des propriétés du comportement mintable. La propriété max_mint_quantity indique le nombre maximal de transactions NFT de cette classe de jeton pouvant être créées.
• Owner : ID de compte du propriétaire actuel 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 de jeton. Cette méthode ne peut être appelée que par l'utilisateur qui est le propriétaire ou le créateur du jeton. Une fois la ressource de jeton créée, seul le propriétaire du jeton peut mettre à jour les propriétés personnalisées du jeton. Si l'utilisateur est à la fois propriétaire et créateur d'un jeton, il peut également mettre à jour la propriété TokenDesc. Les métadonnées de jeton ne peuvent pas être mises à jour. Vous devez transmettre toutes les propriétés de jeton à cette méthode, même si vous souhaitez mettre à jour uniquement certaines propriétés.

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

Paramètres :

• tokenAsset: <Token Class> : ressource de jeton à mettre à jour. Pour plus d'informations sur les propriétés de la ressource de jeton, reportez-vous au fichier de spécification d'entrée.

Renvoie :

• En cas de succès, 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 TFN spécifiée de l'appelant vers un autre compte. Cette méthode inclut les validations suivantes :

• Le jeton existe et n'est pas gravé.
• Le compte émetteur et le compte bénéficiaire existent et ne sont pas le même compte.
• Le compte de l'expéditeur détient le jeton.
• L'appelant de la fonction est l'expéditeur.

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

Paramètres :

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

Renvoie :

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

Exemple de valeur renvoyée :

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

TransferFrom

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

• Le jeton existe et n'est pas gravé.
• Le compte émetteur et le compte bénéficiaire existent et ne sont pas le même compte.
• Le compte de l'expéditeur détient le jeton.

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

Paramètres :

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

Renvoie :

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

Exemple de valeur renvoyée :

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

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

Burn

Cette méthode désactive ou brûle le NFT spécifié du compte de l'appelant. L'appelant de cette méthode doit avoir un compte. Un jeton ne peut être gravé que si le fichier de spécification du jeton inclut le comportement burnable. Si aucune propriété burner_role_name n'est indiquée dans la section roles du fichier de spécification, le propriétaire du jeton peut graver le jeton. Si une propriété burner_role_name est spécifiée dans la section roles, l'utilisateur auquel le rôle de brûleur est affecté, qui est également le créateur (minter) du jeton, peut graver le jeton.

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

Paramètres :

• tokenId: string : ID du jeton à brûler.

Renvoie :

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

Exemple de valeur renvoyée :

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

BurnNFT

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

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

Paramètres :

• tokenId: string : ID du jeton à brûler.

Renvoie :

• En cas de réussite, objet de jeton qui inclut des informations d'historique de jeton.

Exemple de valeur renvoyée :

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

Méthodes personnalisées

Vous pouvez utiliser les méthodes SDK de jeton pour écrire des méthodes personnalisées pour votre application métier.

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

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

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

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

Méthodes SDK NFT

• Gestion des contrôles d'accès
• Gestion de la configuration des jetons
• Gestion de comptes
• Gestion des rôles
• Gestion de l'historique des transactions
• Gestion du comportement des jetons
  • Comportement Mintable
  • Comportement transférable
  • Comportement brûlable

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

Le kit SDK NFT fournit une fonction de contrôle d'accès. Certaines méthodes peuvent être appelées uniquement par un élément Token Admin ou Account Owner du jeton. Vous pouvez utiliser cette fonctionnalité pour vous assurer que les opérations sont effectuées uniquement par les utilisateurs prévus. Tout accès non autorisé entraîne une erreur. Pour utiliser la fonction de contrôle d'accès, importez la classe Authorization à partir du module ../lib/auth.

import { ERC721Authorization } from '../lib/erc721-auth';

AddAdmin

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

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de réussite, message qui répertorie les détails de l'utilisateur ajouté en tant que Token Admin du code chaîne de jeton. En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

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

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

RemoveAdmin

Cette méthode enlève un utilisateur en tant qu'utilisateur Token Admin du code chaîne de jeton.

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de réussite, message qui répertorie les détails de l'utilisateur enlevé en tant que code chaîne de jeton Token Admin. En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

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

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

IsUserTokenAdmin

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

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

Paramètres :

• orgId : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation réseau actuelle.
• userId : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• Réponse booléenne.

Par exemple :

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

{"result":true}

GetAllAdmins

Cette méthode renvoie la liste de tous les utilisateurs Token Admin.

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

Paramètres :

• Aucun élément

Renvoie :

• En cas de succès, une liste de tous les utilisateurs Token Admin. En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

t.Ctx.ERC721Admin.GetAllAdmins()

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

GetAllAdminUsers

Cette méthode renvoie la liste de tous les utilisateurs Token Admin.

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

Paramètres :

• Aucun élément

Renvoie :

• En cas de réussite, liste de tous les utilisateurs Token Admin au format map[string]interface{}. En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

t.Ctx.ERC721Admin.GetAllAdminUsers()

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

CheckAuthorization

Utilisez cette méthode pour ajouter une vérification de contrôle d'accès à une opération. La plupart des méthodes générées automatiquement incluent le contrôle d'accès. Certaines méthodes de jeton peuvent être exécutées uniquement par un élément ERC721Admin ou Account Owner du jeton ou par l'élément MultipleAccountOwner pour les utilisateurs ayant plusieurs comptes. La méthode CheckAuthorization fait partie du package erc721Auth auquel vous accédez via la structure Ctx (récepteur). Le mapping de contrôle d'accès est décrit dans le fichier oChainUtil.go, comme indiqué dans le texte suivant. Vous pouvez modifier le contrôle d'accès en modifiant le fichier oChainUtil.go. Pour utiliser votre propre contrôle d'accès ou pour désactiver le contrôle d'accès, supprimez le code de contrôle d'accès des méthodes de contrôleur et des méthodes personnalisées générées automatiquement.

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

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

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

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

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

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

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

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

Paramètres :

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

Renvoie :

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

Exemples :

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

Accès Admin

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

Accès AccountOwner

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

Accès MultipleAccountOwner

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

Accès TokenOwner

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

Méthodes de gestion de la configuration des jetons

CreateToken

Cette méthode crée un jeton et enregistre ses propriétés dans la base de données d'état. Cette méthode ne peut être appelée que par les utilisateurs dotés du rôle minter.

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

Paramètres :

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

Renvoie :

• En cas de réussite, une valeur interface[] avec des détails de jeton. En cas d'erreur, objet non nul avec un message d'erreur.

Par exemple :

t.Ctx.ERC721Token.CreateToken(&tokenAsset)

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

GetAllTokens

Cette méthode renvoie toutes les ressources de jeton enregistrées dans la base de données d'état. Cette méthode utilise des requêtes enrichies Berkeley DB SQL et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant.

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

Paramètres :

• Aucun élément

Renvoie :

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

Par exemple :

t.Ctx.ERC721Token.GetAllTokens()

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

GetAllTokensByUser

Cette méthode renvoie tous les jetons appartenant à un ID de compte spécifié. Cette méthode utilise des requêtes enrichies Berkeley DB SQL et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant.

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

Paramètres :

• accountId: string : ID du compte.

Renvoie :

• En cas de réussite, une correspondance de ressources de jeton pour le compte spécifié. En cas d'erreur, objet non nul contenant un message d'erreur.

Par exemple :

t.Ctx.ERC721Token.GetAllTokensByUser(accountId)

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

GetTokenUri

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

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

Paramètres :

• tokenId: string : ID du jeton.

Renvoie :

• En cas de succès, il renvoie une correspondance du nouvel URI de jeton dans le type de données de chaîne. En cas d'erreur, objet non nul avec un message d'erreur.

Par exemple :

t.Ctx.ERC721Token.GetTokenURI(tokenId)

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

History

Cette méthode renvoie l'historique du jeton spécifié.

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

Paramètres :

• tokenId: string : ID du jeton.

Renvoie :

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

Par exemple :

t.Ctx.ERC721Token.History(tokenId)

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

Get

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

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

Paramètres :

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

Renvoie :

• En cas de réussite, une correspondance avec les données de ressource de jeton. En outre, si result[0] est transmis, les données sont affectées à result[0]. En cas d'erreur, objet non nul contenant un message d'erreur.

Par exemple :

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

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

OwnerOf

Cette méthode renvoie l'ID de compte du propriétaire d'un jeton spécifié.

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

Paramètres :

• tokenId: string : ID du jeton.

Renvoie :

• En cas de succès, une correspondance de l'ID de compte du propriétaire dans le type de données de chaîne. En cas d'erreur, objet non nul contenant un message d'erreur.

Par exemple :

t.Ctx.ERC721Token.OwnerOf(tokenId)

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}

Name

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

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

Paramètres :

• Aucun élément

Renvoie :

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

Par exemple :

t.Ctx.ERC721Token.Name()

{"TokenName": "paintingnft"}

Symbol

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

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

Paramètres :

• Aucun élément

Renvoie :

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

Par exemple :

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}

TokenUri

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

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

Paramètres :

• tokenId: string : ID du jeton.

Renvoie :

• En cas de succès, il renvoie une correspondance du nouvel URI de jeton dans le type de données de chaîne. En cas d'erreur, objet non nul avec un message d'erreur.

Exemple de valeur renvoyée :

t.Ctx.ERC721Token.TokenURI(tokenId)

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

TotalSupply

Cette méthode renvoie le nombre total de TFN extraites.

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

Paramètres :

• tokenId: string : ID du jeton.

Renvoie :

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

Par exemple :

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}

UpdateToken

Cette méthode met à jour les propriétés de jeton. Cette méthode ne peut être appelée que par le propriétaire ou le créateur du jeton. Une fois la ressource de jeton créée, seul le propriétaire du jeton peut mettre à jour les propriétés personnalisées du jeton. Si l'utilisateur est à la fois propriétaire et créateur d'un jeton, il peut également mettre à jour la propriété TokenDesc. Les métadonnées de jeton ne peuvent pas être mises à jour. Vous devez transmettre toutes les propriétés de jeton à cette méthode, même si vous souhaitez mettre à jour uniquement certaines propriétés.

Ctx.ERC721Token.UpdateToken(asset interface{}) (interface{}, error)

Paramètres :

• Référence aux données de structure de jeton du type requis

Renvoie :

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

Par exemple :

t.Ctx.ERC721Token.UpdateToken(&asset)

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

GetNewCtx

Cette méthode renvoie un nouvel objet TrxContext. La structure trxcontext contient des références à toutes les bibliothèques SDK. Accédez aux méthodes sdk en utilisant uniquement cet objet. L'objet trxcontext conserve l'exclusivité mutuelle des stubs de transaction dans les bibliothèques SDK lorsque des transactions simultanées sont exécutées.

GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext

Paramètres :

• stub : stub de transaction.

Renvoie :

• Une structure trxcontext.

Par exemple :

trxcontext.GetNewCtx(stub)

trxcontext object.

Méthodes de gestion des comptes

GenerateAccountId

Cette méthode renvoie un ID de compte, qui est formé par la concaténation de l'ID de fournisseur de services d'adhésion (orgId) et du nom d'utilisateur ou de l'ID de 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 du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

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

Par exemple :

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

oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507

CreateAccount

Cette méthode crée un compte pour l'utilisateur spécifié. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Les comptes assurent le suivi du nombre de TEF dont dispose un utilisateur. Les utilisateurs doivent avoir des comptes sur le réseau pour effectuer des opérations liées aux jetons. Vous ne pouvez créer qu'un seul compte NFT par utilisateur.

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

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.
• tokenType: string : le seul type de jeton pris en charge est nonfungible.

Renvoie :

• En cas de succès, le nouvel objet Compte. En cas d'erreur, objet non nul contenant un message d'erreur

Par exemple :

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

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

BalanceOf

Cette méthode renvoie le nombre total de TFN que l'utilisateur spécifié détient.

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

Paramètres :

• accountId: string : ID de compte de l'utilisateur.

Renvoie :

• En cas de succès, une interface avec un message et le nombre total de NFT. En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

t.Ctx.ERC721Account.BalanceOf(accountId)

{"TotalNfts": 0}

GetAllAccounts

Cette méthode renvoie la liste de tous les comptes. Cette méthode utilise des requêtes enrichies Berkeley DB SQL et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant.

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

Paramètres :

• Aucun élément

Renvoie :

• Tableau JSON de tous les comptes.

Par exemple :

t.Ctx.ERC721Account.GetAllAccounts()

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

GetAccountByUser

Cette méthode renvoie les détails du compte d'un utilisateur spécifié. Cette méthode ne peut être appelée que par une chaîne (Token Admin) du code chaîne ou par la chaîne (Account Owner) du compte.

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de succès, un objet de compte JSON qui inclut les propriétés suivantes :
• AccountId : ID du compte utilisateur.
• UserId : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.
• OrgId : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• TokenType : type de jeton détenu par le compte.
• NoOfNfts – Nombre total de NFT détenues par le compte.
• En cas d'erreur, objet non nul qui contient un message d'erreur.

Par exemple :

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

GetUserByAccountId

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

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

Paramètres :

• accountId: string : ID du compte.

Renvoie :

• En cas de réussite, objet JSON qui inclut les détails utilisateur dans les propriétés suivantes :
  • OrgId : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation réseau actuelle.
  • UserId : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.
• En cas d'erreur, objet non nul contenant un message d'erreur.

Par exemple :

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

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

History

Cette méthode renvoie 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.

Renvoie :

• En cas de réussite, tableau map[string]interface{} contenant les détails de l'historique du compte indiqué. Les données de compte sont affichées sous la clé value dans la carte. En cas d'erreur, objet d'erreur non nul contenant un message d'erreur.

Par exemple :

t.Ctx.ERC721Account.History(accountId)

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

GetAccountWithStatusByUser

Cette méthode renvoie les détails du compte d'un utilisateur spécifié, y compris le statut du compte. Cette méthode ne peut être appelée que par une chaîne (Token Admin) du code chaîne ou par la chaîne (Account Owner) du compte.

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

Paramètres :

• orgId: string : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• userId: string : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.

Renvoie :

• En cas de succès, un objet de compte JSON qui inclut les propriétés suivantes :
• AccountId : ID du compte utilisateur.
• UserId : nom d'utilisateur ou ID d'adresse électronique de l'utilisateur.
• OrgId : ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation actuelle.
• TokenType : type de jeton détenu par le compte.
• NoOfNfts – Nombre total de NFT détenues par le compte.
• BapAccountVersion : paramètre d'objet de compte à usage interne.
• Status – Statut actuel du compte utilisateur.
• En cas d'erreur, objet non nul qui contient un message d'erreur.

Par exemple :

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

Méthodes de gestion des rôles

AddRoleMember

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

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

Paramètres :

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

Renvoie :

• En cas de succès, une carte avec un message de succès. En cas d'erreur, objet non nul contenant un message d'erreur.

Par exemple :

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

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

RemoveRoleMember

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

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

Paramètres :

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

Renvoie :

• En cas de succès, une carte avec un message de succès. En cas d'erreur, objet non nul contenant un message d'erreur.

Par exemple :

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

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

GetAccountsByRole

Cette méthode renvoie la liste de tous les ID de compte pour un rôle donné.

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

Paramètres :

• roleName: string : nom du rôle à rechercher.

Renvoie :

• En cas de succès, tableau JSON d'ID de compte. En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

t.Ctx.ERC721Role.GetAccountsByRole(userRole)

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

GetUsersByRole

Cette méthode renvoie la liste de tous les utilisateurs pour un rôle donné.

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

Paramètres :

• roleName: string : nom du rôle à rechercher.

Renvoie :

• En cas de succès, tableau JSON d'objets utilisateur. Chaque objet contient l'ID utilisateur et l'ID organisation. En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

t.Ctx.ERC721Role.GetUsersByRole(userRole)

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

IsInRole

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

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

Paramètres :

• role: string : nom du rôle à vérifier pour l'utilisateur 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 de compte sur lequel opérer.

Renvoie :

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

Par exemple :

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

{"result": false}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory

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

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

Paramètres :

• accountId: string : ID du compte.

Renvoie :

• En cas de succès, tableau d'objets de transaction de compte au format JSON :
  • TransactionId : ID de la transaction.
  • TransactedAccount – Compte avec lequel la transaction a eu lieu.
  • TransactionType : type de transaction.
  • Timestamp : heure de la transaction.
  • En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

t.Ctx.ERC721Account.GetAccountTransactionHistory(accountId)

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

GetAccountTransactionHistoryWithFilters

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

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

Paramètres :

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

Renvoie :

• En cas de succès, tableau d'objets de transaction de compte au format JSON :
  • TransactionId : ID de la transaction.
  • TransactedAccount – Compte avec lequel la transaction a eu lieu.
  • TransactionType : type de transaction.
  • Timestamp : heure de la transaction.
  • En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

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

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

GetTransactionById

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

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

Paramètres :

• trxId: string : ID de la ressource de transaction.

Renvoie :

• En cas de réussite, un tableau de cartes des actifs de transaction. En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

t.Ctx.ERC721Transaction.GetTransactionById(transactionId)

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

DeleteHistoricalTransactions

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

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

Paramètres :

• referenceTime: string : les transactions antérieures à l'heure indiquée seront supprimées.

Renvoie :

• En cas de succès, un tableau des ID de transaction supprimés et un message de succès. En cas d'erreur, objet d'erreur non nul qui contient un message d'erreur.

Par exemple :

t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)

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

Gestion du comportement des jetons - Comportement mentable

GetMaxMintQuantity

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

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

Paramètres :

• id : ID du jeton sur lequel opérer.

Renvoie :

• En cas de réussite, quantité minimale maximale du jeton, dans le type de données Nombre. En cas d'erreur, objet non nul avec un message d'erreur.

Par exemple :

t.Ctx.ERC721Token.GetMaxMintQuantity(tokenId);

20000

GetTotalMintedTokens

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

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

Paramètres :

• Aucun élément

Renvoie :

• En cas de réussite, une carte du nombre total de jetons extraits, du type de données Nombre et un message de réussite. En cas d'erreur, objet non nul avec un message d'erreur.

Par exemple :

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

Gestion du comportement des jetons - Comportement transférable

SafeTransferFrom

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

• Le jeton existe et n'est pas gravé.
• Le compte émetteur et le compte bénéficiaire existent et ne sont pas le même compte.
• Le compte de l'expéditeur détient le jeton.
• L'appelant de la fonction est l'expéditeur.

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

Paramètres :

• fromAccountId: string : ID de compte de l'expéditeur dans l'organisation actuelle.
• toAccountId: string : ID de compte du destinataire dans l'organisation actuelle.
• tokenAsset : référence à la ressource de jeton à utiliser.
• data: string : informations supplémentaires facultatives à stocker dans la transaction.

Renvoie :

• En cas de succès, promesse avec un message de succès qui inclut les détails du compte. En cas d'erreur, objet non nul avec un message d'erreur.

Par exemple :

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

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

TransferFrom

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

• Le jeton existe et n'est pas gravé.
• Le compte émetteur et le compte bénéficiaire existent et ne sont pas le même compte.
• Le compte de l'expéditeur détient le jeton.

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

Paramètres :

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

Renvoie :

• En cas de succès, promesse avec un message de succès qui inclut les détails du compte. Les ID de compte ont le préfixe oaccount~. En cas d'erreur, objet non nul avec un message d'erreur.

\Exemple :

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

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

Gestion du comportement des jetons - Comportement gravable

Burn

Cette méthode désactive ou brûle le NFT spécifié du compte de l'appelant. L'appelant de cette méthode doit avoir un compte. Un jeton ne peut être gravé que si le fichier de spécification du jeton inclut le comportement burnable. Si aucune propriété burner_role_name n'est indiquée dans la section roles du fichier de spécification, le propriétaire du jeton peut graver le jeton. Si une propriété burner_role_name est spécifiée dans la section roles, l'utilisateur auquel le rôle de brûleur est affecté, qui est également le créateur (minter) du jeton, peut graver le jeton. La méthode burn fait partie du package ERC721Token auquel vous accédez via le récepteur de la structure Ctx.

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

Paramètres :

• tokenAsset : référence à la ressource de jeton à utiliser.

Renvoie :

• En cas de succès, promesse avec un message de succès qui inclut les détails du compte. En cas d'erreur, objet non nul avec un message d'erreur.

Par exemple :

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

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