Projet de jeton Go échafaudé pour ERC-1155

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

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

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

Modèle

La fonctionnalité de persistance transparente, ou ORM simplifié, est capturée dans la classe OchainModel. Le modèle suivant montre un jeton non fongible entier.

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"`
	TokenStandard string `json:"TokenStandard" final:"erc1155+"`
	TokenType     string `json:"TokenType" final:"nonfungible" validate:"regexp=^nonfungible$"`
	TokenUnit     string `json:"TokenUnit" final:"whole" validate:"regexp=^whole$"`

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

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

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

	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" mandatory:"true" 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"`
}

type Loyalty 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:"loyalty"`
	TokenDesc     string `json:"TokenDesc" validate:"max=256"`
	TokenStandard string `json:"TokenStandard" final:"erc1155+"`
	TokenType     string `json:"TokenType" final:"fungible" validate:"regexp=^fungible$"`
	TokenUnit     string `json:"TokenUnit" final:"fractional" validate:"regexp=^fractional$"`

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

	Divisible map[string]interface{} `json:"Divisible" final:"{\"Decimal\":2}"`

	Behaviors []string `json:"Behaviors" final:"[\"divisible\",\"mintable\",\"transferable\",\"burnable\",\"roles\"]"`

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

	Currency_name           string      `json:"Currency_name" validate:"string"`
	Token_to_currency_ratio int         `json:"Token_to_currency_ratio" validate:"int"`
	Metadata                interface{} `json:"Metadata,omitempty"`
}
Le modèle suivant montre un jeton non fongible fractionnaire.
type RealEstateProperty 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:"realestateproperty"`
      TokenDesc string `json:"TokenDesc" validate:"max=256"`
      TokenStandard string `json:"TokenStandard" final:"erc1155+"`
      TokenType string `json:"TokenType" final:"nonfungible" validate:"regexp=^nonfungible$"`
      TokenUnit string `json:"TokenUnit" final:"fractional" validate:"regexp=^fractional$"`

      Mintable map[string]interface{} `json:"Mintable" final:"{\"Max_mint_quantity\":0}"`
      Behaviors []string `json:"Behaviors" final:"[\"divisible\",\"mintable\",\"transferable\",\"roles\"]"`

      Divisible map[string]interface{} `json:"Divisible" final:"{\"Decimal\":0}"`

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

      CreatedBy string `json:"CreatedBy,omitempty" validate:"string"`
      CreationDate string `json:"CreationDate,omitempty" validate:"string"`
      IsBurned bool `json:"IsBurned" validate:"bool"`
      TokenUri string `json:"TokenUri" mandatory:"true" validate:"string,max=2000"`
      Quantity float64 `json:"Quantity,omitempty"`
      TokenMetadata RealEstatePropertyMetadata `json:"TokenMetadata"`

      PropertySellingPrice int `json:"PropertySellingPrice" validate:"int"`
      PropertyRentingPrice int `json:"PropertyRentingPrice" validate:"int"`
}

type RealEstatePropertyMetadata struct {
      PropertyType string `json:"PropertyType" validate:"string"`
      PropertyName string `json:"PropertyName" validate:"string"`
      PropertyAddress string `json:"PropertyAddress" validate:"string"`
      PropertyImage string `json:"PropertyImage" validate:"string"`
}

Contrôleur

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

type Controller struct {
    Ctx trxcontext.TrxContext
}

Vous pouvez créer n'importe quel nombre de classes, de fonctions ou de fichiers, mais seules les méthodes définies dans la classe de contrôleur principale sont invocables. 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 de jeton générées automatiquement

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

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

IsTokenAdmin
Cette méthode renvoie la valeur booléenne true si l'appelant de la fonction est Token Admin, sinon elle renvoie false. Cette méthode ne peut être appelée que par Token Admin du code chaîne.
func (t *Controller) IsTokenAdmin(orgId string, userId string) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Admin.IsUserTokenAdmin", "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.ERC1155Auth.IsUserTokenAdmin(orgId, userId)
      }
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId: string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Renvoie :
  • La méthode renvoie true si l'appelant est Token Admin, sinon elle renvoie false.
Exemple de valeur renvoyée :
{"result": true}
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 Token Admin du code chaîne.
func (t *Controller) AddTokenAdmin(orgId string, userId string) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Admin.AddAdmin", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Admin.AddAdmin(orgId, userId)
      }
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId: string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Renvoie :
  • En cas de succès, 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: appDev, userId: user1)"}
RemoveTokenAdmin
Cette méthode supprime un utilisateur en tant que Token Admin du code chaîne. Cette méthode ne peut être appelée que par un Token Admin du code chaîne. Vous ne pouvez pas vous enlever en tant que Token Admin.
func (t *Controller) RemoveTokenAdmin(orgId string, userId string) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Admin.RemoveAdmin", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Admin.RemoveAdmin(orgId, userId)
      }
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId: string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Renvoie :
  • En cas de succès, 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 appdev userId user1)"
}
GetAllTokenAdmins
Cette méthode renvoie la liste de tous les utilisateurs qui sont un Token Admin du code chaîne. Cette méthode ne peut être appelée que par Token Admin du code chaîne.
func (t *Controller) GetAllTokenAdmins() (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Admin.GetAllAdmins", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Admin.GetAllAdminUsers()
      }
Paramètres :
  • Aucun élément
Renvoie :
  • En cas de succès, tableau admins au format JSON.
Exemple de valeur renvoyée :
{
  "admins": [
    {
      "OrgId": "appdev",
      "UserId": "idcqa"
    },
    {
      "OrgId": "appdev",
      "UserId": "user1"
    }
  ]
}

Méthodes de gestion de la configuration des jetons

Init
Cette méthode est appelée lors de l'instanciation du code chaîne. Chaque Token Admin est identifié par les informations userId et orgId dans le paramètre adminList. userId est le nom utilisateur ou l'ID courriel du propriétaire de l'instance ou de l'utilisateur connecté à l'instance. orgId est l'ID de fournisseur de services d'adhésion de l'utilisateur dans l'organisation réseau en cours. Le paramètre adminList est obligatoire lors du premier déploiement du code chaîne. Si vous mettez à niveau le code chaîne, transmettez une liste vide ([]). Si vous êtes l'utilisateur qui a initialement déployé le code chaîne, vous pouvez également indiquer de nouveaux administrateurs dans le paramètre adminList lors de la mise à niveau du code chaîne. Toute autre information du paramètre adminList est ignorée lors des mises à niveau.
func (t *Controller) Init(adminList []erc1155Admin.ERC1155TokenAdminAsset) (interface{}, error) {
      list, err := t.Ctx.ERC1155Admin.InitAdmin(adminList)
      if err != nil {
            return nil, fmt.Errorf("initialising admin list failed %s", err.Error())
      }
      <1st Token Name> := <1st TokenClassName>{}
      _, err = t.Ctx.ERC1155Token.SaveClassInfo(&<1st Token Name>)
      if err != nil {
            return nil, err
      }
         .
         .
      <nth Token Name> := <nth TokenClassName>{}
      _, err = t.Ctx.ERC1155Token.SaveClassInfo(&<nth Token Name>)
      if err != nil {
            return nil, err
      }
      _, err = t.Ctx.ERC1155Token.SaveDeleteTransactionInfo()
      if err != nil {
            fmt.Println("error: ", err)
      }
      return list, err
}
Paramètres :
  • adminList array : tableau d'informations {OrgId, UserId} qui indique la liste des administrateurs de jeton. Le tableau adminList est un paramètre obligatoire.
Create<Token Name>Token
Cette méthode crée des jetons. Chaque jeton défini possède sa propre méthode de création. Pour les jetons fongibles, cette méthode ne peut être appelée que par un Token Admin du code chaîne. Pour les jetons non fongibles, si le rôle de minter est défini dans le fichier de spécification, tout utilisateur doté du rôle de minter peut appeler cette méthode pour créer un NFT. Si le rôle minter n'est pas défini, tout utilisateur peut utiliser cette méthode pour créer des NFT. L'utilisateur qui appelle cette méthode devient le propriétaire du NFT.
Jetons fongibles :
func (t *Controller) Create<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.Save", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Token.Save(&tokenAsset)
    }
Jetons non fongibles :
func (t *Controller) Create<Token Name>Token(tokenAsset <Token Class>, quantity float64) (interface{}, error) {
         quantityToPass := []float64{quantity}
          return t.Ctx.ERC1155Token.Save(&tokenAsset, quantityToPass...)
    }
Paramètres :
  • tokenAsset: <Token Class> : ressource de jeton. Les propriétés de la ressource sont définies dans le fichier de modèle.
  • quantity: number : pour les jetons non fongibles uniquement, nombre de jetons à menthe. La seule valeur prise en charge pour ce paramètre est 1.
Renvoie :
  • En cas de succès, la ressource de jeton au format JSON, qui inclut les informations suivantes, en fonction du type de jeton.
  • Behaviors : liste des comportements de jeton. Cette propriété ne peut pas être modifiée.
  • CreatedBy : ID de compte de l'appelant, qui est l'utilisateur qui frappe le jeton. Cette propriété ne peut pas être modifiée.
  • CreationDate : horodatage de la transaction de frappe. Cette propriété ne peut pas être modifiée.
  • IsBurned : cette propriété indique si le jeton est gravé. Cette propriété ne peut pas être modifiée.
  • Mintable : propriétés liées à la frappe. La valeur max_mint_quantity définit le nombre maximal de jetons pouvant être créés pour la classe de jeton.
  • Owner : ID de compte du propriétaire actuel, qui est l'appelant de la méthode.
  • Symbol : symbole du jeton. Cette propriété ne peut pas être modifiée.
  • TokenDesc : description du jeton.
  • TokenMetadata : informations JSON décrivant le jeton.
  • TokenName : nom du jeton. Cette propriété ne peut pas être modifiée.
  • TokenStandard : norme du jeton. Cette propriété ne peut pas être modifiée.
  • TokenType : type du jeton (fongible ou non). Cette propriété ne peut pas être modifiée.
  • TokenUnit : unité du jeton (entière ou fractionnaire). Cette propriété ne peut pas être modifiée.
  • TokenUri : URI du jeton.
  • Quantity : quantité du jeton.
Exemple de valeur renvoyée (NFT entier) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2022-12-29T09:57:03+05:30",
    "IsBurned": false,
    "Mintable": {
        "Max_mint_quantity": 500
    },
    "OnSaleFlag": false,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Price": 100,
    "Quantity": 1,
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "token description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "artcollection",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
}
Exemple de valeur de retour (jeton fongible) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "Currency_name": "Dollar",
    "Divisible": {
        "Decimal": 2
    },
    "Mintable": {
        "Max_mint_quantity": 10000
    },
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "Token Description",
    "TokenId": "Loyalty",
    "TokenName": "loyalty",
    "TokenStandard": "erc1155+",
    "TokenType": "fungible",
    "TokenUnit": "fractional",
    "Token_to_currency_ratio": 0
}
Exemple de valeur de retour (NFT fractionnaire) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2023-06-14T09:53:53+05:30",
    "Divisible": {
        "Decimal": 2
    },
    "IsBurned": false,
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "On_sale_flag": false,
    "Price": 1000,
    "Quantity": 100,
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "Token Description",
    "TokenId": "realEstate",
    "TokenMetadata": {
        "Description": "Painting Description",
        "Image": "",
        "Painter_name": "",
        "Painting_name": "Paint"
    },
    "TokenName": "realestate",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "fractional",
    "TokenUri": "www.realestate.example.com"
}
Update<Token Name>Token
Cette méthode met à jour les jetons. Chaque jeton défini possède sa propre méthode de mise à jour. Vous ne pouvez pas mettre à jour les métadonnées de jeton ou l'URI de jeton de jetons non fongibles. Pour les jetons fongibles, cette méthode ne peut être appelée que par un Token Admin du code chaîne. Pour les jetons non fongibles, cette méthode ne peut être appelée que par le propriétaire du jeton.
Jetons fongibles :
func (t *Controller) Update<%=tokenModelName%>Token(tokenAsset <%=tokenModelName%>) (interface{}, error) {
        auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.Update", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Token.Update(&tokenAsset)
    }
Jetons non fongibles :
func (t *Controller) Update<%=tokenModelName%>Token(tokenAsset <%=tokenModelName%>) (interface{}, error) {
            return t.Ctx.ERC1155Token.Update(&tokenAsset)
    }
Paramètres :
  • tokenAsset: <Token Class> : ressource de jeton. Les propriétés de la ressource sont définies dans le fichier de modèle.
Renvoie :
  • En cas de succès, la ressource de jeton mise à jour au format JSON.
Exemple de valeur renvoyée (NFT entier) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2022-12-29T09:57:03+05:30",
    "IsBurned": false,
    "Mintable": {
        "Max_mint_quantity": 500
    },
    "OnSaleFlag": false,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Price": 100,
    "Quantity": 1,
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "token description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "artcollection",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
}
GetTokenHistory
Cette méthode renvoie l'historique d'un ID de jeton spécifié. N'importe qui peut appeler cette méthode.
func (t *Controller) GetTokenHistory(tokenId string) (interface{}, error) {
            return t.Ctx.ERC1155Token.GetTokenHistory(tokenId)
      }
Paramètres :
  • tokenId: string : ID du jeton.
Renvoie :
  • En cas de succès, tableau JSON contenant l'historique des jetons.
Exemple de valeur de retour (jeton fongible) :
[
  {
    "IsDelete": "false",
    "Timestamp": "2022-12-08T09:54:11Z",
    "TxId": "823sa7c7a00941c62285c86f922bc4d3f5326a20f4bf2f82daa5bc661e4682e8",
    "Value": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "Rupees",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "Updated Token Description",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "IsDelete": "false",
    "Timestamp": "2022-12-08T09:54:11Z",
    "TxId": "711bb7c7a00941c62285c86f922bc3b3f5326a20f4bf2f82daa5bc661e4682e8",
    "Value": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "Dollar",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  }
]
Exemple de valeur de retour (NFT fractionnaire) :
[
    {
        "Timestamp": "2023-06-20T01:06:33Z",
        "TrxId": "16e53db4f8107f9634b7c3a0a2a81a00f69b634f2a52902b809e544d07f272b1",
        "Value": {
            "AssetType": "otoken",
            "Behaviors": [
                "divisible",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "CreationDate": "2023-06-20T01:02:27Z",
            "Divisible": {
                "Decimal": 2
            },
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "On_sale_flag": true,
            "Owners": [
                {
                    "AccountId": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
                    "TokenShare": 10
                },
                {
                    "AccountId": "oaccount~3cddfdaa855900579d963aa6f755a4aed1f3a474a2462c1b45bd7f36df673224",
                    "TokenShare": 10
                }
            ],
            "Price": 2000,
            "Quantity": 20,
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "TokenDesc": "",
            "TokenId": "FNFT",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "Painter_name": "",
                "Painting_name": ""
            },
            "TokenName": "realestate",
            "TokenStandard": "erc1155+",
            "TokenType": "nonfungible",
            "TokenUnit": "fractional",
            "TokenUri": "www.FNFT.example.com"
        }
    },
    {
        "Timestamp": "2023-06-20T01:02:27Z",
        "TrxId": "cec80910d087682554048f911d2cf98b66382bbcf1615483fa1c96c7ea08077c",
        "Value": {
            "AssetType": "otoken",
            "Behaviors": [
                "divisible",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "CreationDate": "2023-06-20T01:02:27Z",
            "Divisible": {
                "Decimal": 2
            },
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "On_sale_flag": true,
            "Owners": [
                {
                    "AccountId": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
                    "TokenShare": 20
                }
            ],
            "Price": 2000,
            "Quantity": 20,
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "TokenDesc": "",
            "TokenId": "FNFT",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "Painter_name": "",
                "Painting_name": ""
            },
            "TokenName": "realestate",
            "TokenStandard": "erc1155+",
            "TokenType": "nonfungible",
            "TokenUnit": "fractional",
            "TokenUri": "www.FNFT.example.com"
        }
    }
]
Exemple de valeur renvoyée (NFT entier) :
[
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-20T01:15:56Z",
        "TxId": "89a3df3ebbe6dca2bcfbd51fc7dca9aab818a2af746b79a92dc8155b729ab22d",
        "Value": {
            "AssetType": "otoken",
            "Behaviors": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "roles"
            ],
            "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "CreationDate": "2023-06-20T01:15:56Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "On_sale_flag": true,
            "Owner": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "Price": 2000,
            "Quantity": 1,
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "TokenDesc": "Updated Token Description",
            "TokenId": "NFT",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "Painter_name": "",
                "Painting_name": ""
            },
            "TokenName": "artcollection",
            "TokenStandard": "erc1155+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "www.NFT.example.com"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-20T01:15:56Z",
        "TxId": "90d6af3ebbe6dca2bcfbd51fc7dca9aab818a2af746b79a92dc8155b729ab22d",
        "Value": {
            "AssetType": "otoken",
            "Behaviors": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "roles"
            ],
            "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "CreationDate": "2023-06-20T01:15:56Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "On_sale_flag": true,
            "Owner": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "Price": 2000,
            "Quantity": 1,
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "TokenDesc": "",
            "TokenId": "NFT",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "Painter_name": "",
                "Painting_name": ""
            },
            "TokenName": "artcollection",
            "TokenStandard": "erc1155+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "www.NFT.example.com"
        }
    }
]
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 Token Admin du code chaîne. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.
func (t *Controller) GetAllTokens() (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.GetAllTokens", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Token.GetAllTokens()
      }
Paramètres :
  • Aucun élément
Renvoie :
  • Liste de toutes les ressources de jeton au format JSON.
Exemple de valeur renvoyée :
[
  {
    "key": "tokenOne",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "key": "tokenTwo",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenTwo",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "key": "art",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
      ],
      "BurnedBy": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
      "BurnedDate": "2022-12-08T10:49:37Z",
      "CreatedBy": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
      "CreationDate": "2022-12-08T10:45:10Z",
      "IsBurned": true,
      "Mintable": {
        "Max_mint_quantity": 20000
      },
      "OnSaleFlag": false,
      "Owner": "",
      "Price": 0,
      "Roles": {
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "art",
      "TokenMetadata": {
        "Description": "",
        "Image": "",
        "PainterName": "",
        "PaintingName": ""
      },
      "TokenName": "artcollection",
      "TokenStandard": "erc1155+",
      "TokenType": "nonfungible",
      "TokenUnit": "whole",
      "TokenUri": "art.example.com",
      "TransferredBy": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
      "TransferredDate": "2022-12-08T10:47:04Z"
    }
  },
  {
    "key": "FNFT",
    "valueJson": {
        "AssetType": "otoken",
        "Behaviors": [
            "divisible",
            "mintable",
            "transferable",
            "burnable",
            "roles"
        ],
        "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
        "CreationDate": "2023-06-20T01:02:27Z",
        "Divisible": {
            "Decimal": 2
        },
        "IsBurned": false,
        "Mintable": {
            "Max_mint_quantity": 20000
        },
        "On_sale_flag": true,
        "Price": 2000,
        "Quantity": 20,
        "Roles": {
            "burner_role_name": "burner",
            "minter_role_name": "minter"
        },
        "TokenDesc": "",
        "TokenId": "FNFT",
        "TokenMetadata": {
            "Description": "",
            "Image": "",
            "Painter_name": "",
            "Painting_name": ""
        },
        "TokenName": "realestate",
        "TokenStandard": "erc1155+",
        "TokenType": "nonfungible",
        "TokenUnit": "fractional",
        "TokenUri": "www.FNFT.example.com"
    }
  },
  {
    "key": "FNFT",
    "valueJson": {
        "AssetType": "otoken",
        "Behaviors": [
            "divisible",
            "mintable",
            "transferable",
            "burnable",
            "roles"
        ],
        "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
        "CreationDate": "2023-06-20T01:02:27Z",
        "Divisible": {
            "Decimal": 2
        },
        "IsBurned": false,
        "Mintable": {
            "Max_mint_quantity": 20000
        },
        "On_sale_flag": true,
        "Price": 2000,
        "Quantity": 20,
        "Roles": {
            "burner_role_name": "burner",
            "minter_role_name": "minter"
        },
        "TokenDesc": "",
        "TokenId": "FNFT",
        "TokenMetadata": {
            "Description": "",
            "Image": "",
            "Painter_name": "",
            "Painting_name": ""
        },
        "TokenName": "realestate",
        "TokenStandard": "erc1155+",
        "TokenType": "nonfungible",
        "TokenUnit": "fractional",
        "TokenUri": "www.FNFT.example.com"
    }
  }
]
GetTokenById
Cette méthode renvoie un objet de jeton si le jeton est présent dans la base de données d'état. Pour les NFT fractionnaires, la liste des propriétaires est également renvoyée. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par le propriétaire du jeton.
func (t *Controller) GetTokenById(tokenId string) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.Get", "TOKEN", map[string]string{"tokenId": tokenId})
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Token.GetTokenById(tokenId)
      }
Paramètres :
  • tokenId string : ID du jeton à obtenir.
Exemple de valeur renvoyée (NFT entier) :
{
  "AssetType": "otoken",
  "Behaviors": [
    "indivisible",
    "singleton",
    "mintable",
    "transferable",
    "burnable",
    "roles"
  ],
  "CreatedBy": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
  "CreationDate": "2022-12-08T10:55:29Z",
  "IsBurned": false,
  "Mintable": {
    "Max_mint_quantity": 20000
  },
  "OnSaleFlag": false,
  "Owner": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
  "Price": 0,
  "Quantity": 1,
  "Roles": {
    "minter_role_name": "minter"
  },
  "TokenDesc": "",
  "TokenId": "nftToken",
  "TokenMetadata": {
    "Description": "",
    "Image": "",
    "PainterName": "",
    "PaintingName": ""
  },
  "TokenName": "artcollection",
  "TokenStandard": "erc1155+",
  "TokenType": "nonfungible",
  "TokenUnit": "whole",
  "TokenUri": "nftToken.example.com"
}
Exemple de valeur de retour (jeton fongible) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "Currency_name": "Dollar",
    "Divisible": {
        "Decimal": 2
    },
    "Mintable": {
        "Max_mint_quantity": 10000
    },
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "Token Description",
    "TokenId": "Loyalty",
    "TokenName": "loyalty",
    "TokenStandard": "erc1155+",
    "TokenType": "fungible",
    "TokenUnit": "fractional",
    "Token_to_currency_ratio": 0
}
Exemple de valeur de retour (NFT fractionnaire) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2023-06-14T09:53:53+05:30",
    "Divisible": {
        "Decimal": 2
    },
    "IsBurned": false,
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "On_sale_flag": false,
    "Owners": [
        {
            "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "TokenShare": 100
        }
    ],
    "Price": 1000,
    "Quantity": 100,
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "Token Description",
    "TokenId": "realEstate",
    "TokenMetadata": {
        "Description": "Painting Description",
        "Image": "",
        "Painter_name": "",
        "Painting_name": "Paint"
    },
    "TokenName": "realestate",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "fractional",
    "TokenUri": "www.realestate.example.com"
}
GetAllTokensByUser
Cette méthode renvoie toutes les ressources de jeton appartenant à un utilisateur spécifié. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant. Cette méthode peut être appelée uniquement 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.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in GetAllTokensByUser. Error: %s", err)
            }
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.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.ERC1155Token.GetAllTokensByUser(accountId)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Exemple de valeur renvoyée :
[
  {
    "key": "tokenOne",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "key": "nftToken",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
      ],
      "CreatedBy": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
      "CreationDate": "2022-12-08T10:55:29Z",
      "IsBurned": false,
      "Mintable": {
        "Max_mint_quantity": 20000
      },
      "OnSaleFlag": false,
      "Owner": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
      "Price": 0,
      "Quantity": 1,
      "Roles": {
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "nftToken",
      "TokenMetadata": {
        "Description": "",
        "Image": "",
        "PainterName": "",
        "PaintingName": ""
      },
      "TokenName": "artcollection",
      "TokenStandard": "erc1155+",
      "TokenType": "nonfungible",
      "TokenUnit": "whole",
      "TokenUri": "example.com"
    }
  }
]
OwnerOf
Cette méthode renvoie l'ID de compte, l'ID d'organisation et l'ID utilisateur du propriétaire de l'ID de jeton spécifié. N'importe qui peut appeler cette méthode.
func (t *Controller) OwnerOf(tokenId string) (interface{}, error) {
            return t.Ctx.ERC1155Token.OwnerOf(tokenId)
      }
Paramètres :
  • tokenId string : ID du jeton.
Exemple de valeur renvoyée (NFT entier) :
{
  "AccountId": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
  "OrgId": "appdev",
  "UserId": "idcqa"
}
Exemple de valeur de retour (NFT fractionnaire) :
[
    {
        "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
        "OrgId": "Org1MSP",
        "UserId": "admin"
    },
    {
        "AccountId": "oaccount~74108eca702bab6d8548e740254f2cc7955d886885251d52d065042172a59db0",
        "OrgId": "Org1MSP",
        "UserId": "user"
    }
]
URI
Cette méthode renvoie l'URI d'un jeton spécifié. N'importe qui peut appeler cette méthode.
func (t *Controller) URI(tokenId string) (interface{}, error) {
            return t.Ctx.ERC1155Token.TokenURI(tokenId)
      }
Paramètres :
  • tokenId string : ID du jeton.
Exemple de valeur renvoyée :
{
    "TokenUri": "example.com"
}
Name
Cette méthode renvoie le nom de la classe de jeton. N'importe qui peut appeler cette méthode.
func (t *Controller) Name(tokenId string) (interface{}, error) {
            return t.Ctx.ERC1155Token.Name(tokenId)
      }
Paramètres :
  • tokenId string : ID du jeton.
Exemple de valeur renvoyée :
{"TokenName": "artcollection"}
TotalSupply
Cette méthode renvoie le nombre total de jetons frappés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.
func (t *Controller) TotalSupply(tokenDetail erc1155Role.TokenDetail) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.TotalSupply", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            token, err := t.Ctx.ERC1155Token.GetTokenByIdOrName(tokenDetail)
            if err != nil {
                  return nil, err
            }
            return t.Ctx.ERC1155Token.TotalSupply(token)
      }
Paramètres :
  • tokenDetails erc1155Role.TokenDetail : détails qui spécifient le jeton. Pour les jetons fongibles, utilisez le format suivant :
    {"TokenId":"token1"}
    Pour les jetons non fongibles, utilisez le format suivant :
    {"TokenName":"artCollection"}
Exemple de valeur renvoyée :
{
    "TotalSupply": 100
}
TotalNetSupply
Cette méthode renvoie le nombre total de jetons frappés moins le nombre de jetons brûlés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.
func (t *Controller) TotalNetSupply(tokenDetail erc1155Role.TokenDetail) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.TotalNetSupply", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            token, err := t.Ctx.ERC1155Token.GetTokenByIdOrName(tokenDetail)
            if err != nil {
                  return nil, err
            }
            return t.Ctx.ERC1155Token.TotalNetSupply(token)
      }
Paramètres :
  • tokenDetails erc1155Role.TokenDetail : détails qui spécifient le jeton. Pour les jetons fongibles, utilisez le format suivant :
    {"TokenId":"token1"}
    Pour les jetons non fongibles, utilisez le format suivant :
    {"TokenName":"artCollection"}
Exemple de valeur renvoyée :
{
   "TotalNetSupply": 900
}
GetTokensByName
Cette méthode renvoie toutes les ressources de jeton pour un nom de jeton spécifié. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.
func (t *Controller) GetTokensByName(tokenName string) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.GetTokensByName", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Token.GetTokensByName(tokenName)
      }
Paramètres :
  • tokenName: string : nom du jeton.
Exemple de valeur renvoyée :
[
  {
    "key": "tokenOne",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "key": "tokenTwo",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenTwo",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  }
]
GetTokenDecimal
Cette méthode renvoie le nombre de décimales pour un jeton spécifié. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.
func (t *Controller) GetTokenDecimal(tokenId string) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.GetTokenDecimal", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            tokenDecimal, err := t.Ctx.ERC1155Token.GetDecimals(tokenId)
            if err != nil {
                  return nil, fmt.Errorf("error in GetTokenDecimal: %s", err.Error())
            }
            response := make(map[string]interface{})
            response["msg"] = fmt.Sprintf("Token Id: %s has %d decimal places.", tokenId, tokenDecimal)
            return response, nil
      }
Paramètres :
  • tokenId string : ID du jeton.
Exemple de valeur renvoyée :
{
    "msg": "Token Id: tokenOne has 2 decimal places."
}

Méthodes de gestion des comptes

CreateAccount
Cette méthode crée un compte pour un utilisateur spécifié et les comptes de jetons associés pour les jetons fongibles ou non fongibles. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Le compte utilisateur assure le suivi du compte NFT et des comptes de jetons fongibles dont dispose un utilisateur. Les utilisateurs doivent disposer de comptes sur le réseau pour effectuer les opérations liées aux jetons. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.

Un compte utilisateur possède un ID unique, formé par un hachage SHA-256 du paramètre orgId et du paramètre userId.

Un utilisateur peut avoir plusieurs comptes de jeton fongibles avec des ID de compte uniques. Les ID de compte de jeton fongibles sont formés par un hachage SHA-256 du paramètre orgId, le paramètre userId, la chaîne constante ft séparée par le symbole tilde (~) et un nombre de compteur qui signifie l'index du compte fongible créé séparé par le symbole tilde (~).

Un utilisateur ne peut avoir qu'un seul compte de jeton non fongible. Les ID de compte de jeton non fongibles sont uniques et sont formés par un hachage SHA-256 du paramètre orgId, du paramètre userId et de la chaîne constante nft séparés par le symbole tilde (~). Tous les jetons non fongibles qu'un utilisateur possède, qu'ils soient entiers ou fractionnaires, sont liés à ce compte.

Les ID de compte utilisateur commencent par ouaccount~. Les ID de compte de jeton commencent par oaccount~.

func (t *Controller) CreateAccount(orgId string, userId string, ftAccount bool, nftAccount bool) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.CreateAccount", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Account.CreateAccount(orgId, userId, ftAccount, nftAccount)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • ftAccount bool : si la valeur est True, un compte de jeton fongible est créé et associé au compte utilisateur.
  • nftAccount bool : si la valeur est True, un compte de jeton non fongible est créé et associé au compte utilisateur.
Renvoie :
  • En cas de succès, objet JSON du compte créé.
Exemple de valeur renvoyée :
{
  "AssetType": "ouaccount",
  "AccountId": "ouaccount~cf20877546f52687f387e7c91d88b9722c97e1a456cc0484f40c747f7804feae",
  "UserId": "user1",
  "OrgId": "appdev",
  "TotalAccounts": 2,
  "TotalFtAccounts": 1,
  "AssociatedFtAccounts": [
    {
      "AccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
      "TokenId": ""
    }
  ],
  "AssociatedNftAccount": "oaccount~73c3e835dac6d0a56ca9d8def08269f83cefd59b9d297fe2cdc5a9083828fa58"
}
CreateUserAccount
Cette méthode crée un compte pour un utilisateur spécifié. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Le compte utilisateur assure le suivi du compte NFT et des comptes de jetons fongibles dont dispose un utilisateur. Les utilisateurs doivent disposer de comptes sur le réseau pour effectuer les opérations liées aux jetons.

Un ID de compte est un hachage SHA-256 du paramètre orgId et du paramètre userId. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.

func (t *Controller) CreateUserAccount(orgId string, userId string) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.CreateUserAccount", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Account.CreateUserAccount(orgId, userId)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Renvoie :
  • En cas de succès, objet JSON du compte utilisateur créé.
Exemple de valeur renvoyée :
{
  "AssetType": "ouaccount",
  "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
  "UserId": "idcqa",
  "OrgId": "appdev",
  "TotalAccounts": 0,
  "TotalFtAccounts": 0,
  "AssociatedFtAccounts": [],
  "AssociatedNftAccount": ""
}
CreateTokenAccount
Cette méthode crée un compte de jeton fongible ou non fongible à associer à un compte utilisateur.

Un utilisateur peut avoir plusieurs comptes de jeton fongibles avec des ID de compte uniques. Les ID de compte de jeton fongibles sont formés par un hachage SHA-256 du paramètre orgId, le paramètre userId, la chaîne constante ft séparée par le symbole tilde (~) et un nombre de compteur qui signifie l'index du compte fongible créé séparé par le symbole tilde (~).

Un utilisateur ne peut avoir qu'un seul compte de jeton non fongible. Les ID de compte de jeton non fongibles sont uniques et sont formés par un hachage SHA-256 du paramètre orgId, du paramètre userId et de la chaîne constante nft séparés par le symbole tilde (~). Tous les jetons non fongibles qu'un utilisateur possède, qu'ils soient entiers ou fractionnaires, sont liés à ce compte.

Cette méthode ne peut être appelée que par un Token Admin du code chaîne.

func (t *Controller) CreateTokenAccount(orgId string, userId string, tokenType erc1155Token.TokenType) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.CreateTokenAccount", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            typeOfToken, err := tokenType.GetTokenType()
          if err != nil {
                  return nil, err
            }
            return t.Ctx.ERC1155Account.CreateTokenAccount(orgId, userId, typeOfToken)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • tokenType erc1155Token.TokenType : type de compte de jeton à créer. Les seuls types de jeton pris en charge sont nonfungible et fungible.
Renvoie :
  • En cas de succès, objet JSON du compte de jeton créé.
Exemple de valeur renvoyée :
{
    "AssetType": "ouaccount",
    "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "TotalAccounts": 1,
    "TotalFtAccounts": 1,
    "AssociatedFtAccounts": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "TokenId": ""
        }
    ],
    "AssociatedNftAccount": ""
}
AssociateFungibleTokenAccount
Cette méthode associe le compte de jeton fongible d'un utilisateur à un jeton fongible particulier.

Cette méthode ne peut être appelée que par Token Admin du code chaîne.

func (t *Controller) AssociateFungibleTokenToAccount(orgId string, userId string, tokenId string) (interface{}, error) {
            accountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in generating accountId. Error: %s", err)
            }
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.AssociateFungibleTokenToAccount", "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.ERC1155Account.AssociateTokenToToken(accountId, tokenId)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • tokenId string : ID du jeton.
Renvoie :
  • En cas de succès, un objet JSON du compte utilisateur, qui indique que le jeton fongible a été associé au compte de jeton. Par exemple, dans l'exemple suivant, le premier objet du tableau associatedFtAccounts indique que l'ID de compte de jeton fongible et l'ID de jeton sont associés.
Exemple de valeur renvoyée :
{
    "AssetType": "ouaccount",
    "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "TotalAccounts": 1,
    "TotalFtAccounts": 1,
    "AssociatedFtAccounts": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "TokenId": "tokenOne"
        }
    ],
    "AssociatedNftAccount": ""
}
GetAccountHistory
Cette méthode renvoie l'historique d'un compte de jeton spécifié. Il s'agit d'une méthode asynchrone. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par le propriétaire du compte.
func (t *Controller) GetAccountHistory(orgId string, userId string, tokenId ...string) (interface{}, error) {
            userAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in GetAccountHistory. Error: %s", err)
            }
            _, err = t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.History", "TOKEN", map[string]string{"accountId": userAccountId})
            if err != nil {
                  return nil, fmt.Errorf("error in GetAccountHistory. Error: %s", err)
            }
            tokenAccount, err := t.Ctx.ERC1155Account.Get(userAccountId, tokenId...)
            if err != nil {
                  return nil, fmt.Errorf("error in GetAccountHistory. Error: %s", err)
            }
            tokenAccountId, err := util.GetAccountProperty(tokenAccount, constants.AccountId)
            if err != nil {
                  return nil, fmt.Errorf("error in GetAccountHistory. Error: %s", err)
            }
            return t.Ctx.ERC1155Account.GetAccountHistory(tokenAccountId)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • tokenId ...string : pour un compte de jeton non fongible, une chaîne vide. Pour un compte de jeton fongible, ID de jeton.
Renvoie :
  • En cas de succès, tableau d'objets JSON qui décrit l'historique des comptes.
Exemple de valeur renvoyée :
[
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-06T11:03:48Z",
        "TxId": "c5180f3be3d9130f25a4b4e866f38a4283117dcbfbffb4f55e2c5b03dba0dd29",
        "Value": {
            "AccountCategory": "",
            "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
            "AssetType": "oaccount",
            "Balance": 100,
            "BapAccountVersion": 1
            "OrgId": "appdev",
            "TokenId": "loy1",
            "TokenName": "loyalty",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-06T11:02:39Z",
        "TxId": "6f81b0c94b451d375a3892446aefbdf78d9fd1ac43699daa89f0dff10db5fd22",
        "Value": {
            "AccountCategory": "",
            "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
            "AssetType": "oaccount",
            "Balance": 0,
            "BapAccountVersion": 0
            "OrgId": "appdev",
            "TokenId": "loy1",
            "TokenName": "loyalty",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-05T16:28:46Z",
        "TxId": "8185af648546e909488e72149be497b210f74f95ada252c42da9c35cb9d98691",
        "Value": {
            "AccountCategory": "",
            "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
            "AssetType": "oaccount",
            "Balance": 0,
            "BapAccountVersion": 0
            "OrgId": "appdev",
            "TokenId": "",
            "TokenName": "",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    }
]
GetAccount
Cette méthode renvoie les détails du compte de jeton pour un utilisateur spécifié. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par Account Owner du compte.
func (t *Controller) GetAccount(orgId string, userId string, tokenId ...string) (interface{}, error) {
            accountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, err
            }
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.GetAccount", "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.ERC1155Account.GetAccountWithStatus(accountId, tokenId...)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • tokenId ...string : pour un compte de jeton non fongible, une chaîne vide. Pour un compte de jeton fongible, ID de jeton.
Renvoie :
  • En cas de succès, objet JSON qui inclut les détails du compte de jeton. Les paramètres BapAccountVersion et AccountCategory sont définis dans l'objet de compte pour une utilisation interne.
Exemple de valeur de retour (compte de jeton non fongible) :
{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 1,
  "NoOfNfts": 1,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}
Exemple de valeur de retour (compte de jeton fongible) :
{
  "AccountCategory": "",
  "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
  "AssetType": "oaccount",
  "Balance": 0,
  "BapAccountVersion": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenId": "t1",
  "TokenName": "loyalty",
  "TokenType": "fungible",
  "UserId": "idcqa"
}
GetAllAccounts
Cette méthode renvoie les détails de tous les comptes utilisateur. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.
func (t *Controller) GetAllAccounts() (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.GetAllAccounts", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Account.GetAllAccounts()
      }
Paramètres :
  • Aucun élément
Renvoie :
  • En cas de succès, tableau JSON de tous les comptes.
Exemple de valeur renvoyée :
[
    {
        "AssetType": "ouaccount",
        "AccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38",
        "UserId": "idcqa",
        "OrgId": "appdev",
        "TotalAccounts": 3,
        "TotalFtAccounts": 2,
        "AssociatedFtAccounts": [
            {
                "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
                "TokenId": "loy1"
            },
            {
                "AccountId": "oaccount~58c5a6b09a41befca2a9ea2550439838c4dcf4d8a2a4f7c98e9319cf8479bfc4",
                "TokenId": ""
            }
        ],
        "AssociatedNftAccount": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371"
    },
    {
        "AssetType": "ouaccount",
        "AccountId": "ouaccount~9501bb774c156eb8354dfe489250ea91f757523d70f08ee494bda98bb352003b",
        "UserId": "user1_minter",
        "OrgId": "appdev",
        "TotalAccounts": 2,
        "TotalFtAccounts": 1,
        "AssociatedFtAccounts": [
            {
                "AccountId": "oaccount~1089ee5122f367ee0ca38c6660298f4b81f199627e4f67f3691c0f628237974c",
                "TokenId": "loy1"
            }
        ],
        "AssociatedNftAccount": "oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446"
    },
]
GetAccountDetailsByUser
Cette méthode renvoie un récapitulatif de compte pour un utilisateur spécifié et les détails des jetons fongibles et non fongibles associés à l'utilisateur. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par Account Owner du compte.
func (t *Controller) GetAccountDetailsByUser(orgId string, userId string) (interface{}, error) {
            accountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, err
            }
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.GetAccountDetailsByUser", "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.ERC1155Account.GetAccountDetailsByUser(orgId, userId)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Renvoie :
  • En cas de succès, objet de compte JSON qui inclut et résume le compte pour l'utilisateur spécifié et les détails des jetons fongibles et non fongibles associés à l'utilisateur. Pour les jetons non fongibles fractionnaires, la propriété TokenShare de la section AssociatedNFTs affiche le partage dont l'utilisateur est propriétaire.
Exemple de valeur renvoyée :
{
    "AssociatedFTAccounts": [
        {
            "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
            "Balance": 90,
          "TokenId": "FT"
        },
    ],
    "AssociatedNFTAccount": {
        "AccountId": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
        "AssociatedNFTs": [
            {
              "NFTTokenId": "FNFT",
                "TokenShare": 230
            },
            {
              "NFTTokenId": "NFT"
            },
            {
              "NFTTokenId": "NFT2"
            }
        ]
    },
    "UserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
}
GetUserByAccountId
Cette méthode renvoie les détails utilisateur d'un ID de compte spécifié. Cette méthode peut être appelée par tous les utilisateurs.
func (t *Controller) GetUserByAccountId(accountId string) (interface{}, error) {
            return t.Ctx.ERC1155Account.GetUserByAccountById(accountId)
      }
Paramètres :
  • accountId string – ID du compte.
Renvoie :
  • En cas de succès, objet JSON des détails de l'utilisateur (orgId et userId).
Exemple de valeur renvoyée :
{
    "OrgId": "appdev",
    "UserId": "user2"
}

Méthodes de gestion des rôles

AddRole
Cette méthode ajoute un rôle à un utilisateur et un jeton spécifiés. Cette méthode ne peut être appelée que par un Token Admin du code chaîne. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton. L'utilisateur spécifié doit disposer d'un compte de jeton associé au jeton fongible ou d'un compte de jeton non fongible pour les rôles NFT. Le rôle spécifié doit exister dans le fichier de spécification du jeton.
func (t *Controller) AddRole(orgId string, userId string, role string, tokenDetail erc1155Role.TokenDetail) (interface{}, error) {
            userAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, err
            }
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.AddRoleMember", "TOKEN", map[string]string{"accountId": userAccountId})
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            token, err := t.Ctx.ERC1155Token.GetTokenByIdOrName(tokenDetail)
            if err != nil {
                  return nil, err
            }
            return t.Ctx.ERC1155Token.AddRoleMember(role, userAccountId, token)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • role: string : nom du rôle à ajouter à l'utilisateur spécifié.
  • tokenDetails erc1155Role.TokenDetail : détails qui spécifient le jeton. Pour les jetons fongibles, utilisez le format suivant :
    {"TokenId":"token1"}
    Pour les jetons non fongibles, utilisez le format suivant :
    {"TokenName":"artCollection"}
Renvoie :
  • En cas de succès, message avec les détails du compte.
Exemple de valeur renvoyée :
{
    "msg": "Successfully added role minter to oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a (orgId : appdev, userId : idcqa)"
}
IsInRole
Cette méthode renvoie une valeur booléenne pour indiquer si un utilisateur a un rôle spécifié. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton. Cette méthode ne peut être appelée que par Token Admin du code chaîne ou par Account Owner du compte. L'utilisateur spécifié doit disposer d'un compte de jeton associé au jeton fongible ou d'un compte de jeton non fongible pour les rôles NFT. Le rôle spécifié doit exister dans le fichier de spécification du jeton.
func (t *Controller) IsInRole(orgId string, userId string, role string, tokenDetail erc1155Role.TokenDetail) (interface{}, error) {
            userAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, err
            }
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.IsInRole", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            token, err := t.Ctx.ERC1155Token.GetTokenByIdOrName(tokenDetail)
            if err != nil {
                  return nil, err
            }
            var result bool
            result, err = t.Ctx.ERC1155Token.IsInRole(role, userAccountId, token)
            if err != nil {
                  return nil, fmt.Errorf("error in IsInRole %s", err.Error())
            }
            response := make(map[string]interface{})
            response["result"] = result
            return response, nil
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • role: string : nom du rôle à rechercher.
  • tokenDetails erc1155Role.TokenDetail : détails qui spécifient le jeton. Pour les jetons fongibles, utilisez le format suivant :
    {"TokenId":"token1"}
    Pour les jetons non fongibles, utilisez le format suivant :
    {"TokenName":"artCollection"}
Exemple de valeur renvoyée :
{
    "result": true
}
RemoveRole
Cette méthode supprime un rôle d'un utilisateur et d'un jeton spécifiés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton. Cette méthode ne peut être appelée que par Token Admin du code chaîne. L'utilisateur spécifié doit disposer d'un compte de jeton associé au jeton fongible ou d'un compte de jeton non fongible pour les rôles NFT. Le rôle spécifié doit exister dans le fichier de spécification du jeton.
func (t *Controller) RemoveRole(orgId string, userId string, role string, tokenDetail erc1155Role.TokenDetail) (interface{}, error) {
            userAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, err
            }
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Token.RemoveRoleMember", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            token, err := t.Ctx.ERC1155Token.GetTokenByIdOrName(tokenDetail)
            if err != nil {
                  return nil, err
            }
            return t.Ctx.ERC1155Token.RemoveRoleMember(role, userAccountId, token)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • role: string : nom du rôle à enlever de l'utilisateur spécifié.
  • tokenDetails erc1155Role.TokenDetail : détails qui spécifient le jeton. Pour les jetons fongibles, utilisez le format suivant :
    {"TokenId":"token1"}
    Pour les jetons non fongibles, utilisez le format suivant :
    {"TokenName":"artCollection"}
Exemple de valeur renvoyée :
{
    "msg": "Successfully removed role 'minter' from Account Id: oaccount~ec7e4de2f81e3ea071710e07b6ff7d9346e84ef665ca4650885dbe8c3e2bd4c0 (Org-Id: appdev, User-Id: idcqa)"
}
GetAccountsByRole
Cette méthode renvoie la liste de tous les ID de compte pour un rôle et un jeton spécifiés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton. Cette méthode ne peut être appelée que par Token Admin du code chaîne.
func (t *Controller) GetAccountsByRole(role string, tokenDetail erc1155Role.TokenDetail) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Role.GetAccountsByRole", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            token, err := t.Ctx.ERC1155Token.GetTokenByIdOrName(tokenDetail)
            if err != nil {
                  return nil, err
            }
            return t.Ctx.ERC1155Role.GetAccountsByRole(role, token)
      }
Paramètres :
  • role: string : nom du rôle à rechercher.
  • tokenDetails erc1155Role.TokenDetail : détails qui spécifient le jeton. Pour les jetons fongibles, utilisez le format suivant :
    {"TokenId":"token1"}
    Pour les jetons non fongibles, utilisez le format suivant :
    {"TokenName":"artCollection"}
Exemple de valeur renvoyée :
{
    "accounts": [
        "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
        "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b"
    ]
}
GetUsersByRole
Cette méthode renvoie la liste de tous les utilisateurs pour un rôle et un jeton spécifiés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton. Cette méthode ne peut être appelée que par Token Admin du code chaîne.
func (t *Controller) GetUsersByRole(role string, tokenDetail erc1155Role.TokenDetail) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Role.GetUsersByRole", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            token, err := t.Ctx.ERC1155Token.GetTokenByIdOrName(tokenDetail)
            if err != nil {
                  return nil, err
            }
            return t.Ctx.ERC1155Role.GetUsersByRole(role, token)
      }
Paramètres :
  • role: string : nom du rôle à rechercher.
  • tokenDetails erc1155Role.TokenDetail : détails qui spécifient le jeton. Pour les jetons fongibles, utilisez le format suivant :
    {"TokenId":"token1"}
    Pour les jetons non fongibles, utilisez le format suivant :
    {"TokenName":"artCollection"}
Exemple de valeur renvoyée :
{
    "Users": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "OrgId": "appdev",
            "UserId": "idcqa"
        },
        {
            "AccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
            "OrgId": "appdev",
            "UserId": "user1"
        }
    ]
}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory
Cette méthode renvoie l'historique des transactions de compte. Cette méthode peut être appelée uniquement par un élément Token Admin du code chaîne ou par le propriétaire du compte. Pour les jetons non fongibles, cette méthode ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.
func (t *Controller) GetAccountTransactionHistory(orgId string, userId string, tokenId ...string) (interface{}, error) {
            userAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in GetAccountTransactionHistory. Error: %s", err)
            }
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.GetAccountTransactionHistory", "TOKEN", map[string]string{"accountId": userAccountId})
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            tokenAccount, err := t.Ctx.ERC1155Account.Get(userAccountId, tokenId...)
            if err != nil {
                  return nil, fmt.Errorf("error in GetAccountTransactionHistory. Error: %s", err)
            }
            tokenAccountId, err := util.GetAccountProperty(tokenAccount, constants.AccountId)
            if err != nil {
                  return nil, fmt.Errorf("error in GetAccountTransactionHistory. Error: %s", err)
            }
            return t.Ctx.ERC1155Account.GetAccountTransactionHistory(tokenAccountId)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • tokenId ...string : pour un compte de jeton non fongible, une chaîne vide. Pour un compte de jeton fongible, ID de jeton.
Exemple de valeur renvoyée :
[
    {
        "Balance": 90,
        "Timestamp": "2023-06-06T11:11:09Z",
        "TokenId": "FNFT",
        "TransactedAccount": "oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446",
        "TransactedAmount": 10,
        "TransactionId": "otransaction~0f4d96fbf8fed88ea8a3133428977721091467c701848d595ebc3fffa88b3657~7c88c736df38d5622512f1e8dcdd50710eb47c953f1ecb24ac44790a9e2f475b",
        "TransactionType": "DEBIT",
        "TriggeredByUserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
    },
    {
        "Timestamp": "2023-06-06T11:11:09Z",
        "TokenId": "NFT",
        "TransactedAccount": "oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446",
        "TransactionId": "otransaction~0f4d96fbf8fed88ea8a3133428977721091467c701848d595ebc3fffa88b3657~178e3730bc5bee50d02f1464a4eebf733a051905f651e5789039adb4a3edc114",
        "TransactionType": "DEBIT",
        "TriggeredByUserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
    },
    {
        "Timestamp": "2023-06-06T11:06:54Z",
        "TokenId": "NFT",
        "TransactedAccount": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
        "TransactionId": "otransaction~6a13667ea3f6edc4c854e85b127526eccb58783f653c348b42a3869f0f29a4fb~a7cefb22ff39ee7e36967be71de27da6798548c872061a62dabc56d88d50b930",
        "TransactionType": "MINT",
        "TriggeredByUserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
    },
    {
        "Balance": 100,
        "Timestamp": "2023-06-05T16:34:33Z",
        "TokenId": "FNFT",
        "TransactedAccount": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
        "TransactedAmount": 100,
        "TransactionId": "otransaction~2bc15de1766d582d821bd8d61756bca02837dc683c0aa61f69657ccd1d95e335~e4eb15d9354f694230df8835ade012100d82aa43672896a2c7125a86e3048f9f",
        "TransactionType": "MINT",
        "TriggeredByUserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
    }
]
GetTransactionById
Cette méthode renvoie les détails de transaction pour un ID de transaction spécifié. N'importe qui peut appeler cette méthode.
func (t *Controller) GetTransactionById(transactionId string) (interface{}, error) {
            return t.Ctx.ERC1155Transaction.GetTransactionById(transactionId)
      }
Paramètres :
  • transactionId: string : ID de la transaction.
Exemple de valeur renvoyée :
{
    "history": [
        {
            "IsDelete": "false",
            "Timestamp": "2022-12-08T10:45:56Z",
            "TxId": "2da02a53aa1032602df6c68c5628a4ab8b22ba107c0201520ce495948901aa98",
            "Value": {
                "Amount": 5,
                "AssetType": "otransaction",
                "FromAccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
                "Timestamp": "2022-12-08T10:45:56Z",
                "ToAccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
                "TokenId": "tokenOne",
                "TransactionId": "otransaction~2da02a53aa1032602df6c68c5628a4ab8b22ba107c0201520ce495948901aa98~9c3ce5f21abd98ca018c196086d73a812f2f49dba323f1de4f6867eecfeec8ff",
                "TransactionType": "TRANSFER",
                "TriggeredByUserAccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc"
            }
        }
    ],
    "transactionId": "otransaction~2da02a53aa1032602df6c68c5628a4ab8b22ba107c0201520ce495948901aa98~9c3ce5f21abd98ca018c196086d73a812f2f49dba323f1de4f6867eecfeec8ff"
}
DeleteHistoricalTransactions
Cette méthode supprime les transactions antérieures à un horodatage spécifié de la base de données d'état. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.
func (t *Controller) DeleteHistoricalTransactions(timestamp string) (interface{}, error) {
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Transaction.DeleteHistoricalTransactions", "TOKEN")
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            return t.Ctx.ERC1155Transaction.DeleteHistoricalTransactions(timestamp)
      }
Paramètres :
  • timestamp: string – Toutes les transactions antérieures à cet horodatage seront supprimées.
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

MintBatch
Cette méthode crée (affecte) plusieurs jetons dans une opération de batch. Cette méthode crée uniquement des jetons fongibles ou des jetons non fongibles fractionnaires.

Pour les jetons fongibles, si le rôle minter est défini dans le fichier de spécification, tout utilisateur disposant du rôle minter peut appeler cette méthode. Sinon, n'importe quel utilisateur peut utiliser cette méthode pour frapper des jetons. Vous ne pouvez pas dépasser la propriété max_mint_quantity du jeton si cette propriété a été spécifiée lors de la création ou de la mise à jour du jeton.

Pour les jetons non fongibles, si le rôle minter est défini dans le fichier de spécification, tout utilisateur disposant du rôle minter peut appeler cette méthode. Sinon, n'importe quel utilisateur peut utiliser cette méthode pour frapper des jetons. En outre, l'appelant doit également être le créateur du jeton. Il n'y a pas de limite supérieure à la quantité de jetons fractionnaires non fongibles qui peuvent être frappés.

Vous ne pouvez pas utiliser cette méthode pour frapper un jeton non fongible entier.

func (t *Controller) MintBatch(orgId string, userId string, tokenIds []string, quantity []float64) (interface{}, error) {
            accountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in generating the accountId. Error: %s", err)
            }
            var tokens []interface{}
            for _, tokenId := range tokenIds {
                  tokenAssetValue, err := t.getTokenObject(tokenId)
                  if err != nil {
                        return nil, err
                  }
                  tokens = append(tokens, tokenAssetValue.Interface())
            }
            return t.Ctx.ERC1155Token.MintBatch(accountId, tokens, quantity)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • tokenIds []string : liste des ID de jeton pour lesquels les jetons ment.
  • quantity []float64 : liste des quantités de jetons à menthe, correspondant au tableau d'ID de jeton.
Renvoie :
  • En cas de succès, objet JSON qui inclut des détails sur les jetons extraits.
Exemple de valeur renvoyée :
{
    "details": [
        {
            "msg": "Successfully minted 100 tokens of fractional tokenId: plot55 to Org-Id: appdev, User-Id: idcqa"
        },
        {
            "msg": "Successfully minted 100 tokens of tokenId: 'loyalty' to Token-Account-Id 'oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e'"
        }
    ],
    "msg": "Successfully minted batch of tokens for User-Account-Id 'ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38' (Org-Id: 'appdev', User-Id: 'idcqa')"
}

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

BatchTransferFrom
Cette méthode termine une opération par lots qui transfère les jetons spécifiés dans une liste d'ID de jeton d'un utilisateur à un autre.

Pour les NFT, comme la méthode transfère la propriété du NFT, l'expéditeur du NFT doit posséder le jeton.

Pour les NFT fractionnaires, si un utilisateur (y compris le créateur du jeton) transfère tous les partages qu'il possède, il perd la propriété du jeton. Si une partie d'un jeton est transférée à un utilisateur, cet utilisateur devient automatiquement l'un des propriétaires du NFT fractionnaire.

Cette méthode ne vérifie pas que l'appelant de la méthode est l'expéditeur indiqué. Cette méthode peut être appelée par tous les utilisateurs.

func (t *Controller) BatchTransferFrom(fromOrgId string, fromUserId string, toOrgId string, toUserId string, tokenIds []string, quantity []float64) (interface{}, error) {
            fromAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(fromOrgId, fromUserId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in BatachTransferFrom. Error: %s", err)
            }
            toAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(toOrgId, toUserId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in BatachTransferFrom. Error: %s", err)
            }
            var tokens []interface{}
            for _, tokenId := range tokenIds {
                  tokenAssetValue, err := t.getTokenObject(tokenId)
                  if err != nil {
                        return nil, err
                  }
                  tokens = append(tokens, tokenAssetValue.Interface())
            }
            return t.Ctx.ERC1155Token.BatchTransferFrom(fromAccountId, toAccountId, tokens, quantity)
      }
Paramètres :
  • fromOrgId string : ID du fournisseur de services d'adhésion de l'expéditeur et du propriétaire du jeton dans l'organisation actuelle.
  • fromUserId string : nom d'utilisateur ou ID de courriel de l'expéditeur et du propriétaire du jeton.
  • toOrgId string : ID du fournisseur de services d'adhésion du destinataire dans l'organisation actuelle.
  • toUserId string : nom d'utilisateur ou ID courriel du destinataire.
  • tokenIds string[] : liste des ID de jeton pour les jetons à transférer.
  • quantity float64[] : liste des quantités de jetons à transférer, correspondant au tableau d'ID de jeton.
Renvoie :
  • En cas de succès, un message contenant les détails de chaque transfert de jeton.
Exemple de valeur renvoyée :
[
    {
        "msg": "Successfully transferred NFT token: 'FNFT' of '10' quantity from Account-Id: oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371 (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446 (Org-Id: appdev, User-Id: user1_minter)"
    },
    {
        "msg": "Successfully transferred 10 FT token: 'FT' from Account-Id: oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~1089ee5122f367ee0ca38c6660298f4b81f199627e4f67f3691c0f628237974c (Org-Id: appdev, User-Id: user1_minter)"
    },
    {
        "msg": "Successfully transferred NFT token: 'NFT' from Account-Id: oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371 (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446 (Org-Id: appdev, User-Id: user1_minter)"
    }
]
SafeBatchTransferFrom
Cette méthode termine une opération par lots qui transfère les jetons spécifiés dans une liste d'ID de jeton d'un utilisateur à un autre.

Pour les NFT, comme la méthode transfère la propriété du NFT, l'expéditeur du NFT doit posséder le jeton.

Pour les NFT fractionnaires, si un utilisateur (y compris le créateur du jeton) transfère tous les partages qu'il possède, il perd la propriété du jeton. Si une partie d'un jeton est transférée à un utilisateur, cet utilisateur devient automatiquement l'un des propriétaires du NFT fractionnaire.

L'appelant de la méthode doit être l'expéditeur spécifié. Cette méthode peut être appelée par tous les utilisateurs.

func (t *Controller) SafeBatchTransferFrom(fromOrgId string, fromUserId string, toOrgId string, toUserId string, tokenIds []string, quantity []float64) (interface{}, error) {
            fromAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(fromOrgId, fromUserId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in BatachTransferFrom. Error: %s", err)
            }
            toAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(toOrgId, toUserId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in BatachTransferFrom. Error: %s", err)
            }
            var tokens []interface{}
            for _, tokenId := range tokenIds {
                  tokenAssetValue, err := t.getTokenObject(tokenId)
                  if err != nil {
                        return nil, err
                  }
                  tokens = append(tokens, tokenAssetValue.Interface())
            }
            return t.Ctx.ERC1155Token.SafeBatchTransferFrom(fromAccountId, toAccountId, tokens, quantity)
      }
Paramètres :
  • fromOrgId string : ID du fournisseur de services d'adhésion de l'expéditeur et du propriétaire du jeton dans l'organisation actuelle.
  • fromUserId string : nom d'utilisateur ou ID de courriel de l'expéditeur et du propriétaire du jeton.
  • toOrgId string : ID du fournisseur de services d'adhésion du destinataire dans l'organisation actuelle.
  • toUserId string : nom d'utilisateur ou ID courriel du destinataire.
  • tokenIds string[] : liste des ID de jeton pour les jetons à transférer.
  • quantity float64[] : liste des quantités de jetons à transférer, correspondant au tableau d'ID de jeton.
Renvoie :
  • En cas de succès, un message contenant les détails de chaque transfert de jeton.
Exemple de valeur renvoyée :
[
    {
        "msg": "Successfully transferred NFT token: 'FNFT' of '10' quantity from Account-Id: oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371 (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446 (Org-Id: appdev, User-Id: user1_minter)"
    },
    {
        "msg": "Successfully transferred 10 FT token: 'FT' from Account-Id: oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~1089ee5122f367ee0ca38c6660298f4b81f199627e4f67f3691c0f628237974c (Org-Id: appdev, User-Id: user1_minter)"
    },
    {
        "msg": "Successfully transferred NFT token: 'NFT' from Account-Id: oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371 (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446 (Org-Id: appdev, User-Id: user1_minter)"
    }
]
BalanceOfBatch
Cette méthode termine une opération de batch qui obtient le solde des comptes de jeton. Les détails du compte sont indiqués dans trois listes distinctes d'ID d'organisation, d'ID d'utilisateur et d'ID de jeton. Cette méthode ne peut être appelée que par un Token Admin du code chaîne ou par les propriétaires de compte. Les titulaires de compte ne peuvent voir les détails du solde que pour les comptes dont ils sont propriétaires.
func (t *Controller) BalanceOfBatch(orgIds []string, userIds []string, tokenIds []string) (interface{}, error) {
            callerAccountCheck := false
            _, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.BalanceOfBatch", "TOKEN")
            if err != nil {
                  callerAccountCheck = true
            }
            accountIds, err := t.Ctx.ERC1155Account.GenerateAccountIds(orgIds, userIds, callerAccountCheck)
            if err != nil {
                  return nil, fmt.Errorf("error in BalanceOfBatch. Error: %s", err)
            }
            var tokens []interface{}
            for _, tokenId := range tokenIds {
                  tokenAssetValue, err := t.getTokenObject(tokenId)
                  if err != nil {
                        tokens = append(tokens, map[string]interface{}{"TokenId": tokenId})
                  } else {
                        tokens = append(tokens, tokenAssetValue.Interface())
                  }
            }
            return t.Ctx.ERC1155Account.BalanceOfBatch(accountIds, tokens)
      }
Paramètres :
  • orgIds []string : liste des ID de fournisseur de services d'adhésion dans l'organisation actuelle.
  • userIds []string : liste du nom d'utilisateur ou des ID de courriel.
  • tokenIds []string : liste des ID de jeton.
Exemple de valeur renvoyée :

Dans l'exemple suivant, l'ID de jeton FNFT représente un jeton non fongible fractionnaire et l'ID de jeton FT représente un jeton fongible.

[
    {
        "OrgId": "appdev",
        "UserId": "idcqa",
        "UserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38",
        "TokenAccountId": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
        "TokenId": "FNFT",
        "Balance": 100
    },
    {
        "OrgId": "appdev",
        "UserId": "idcqa",
        "UserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38",
        "TokenAccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
        "TokenId": "FT",
        "Balance": 50
    },
    {
        "OrgId": "appdev",
        "UserId": "user1_minter",
        "UserAccountId": "ouaccount~9501bb774c156eb8354dfe489250ea91f757523d70f08ee494bda98bb352003b",
        "TokenAccountId": "oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446",
        "TokenId": "FNFT",
        "Balance": 10
    }
]
ExchangeToken
Cette méthode échange des jetons entre des comptes spécifiés. Cette méthode prend uniquement en charge l'échange entre un NFT et un jeton fongible ou un jeton fongible et un NFT. Cette méthode ne peut être appelée que par le propriétaire du compte.
func (t *Controller) ExchangeToken(fromTokenId string, fromOrgId string, fromUserId string, fromTokenQuantity float64, toTokenId string, toOrgId string, toUserId string, toTokenQuantity float64) (interface{}, error) {
            fromUserAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(fromOrgId, fromUserId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in BatachTransferFrom. Error: %s", err)
            }
            auth, err := t.Ctx.ERC1155Auth.CheckAuthorization("ERC1155Account.ExchangeToken", "TOKEN", map[string]string{"accountId": fromUserAccountId})
            if err != nil && !auth {
                  return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
            }
            toUserAccountId, err := t.Ctx.ERC1155Account.GenerateAccountId(toOrgId, toUserId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in BatachTransferFrom. Error: %s", err)
            }
            return t.Ctx.ERC1155Token.ExchangeToken(fromTokenId, fromUserAccountId, fromTokenQuantity, toTokenId, toUserAccountId, toTokenQuantity)
      }
Paramètres :
  • fromTokenId string : ID du jeton appartenant à l'expéditeur.
  • fromOrgId string : ID du fournisseur de services d'adhésion de l'expéditeur dans l'organisation actuelle.
  • fromUserId string : nom d'utilisateur ou ID courriel de l'expéditeur.
  • fromTokenQuantity float64 : quantité de jetons de l'expéditeur à échanger avec le destinataire.
  • toTokenId string : ID du jeton appartenant au récepteur.
  • toOrgId string : ID du fournisseur de services d'adhésion du destinataire dans l'organisation actuelle.
  • toUserId string : nom d'utilisateur ou ID courriel du destinataire.
  • toTokenQuantity float64 : quantité de jetons du récepteur à échanger avec l'expéditeur.
Renvoie :
  • En cas de succès, message avec les détails de l'échange de jetons.
Exemple de valeur renvoyée :
{
    "msg": "Succesfully exchanged 10 tokens of type 'nonfungible' with tokenId: [r1] from Account 'oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371' (OrgId: appdev, UserId: idcqa) to 10 tokens of type 'fungible' with tokenId: [loy1] from Account 'oaccount~1089ee5122f367ee0ca38c6660298f4b81f199627e4f67f3691c0f628237974c' (OrgId: 'appdev', UserId: 'user1_minter')"
}

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

BurnBatch
Cette méthode désactive, ou brûle, les jetons fongibles et non fongibles spécifiés. Tout utilisateur peut appeler cette méthode.
func (t *Controller) BurnBatch(orgId string, userId string, tokenIds []string, quantity []float64) (interface{}, error) {
            accountId, err := t.Ctx.ERC1155Account.GenerateAccountId(orgId, userId, constants.UserAccount)
            if err != nil {
                  return nil, fmt.Errorf("error in BatachTransferFrom. Error: %s", err)
            }
            var tokens []interface{}
            for _, tokenId := range tokenIds {
                  tokenAssetValue, err := t.getTokenObject(tokenId)
                  if err != nil {
                        return nil, err
                  }
                  tokens = append(tokens, tokenAssetValue.Interface())
            }
            return t.Ctx.ERC1155Token.Burn(accountId, tokens, quantity)
      }
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou ID de courriel.
  • tokenIds []string : liste des ID de jeton à graver
  • quantity []float64 : liste des quantités de jetons à graver, correspondant au tableau d'ID de jeton.
Renvoie :
  • En cas de succès, message contenant des détails sur les opérations de gravure.
Exemple de valeur renvoyée :
[
    {
        "msg": "Successfully burned NFT token: 'art' from Account-Id: oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6 (Org-Id: appdev, User-Id: idcqa)"
    },
    {
        "msg": "Successfully burned 2 tokens of tokenId: FT from Account-ID oaccount~9a940587fd322ccc8400233244cd3b13f3aa2a52e418e4c71fb819a2217bc49e (Org-Id: AutoF1377358917, User-Id: idcqa)"
    },
    {
        "msg": "Successfully burned 2 token share of tokenId: FNFT from Account-ID oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a (Org-Id: AutoF1377358917, User-Id: idcqa)"
    }
]
BurnNFT
Cette méthode désactive ou brûle le jeton non fongible spécifié et renvoie un objet de jeton et un historique de jeton. Tout utilisateur doté du rôle de brûleur peut appeler cette méthode.
func (t *Controller) BurnNFT(orgId string, userId string, tokenId string) (interface{}, error) {
            tokenAsset, err := t.Ctx.ERC1155Token.Get(tokenId)
            if err != nil {
                  return nil, err
            }
            token := tokenAsset.(map[string]interface{})
            if token[constants.TokenType] != constants.NonFungible {
                  return nil, fmt.Errorf("only nonfungible tokens are allowed")
            }
            if token[constants.IsBurned] == true {
                  return nil, fmt.Errorf("token with tokenId %s is already burned", tokenId)
            }
            tokenQuantity := float64(1)
            tokenUnit := token[constants.TokenUnit]
            tokenHistory, err := t.Ctx.ERC1155Token.History(tokenId)
            if err != nil {
                  return nil, err
            }
            if tokenUnit == constants.Fractional {
                  owners, err := t.Ctx.ERC1155Token.OwnerOf(tokenId)
                  if err != nil {
                        return nil, err
                  }
                  ownersList := owners.([]map[string]interface{})
                  if len(ownersList) != 1 {
                        return nil, fmt.Errorf("NFT has multiple owners, to completely burn this NFT it should have only one owner")
                  }
                  tokenQuantity = token[constants.Quantity].(float64)
            }
            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)
            tokenIds := []string{tokenId}
            tokenQuantities := []float64{tokenQuantity}
            token[constants.IsBurned] = true
            _, err = t.BurnBatch(orgId, userId, tokenIds, tokenQuantities)
            if err != nil {
                  return nil, err
            }
            return token, nil
      }
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion dans l'organisation actuelle.
  • userId: string : nom d'utilisateur ou ID de courriel.
  • tokenId: string : ID du jeton non fongible à graver
Renvoie :
  • En cas de succès, objet de jeton au format JSON qui inclut des informations d'historique de jeton.
Exemple de valeur renvoyée :
{
    "AssetType": "otoken",
    "Behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2023-08-22T13:14:46+05:30",
    "IsBurned": true,
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "On_sale_flag": false,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Price": 120,
    "Quantity": 1,
    "Roles": {
        "minter_role_name": "minter"
    },
    "TokenDesc": "",
    "TokenHistory": "[{\"IsDelete\":\"false\",\"Timestamp\":\"2023-08-22T13:14:46+05:30\",\"TxId\":\"c0ea212f19197c5b86323bfca11c6ca545aa0af5d40cd04f9e955b5371fd40ae\",\"Value\":{\"AssetType\":\"otoken\",\"Behaviors\":[\"indivisible\",\"singleton\",\"mintable\",\"transferable\",\"burnable\",\"roles\"],\"CreatedBy\":\"oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d\",\"CreationDate\":\"2023-08-22T13:14:46+05:30\",\"IsBurned\":false,\"Mintable\":{\"Max_mint_quantity\":20000},\"On_sale_flag\":false,\"Owner\":\"oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d\",\"Price\":120,\"Quantity\":1,\"Roles\":{\"minter_role_name\":\"minter\"},\"TokenDesc\":\"\",\"TokenId\":\"1\",\"TokenMetadata\":{\"Description\":\"\",\"Image\":\"\",\"Painter_name\":\"\",\"Painting_name\":\"\"},\"TokenName\":\"artcollection\",\"TokenStandard\":\"erc1155+\",\"TokenType\":\"nonfungible\",\"TokenUnit\":\"whole\",\"TokenUri\":\"example.com\"}}]",
    "TokenId": 1,
    "TokenMetadata": {
        "Description": "",
        "Image": "",
        "Painter_name": "",
        "Painting_name": ""
    },
    "TokenName": "artcollection",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "example.com"
}

Méthodes SDK

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

CheckAuthorization
Utilisez cette méthode pour ajouter une vérification de contrôle d'accès à une opération. Il s'agit d'une fonction asynchrone. 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 ERC721Admin ou Account Owner du jeton ou par MultipleAccountOwner pour les utilisateurs ayant plusieurs comptes. La méthode CheckAuthorization fait partie de la classe erc721Auth, à laquelle vous accédez via l'objet Ctx. 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.
  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

      var erc1155ad ERC1155AdminAccess
      var erc1155t ERC1155TokenAccess
      var erc1155a ERC1155AccountAccess
      var erc1155as ERC1155AccountStatusAccess
      var erc1155trx ERC1155TransactionAccess
      var erc1155role ERC1155RoleAccess
      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"}

      erc1155ad.AddAdmin = []string{"Admin"}
      erc1155ad.GetAllAdmins = []string{"Admin"}
      erc1155ad.IsUserTokenAdmin = []string{"Admin"}
      erc1155ad.RemoveAdmin = []string{"Admin"}
      erc1155t.AddRoleMember = []string{"Admin"}
      erc1155t.IsInRole = []string{"Admin"}
      erc1155t.GetAllTokens = []string{"Admin"}
      erc1155t.GetAllTokensByUser = []string{"Admin", "AccountOwner"}
      erc1155t.Get = []string{"Admin", "TokenOwner"}
      erc1155t.RemoveRoleMember = []string{"Admin"}
      erc1155t.TotalNetSupply = []string{"Admin"}
      erc1155t.TotalSupply = []string{"Admin"}
      erc1155t.GetTokenDecimal = []string{"Admin"}
      erc1155t.GetTokensByName = []string{"Admin"}
      erc1155t.GetTotalMintedTokens = []string{"Admin"}
      erc1155t.GetNetTokens = []string{"Admin"}
      erc1155t.Save = []string{"Admin"}
      erc1155t.Update = []string{"Admin"}

      erc1155trx.DeleteHistoricalTransactions = []string{"Admin"}

      erc1155role.GetAccountsByRole = []string{"Admin"}
      erc1155role.GetUsersByRole = []string{"Admin"}
      erc1155a.AssociateFungibleTokenToAccount = []string{"Admin", "AccountOwner"}
      erc1155a.BalanceOfBatch = []string{"Admin"}
      erc1155a.CreateAccount = []string{"Admin"}
      erc1155a.CreateTokenAccount = []string{"Admin"}
      erc1155a.CreateUserAccount = []string{"Admin"}
      erc1155a.GetAccountTransactionHistory = []string{"Admin", "AccountOwner"}
      erc1155a.GetAccountTransactionHistoryWithFilters = []string{"Admin", "AccountOwner"}
      erc1155a.GetAccountsByUser = []string{"Admin", "AccountOwner"}
      erc1155a.GetAccount = []string{"Admin", "AccountOwner"}
      erc1155a.History = []string{"Admin", "AccountOwner"}
      erc1155a.GetAllAccounts = []string{"Admin"}
      erc1155a.ExchangeToken = []string{"AccountOwner"}
      erc1155a.GetAccountDetailsByUser = []string{"Admin", "AccountOwner"}

      erc1155as.Get = []string{"Admin", "AccountOwner"}
      erc1155as.ActivateAccount = []string{"Admin"}
      erc1155as.SuspendAccount = []string{"Admin"}
      erc1155as.DeleteAccount = []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
      accessMap.ERC1155Account = erc1155a
      accessMap.ERC1155AccountStatus = erc1155as
      accessMap.ERC1155Admin = erc1155ad
      accessMap.ERC1155Token = erc1155t
      accessMap.ERC1155Transaction = erc1155trx
      accessMap.ERC1155Role = erc1155role
Ctx.ERC1155Auth.CheckAuthorization(funcName string, args []string) (bool, error)
Paramètres :
  • funcName string : valeur de mappage entre les récepteurs et les méthodes, comme décrit dans le fichier oChainUtil.go.
  • args : argument de variable dans lequel args[0] prend la constante 'TOKEN' et args[1] prend le paramètre accountId pour ajouter une vérification de contrôle d'accès pour AccountOwner. Afin d'ajouter une vérification de contrôle d'accès pour MultipleAccountOwner, args[1] prend le paramètre orgId et args[2] prend le paramètre userId. Afin d'ajouter une vérification de contrôle d'accès pour TokenOwner, args[1] prend le paramètre d'ID de jeton.
Renvoie :
  • Réponse d'erreur bool si nécessaire.
IsUserTokenAdmin
Cette méthode renvoie la valeur booléenne true si l'utilisateur indiqué est Token Admin, et false dans le cas contraire. La méthode ne peut être appelée que par un Token Admin du code chaîne de jeton.
Ctx.ERC1155Auth.IsUserTokenAdmin(orgId string, userId string) (interface{}, error)
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId: string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Exemple de valeur renvoyée :
{
  "result": true
}
AddAdmin
Cette méthode ajoute un utilisateur en tant que Token Admin du code chaîne de jeton. La méthode ne peut être appelée que par un Token Admin du code chaîne de jeton.
Ctx.ERC1155Admin.AddAdmin(orgId string, userId string) (interface{}, error)
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId: string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Renvoie :
  • En cas de succès, message qui répertorie les détails de l'utilisateur ajouté en tant que Token Admin du code chaîne de jeton.
Exemple de valeur renvoyée :
{
  "msg": "Successfully added Admin (orgId: appdev, userId: user1)"
}
RemoveAdmin
Cette méthode enlève un utilisateur en tant que Token Admin du code chaîne de jeton. La méthode ne peut être appelée que par un Token Admin du code chaîne de jeton. Vous ne pouvez pas vous enlever en tant que Token Admin.
Ctx.ERC1155Admin.RemoveAdmin(orgId string, userId string) (interface{}, error)
Paramètres :
  • orgId: string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId: string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Renvoie :
  • En cas de succès, message répertoriant les détails de l'utilisateur enlevé en tant que Token Admin du code chaîne de jeton.
Exemple de valeur renvoyée :
{
    "msg": "Successfully removed Admin (orgId appdev userId user1)"
}
GetAllAdminUsers
Cette méthode renvoie la liste de tous les utilisateurs Token Admin.
Ctx.ERC1155Admin.GetAllAdminUsers() (interface{}, error)
Paramètres :
  • Aucun élément
Renvoie :
  • En cas de succès, liste de tous les utilisateurs Token Admin, identifiés par ID d'organisation et ID d'utilisateur.
Exemple de valeur renvoyée :
{
  "admins": [
    {
      "OrgId": "appdev",
      "UserId": "idcqa"
    },
    {
      "OrgId": "appdev",
      "UserId": "user1"
    }
  ]
}

Méthodes de gestion de la configuration des jetons

Save
Cette méthode crée des jetons. Chaque jeton défini possède sa propre méthode de création. Pour les jetons non fongibles, si le rôle de minter est défini dans le fichier de spécification, tout utilisateur doté du rôle de minter peut appeler cette méthode pour créer un NFT. Sinon, n'importe quel utilisateur peut utiliser cette méthode pour créer (mentalement) des NFT. L'utilisateur qui appelle cette méthode devient propriétaire du NFT (entier ou fractionnaire).
Ctx.ERC1155Token.Save(token interface{}, quantity ...float64) (interface{}, error)
Paramètres :
  • tokenAsset: interface{} : ressource de jeton. Les propriétés de la ressource sont définies dans le fichier de modèle.
  • quantity: number : pour les jetons non fongibles uniquement, nombre de jetons à menthe. La seule valeur prise en charge pour ce paramètre est 1.
Renvoie :
  • En cas de succès, la ressource de jeton au format JSON, qui inclut les informations suivantes.
  • Behavior ou Behaviors : liste des comportements de jeton. Cette propriété ne peut pas être modifiée.
  • CreatedBy : ID de compte de l'appelant, qui est l'utilisateur qui frappe le jeton. Cette propriété ne peut pas être modifiée.
  • CreationDate : horodatage de la transaction de frappe. Cette propriété ne peut pas être modifiée.
  • IsBurned : cette propriété indique si le jeton est gravé. Cette propriété ne peut pas être modifiée.
  • Mintable : propriétés liées à la frappe. La valeur max_mint_quantity définit le nombre maximal de jetons pouvant être créés pour la classe de jeton.
  • Owner : ID de compte du propriétaire actuel, qui est l'appelant de la méthode.
  • Symbol : symbole du jeton. Cette propriété ne peut pas être modifiée.
  • TokenDesc : description du jeton.
  • TokenMetadata : informations JSON décrivant le jeton.
  • TokenName : nom du jeton. Cette propriété ne peut pas être modifiée.
  • TokenStandard : norme du jeton. Cette propriété ne peut pas être modifiée.
  • TokenType : type du jeton (fongible ou non). Cette propriété ne peut pas être modifiée.
  • TokenUnit : unité du jeton (entière ou fractionnaire). Cette propriété ne peut pas être modifiée.
  • TokenUri : URI du jeton.
  • Quantity : quantité du jeton.
Exemple de valeur renvoyée (NFT entier) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2022-12-29T09:57:03+05:30",
    "IsBurned": false,
    "Mintable": {
        "Max_mint_quantity": 500
    },
    "OnSaleFlag": false,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Price": 100,
    "Quantity": 1,
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "token description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "artcollection",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
}
Exemple de valeur de retour (jeton fongible) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "Currency_name": "Dollar",
    "Divisible": {
        "Decimal": 2
    },
    "Mintable": {
        "Max_mint_quantity": 10000
    },
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "Token Description",
    "TokenId": "Loyalty",
    "TokenName": "loyalty",
    "TokenStandard": "erc1155+",
    "TokenType": "fungible",
    "TokenUnit": "fractional",
    "Token_to_currency_ratio": 0
}
Exemple de valeur de retour (NFT fractionnaire) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2023-06-14T09:53:53+05:30",
    "Divisible": {
        "Decimal": 2
    },
    "IsBurned": false,
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "On_sale_flag": false,
    "Price": 1000,
    "Quantity": 100,
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "Token Description",
    "TokenId": "realEstate",
    "TokenMetadata": {
        "Description": "Painting Description",
        "Image": "",
        "Painter_name": "",
        "Painting_name": "Paint"
    },
    "TokenName": "realestate",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "fractional",
    "TokenUri": "www.realestate.example.com"
}
Update
Cette méthode met à jour les jetons. Vous ne pouvez pas mettre à jour les métadonnées de jeton ou l'URI de jeton de jetons non fongibles.
Ctx.ERC1155Token.Update(tokenAsset interface{}) (interface{}, error)
Paramètres :
  • tokenAsset: interface{} : ressource de jeton. Les propriétés de la ressource sont définies dans le fichier de modèle.
Renvoie :
  • En cas de succès, la ressource de jeton mise à jour au format JSON.
Exemple de valeur renvoyée (NFT entier) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2022-12-29T09:57:03+05:30",
    "IsBurned": false,
    "Mintable": {
        "Max_mint_quantity": 500
    },
    "OnSaleFlag": false,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Price": 100,
    "Quantity": 1,
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "token description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "artcollection",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"
}
History (Token)
Cette méthode renvoie l'historique d'un ID de jeton spécifié.
Ctx.ERC1155Token.History(tokenId string) (interface{}, error)
Paramètres :
  • tokenId string : ID du jeton.
Renvoie :
  • En cas de succès, tableau JSON contenant l'historique des jetons.
Exemple de valeur de retour (jeton fongible) :
[
  {
    "IsDelete": "false",
    "Timestamp": "2022-12-08T09:54:11Z",
    "TxId": "823sa7c7a00941c62285c86f922bc4d3f5326a20f4bf2f82daa5bc661e4682e8",
    "Value": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "Rupees",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "Updated Token Description",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "IsDelete": "false",
    "Timestamp": "2022-12-08T09:54:11Z",
    "TxId": "711bb7c7a00941c62285c86f922bc3b3f5326a20f4bf2f82daa5bc661e4682e8",
    "Value": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "Dollar",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  }
]
Exemple de valeur de retour (NFT fractionnaire) :
[
    {
        "Timestamp": "2023-06-20T01:06:33Z",
        "TrxId": "16e53db4f8107f9634b7c3a0a2a81a00f69b634f2a52902b809e544d07f272b1",
        "Value": {
            "AssetType": "otoken",
            "Behaviors": [
                "divisible",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "CreationDate": "2023-06-20T01:02:27Z",
            "Divisible": {
                "Decimal": 2
            },
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "On_sale_flag": true,
            "Owners": [
                {
                    "AccountId": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
                    "TokenShare": 10
                },
                {
                    "AccountId": "oaccount~3cddfdaa855900579d963aa6f755a4aed1f3a474a2462c1b45bd7f36df673224",
                    "TokenShare": 10
                }
            ],
            "Price": 2000,
            "Quantity": 20,
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "TokenDesc": "",
            "TokenId": "FNFT",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "Painter_name": "",
                "Painting_name": ""
            },
            "TokenName": "realestate",
            "TokenStandard": "erc1155+",
            "TokenType": "nonfungible",
            "TokenUnit": "fractional",
            "TokenUri": "www.FNFT.example.com"
        }
    },
    {
        "Timestamp": "2023-06-20T01:02:27Z",
        "TrxId": "cec80910d087682554048f911d2cf98b66382bbcf1615483fa1c96c7ea08077c",
        "Value": {
            "AssetType": "otoken",
            "Behaviors": [
                "divisible",
                "mintable",
                "transferable",
                "burnable",
                "roles"
            ],
            "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "CreationDate": "2023-06-20T01:02:27Z",
            "Divisible": {
                "Decimal": 2
            },
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "On_sale_flag": true,
            "Owners": [
                {
                    "AccountId": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
                    "TokenShare": 20
                }
            ],
            "Price": 2000,
            "Quantity": 20,
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "TokenDesc": "",
            "TokenId": "FNFT",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "Painter_name": "",
                "Painting_name": ""
            },
            "TokenName": "realestate",
            "TokenStandard": "erc1155+",
            "TokenType": "nonfungible",
            "TokenUnit": "fractional",
            "TokenUri": "www.FNFT.example.com"
        }
    }
]
Exemple de valeur renvoyée (NFT entier) :
[
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-20T01:15:56Z",
        "TxId": "89a3df3ebbe6dca2bcfbd51fc7dca9aab818a2af746b79a92dc8155b729ab22d",
        "Value": {
            "AssetType": "otoken",
            "Behaviors": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "roles"
            ],
            "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "CreationDate": "2023-06-20T01:15:56Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "On_sale_flag": true,
            "Owner": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "Price": 2000,
            "Quantity": 1,
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "TokenDesc": "Updated Token Description",
            "TokenId": "NFT",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "Painter_name": "",
                "Painting_name": ""
            },
            "TokenName": "artcollection",
            "TokenStandard": "erc1155+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "www.NFT.example.com"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-20T01:15:56Z",
        "TxId": "90d6af3ebbe6dca2bcfbd51fc7dca9aab818a2af746b79a92dc8155b729ab22d",
        "Value": {
            "AssetType": "otoken",
            "Behaviors": [
                "indivisible",
                "singleton",
                "mintable",
                "transferable",
                "roles"
            ],
            "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "CreationDate": "2023-06-20T01:15:56Z",
            "IsBurned": false,
            "Mintable": {
                "Max_mint_quantity": 20000
            },
            "On_sale_flag": true,
            "Owner": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
            "Price": 2000,
            "Quantity": 1,
            "Roles": {
                "burner_role_name": "burner",
                "minter_role_name": "minter"
            },
            "TokenDesc": "",
            "TokenId": "NFT",
            "TokenMetadata": {
                "Description": "",
                "Image": "",
                "Painter_name": "",
                "Painting_name": ""
            },
            "TokenName": "artcollection",
            "TokenStandard": "erc1155+",
            "TokenType": "nonfungible",
            "TokenUnit": "whole",
            "TokenUri": "www.NFT.example.com"
        }
    }
]
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 Token Admin du code chaîne. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.
Ctx.ERC1155Token.GetAllTokens()() (interface{}, error)
Paramètres :
  • Aucun élément
Exemple de valeur renvoyée :
[
  {
    "key": "tokenOne",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "key": "tokenTwo",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenTwo",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "key": "art",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
      ],
      "BurnedBy": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
      "BurnedDate": "2022-12-08T10:49:37Z",
      "CreatedBy": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
      "CreationDate": "2022-12-08T10:45:10Z",
      "IsBurned": true,
      "Mintable": {
        "Max_mint_quantity": 20000
      },
      "OnSaleFlag": false,
      "Owner": "",
      "Price": 0,
      "Roles": {
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "art",
      "TokenMetadata": {
        "Description": "",
        "Image": "",
        "PainterName": "",
        "PaintingName": ""
      },
      "TokenName": "artcollection",
      "TokenStandard": "erc1155+",
      "TokenType": "nonfungible",
      "TokenUnit": "whole",
      "TokenUri": "art.example.com",
      "TransferredBy": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
      "TransferredDate": "2022-12-08T10:47:04Z"
    }
  },
  {
    "key": "FNFT",
    "valueJson": {
        "AssetType": "otoken",
        "Behaviors": [
            "divisible",
            "mintable",
            "transferable",
            "burnable",
            "roles"
        ],
        "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
        "CreationDate": "2023-06-20T01:02:27Z",
        "Divisible": {
            "Decimal": 2
        },
        "IsBurned": false,
        "Mintable": {
            "Max_mint_quantity": 20000
        },
        "On_sale_flag": true,
        "Price": 2000,
        "Quantity": 20,
        "Roles": {
            "burner_role_name": "burner",
            "minter_role_name": "minter"
        },
        "TokenDesc": "",
        "TokenId": "FNFT",
        "TokenMetadata": {
            "Description": "",
            "Image": "",
            "Painter_name": "",
            "Painting_name": ""
        },
        "TokenName": "realestate",
        "TokenStandard": "erc1155+",
        "TokenType": "nonfungible",
        "TokenUnit": "fractional",
        "TokenUri": "www.FNFT.example.com"
    }
  },
  {
    "key": "FNFT",
    "valueJson": {
        "AssetType": "otoken",
        "Behaviors": [
            "divisible",
            "mintable",
            "transferable",
            "burnable",
            "roles"
        ],
        "CreatedBy": "oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a",
        "CreationDate": "2023-06-20T01:02:27Z",
        "Divisible": {
            "Decimal": 2
        },
        "IsBurned": false,
        "Mintable": {
            "Max_mint_quantity": 20000
        },
        "On_sale_flag": true,
        "Price": 2000,
        "Quantity": 20,
        "Roles": {
            "burner_role_name": "burner",
            "minter_role_name": "minter"
        },
        "TokenDesc": "",
        "TokenId": "FNFT",
        "TokenMetadata": {
            "Description": "",
            "Image": "",
            "Painter_name": "",
            "Painting_name": ""
        },
        "TokenName": "realestate",
        "TokenStandard": "erc1155+",
        "TokenType": "nonfungible",
        "TokenUnit": "fractional",
        "TokenUri": "www.FNFT.example.com"
    }
  }
]
Get (Token)
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 peut uniquement être appelée par Token Admin du code chaîne ou par le propriétaire du jeton. Pour les NFT fractionnaires, la liste des propriétaires est également renvoyée.
Ctx.ERC1155Token.Get(id string, result ...interface{}) (interface{}, error)
Paramètres :
  • id string : ID du jeton à obtenir.
Exemple de valeur renvoyée (NFT entier) :
{
  "AssetType": "otoken",
  "Behaviors": [
    "indivisible",
    "singleton",
    "mintable",
    "transferable",
    "burnable",
    "roles"
  ],
  "CreatedBy": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
  "CreationDate": "2022-12-08T10:55:29Z",
  "IsBurned": false,
  "Mintable": {
    "Max_mint_quantity": 20000
  },
  "OnSaleFlag": false,
  "Owner": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
  "Price": 0,
  "Quantity": 1,
  "Roles": {
    "minter_role_name": "minter"
  },
  "TokenDesc": "",
  "TokenId": "nftToken",
  "TokenMetadata": {
    "Description": "",
    "Image": "",
    "PainterName": "",
    "PaintingName": ""
  },
  "TokenName": "artcollection",
  "TokenStandard": "erc1155+",
  "TokenType": "nonfungible",
  "TokenUnit": "whole",
  "TokenUri": "example.com"
}
Exemple de valeur de retour (jeton fongible) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "Currency_name": "Dollar",
    "Divisible": {
        "Decimal": 2
    },
    "Mintable": {
        "Max_mint_quantity": 10000
    },
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "Token Description",
    "TokenId": "Loyalty",
    "TokenName": "loyalty",
    "TokenStandard": "erc1155+",
    "TokenType": "fungible",
    "TokenUnit": "fractional",
    "Token_to_currency_ratio": 0
}
Exemple de valeur de retour (NFT fractionnaire) :
{
    "AssetType": "otoken",
    "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "CreationDate": "2023-06-14T09:53:53+05:30",
    "Divisible": {
        "Decimal": 2
    },
    "IsBurned": false,
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "On_sale_flag": false,
    "Owners": [
        {
            "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
            "TokenShare": 100
        }
    ],
    "Price": 1000,
    "Quantity": 100,
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "TokenDesc": "Token Description",
    "TokenId": "realEstate",
    "TokenMetadata": {
        "Description": "Painting Description",
        "Image": "",
        "Painter_name": "",
        "Painting_name": "Paint"
    },
    "TokenName": "realestate",
    "TokenStandard": "erc1155+",
    "TokenType": "nonfungible",
    "TokenUnit": "fractional",
    "TokenUri": "www.realestate.example.com"
}
GetAllTokensByUser
Cette méthode renvoie toutes les ressources de jeton appartenant à un utilisateur spécifié. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.
Ctx.ERC1155Token.GetAllTokensByUser(accountId string) (interface{}, error)
Paramètres :
  • accountId string : ID de compte de l'utilisateur.
Exemple de valeur renvoyée :
[
  {
    "key": "tokenOne",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "key": "nftToken",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
      ],
      "CreatedBy": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
      "CreationDate": "2022-12-08T10:55:29Z",
      "IsBurned": false,
      "Mintable": {
        "Max_mint_quantity": 20000
      },
      "OnSaleFlag": false,
      "Owner": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
      "Price": 0,
      "Quantity": 1,
      "Roles": {
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "nftToken",
      "TokenMetadata": {
        "Description": "",
        "Image": "",
        "PainterName": "",
        "PaintingName": ""
      },
      "TokenName": "artcollection",
      "TokenStandard": "erc1155+",
      "TokenType": "nonfungible",
      "TokenUnit": "whole",
      "TokenUri": "example.com"
    }
  }
]
OwnerOf
Cette méthode renvoie l'ID de compte, l'ID d'organisation et l'ID utilisateur du propriétaire de l'ID de jeton spécifié.
Ctx.ERC1155Token.OwnerOf(tokenId string) (interface{}, error)
Paramètres :
  • tokenId string : ID du jeton.
Exemple de valeur renvoyée :
{
  "AccountId": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
  "OrgId": "appdev",
  "UserId": "idcqa"
}
TokenURI
Cette méthode renvoie l'URI d'un jeton spécifié. N'importe qui peut appeler cette méthode.
Ctx.ERC1155Token.TokenURI(tokenId string) (interface{}, error)
Paramètres :
  • tokenId string : ID du jeton.
Exemple de valeur renvoyée :
{
    "TokenUri": "example.com"
}
Name
Cette méthode renvoie le nom de la classe de jeton. N'importe qui peut appeler cette méthode.
Ctx.ERC1155Token.Name(tokenId string) (interface{}, error)
Paramètres :
  • tokenId string : ID du jeton.
Exemple de valeur renvoyée :
{"TokenName": "artcollection"}
TotalSupply
Cette méthode renvoie le nombre total de jetons frappés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton.
Ctx.ERC1155Token.TotalSupply(tokenAsset interface{}) (map[string]interface{}, error)
Paramètres :
  • tokenAsset interface{} : ressource de jeton.
Exemple de valeur renvoyée :
{"TotalSupply": 100}
TotalNetSupply
Cette méthode renvoie le nombre total de jetons frappés moins le nombre de jetons brûlés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton.
Ctx.ERC1155Token.TotalNetSupply(token interface{}) (interface{}, error)
Paramètres :
  • token interface{} : ressource de jeton.
Exemple de valeur renvoyée :
{"TotalNetSupply": 100}
GetTokensByName
Cette méthode renvoie toutes les ressources de jeton pour un nom de jeton spécifié. Cette méthode utilise des requêtes Berkeley DB SQL riches et ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.
Ctx.ERC1155Token.GetTokensByName(tokenName string) (interface{}, error)
Paramètres :
  • tokenName: string : nom du jeton.
Exemple de valeur renvoyée :
[
  {
    "key": "tokenOne",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenOne",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  },
  {
    "key": "tokenTwo",
    "valueJson": {
      "AssetType": "otoken",
      "Behaviors": [
        "divisible",
        "mintable",
        "transferable",
        "roles"
      ],
      "Currency_name": "",
      "Divisible": {
        "Decimal": 2
      },
      "Mintable": {
        "Max_mint_quantity": 1000
      },
      "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
      },
      "TokenDesc": "",
      "TokenId": "tokenTwo",
      "TokenName": "moneytok",
      "TokenStandard": "erc1155+",
      "TokenType": "fungible",
      "TokenUnit": "fractional",
      "Token_to_currency_ratio": 0
    }
  }
]
GetDecimals
Cette méthode renvoie le nombre de décimales pour un jeton spécifié. Si le comportement divisible n'est pas spécifié pour le jeton, la valeur par défaut de zéro décimale est renvoyée.
Ctx.ERC1155Token.GetDecimals(tokenId string) (int, error)
Paramètres :
  • tokenId: string : ID du jeton.
Exemple de valeur renvoyée :
2

Méthodes de gestion des comptes

CreateAccount
Cette méthode crée un compte pour un utilisateur spécifié et les comptes de jetons associés pour les jetons fongibles ou non fongibles. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Le compte utilisateur assure le suivi du compte NFT et des comptes de jetons fongibles dont dispose un utilisateur. Les utilisateurs doivent disposer de comptes sur le réseau pour effectuer les opérations liées aux jetons. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.

Un compte utilisateur possède un ID unique, formé par un hachage SHA-256 du paramètre orgId et du paramètre userId.

Un utilisateur peut avoir plusieurs comptes de jeton fongibles avec des ID de compte uniques. Les ID de compte de jeton fongibles sont formés par un hachage SHA-256 du paramètre orgId, le paramètre userId, la chaîne constante ft séparée par le symbole tilde (~) et un nombre de compteur qui signifie l'index du compte fongible créé séparé par le symbole tilde (~).

Un utilisateur ne peut avoir qu'un seul compte de jeton non fongible. Les ID de compte de jeton non fongibles sont uniques et sont formés par un hachage SHA-256 du paramètre orgId, du paramètre userId et de la chaîne constante nft séparés par le symbole tilde (~). Tous les jetons non fongibles qu'un utilisateur possède, qu'ils soient entiers ou fractionnaires, sont liés à ce compte unique non fongible.

Ctx.ERC1155Account.CreateAccount(orgId string, userId string, ftAccount bool, nftAccount bool) (ERC1155UserAccount, error)
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • ftAccount bool : si la valeur est True, un compte de jeton fongible est créé et associé au compte utilisateur.
  • nftAccount bool : si la valeur est True, un compte de jeton non fongible est créé et associé au compte utilisateur.
Renvoie :
  • En cas de succès, objet JSON du compte créé.
Exemple de valeur renvoyée :
{
  "AssetType": "ouaccount",
  "AccountId": "ouaccount~cf20877546f52687f387e7c91d88b9722c97e1a456cc0484f40c747f7804feae",
  "UserId": "user1",
  "OrgId": "appdev",
  "TotalAccounts": 2,
  "TotalFtAccounts": 1,
  "AssociatedFtAccounts": [
    {
      "AccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
      "TokenId": ""
    }
  ],
  "AssociatedNftAccount": "oaccount~73c3e835dac6d0a56ca9d8def08269f83cefd59b9d297fe2cdc5a9083828fa58"
}
CreateUserAccount
Cette méthode crée un compte pour un utilisateur spécifié. Un compte doit être créé pour tout utilisateur qui aura des jetons à tout moment. Le compte utilisateur assure le suivi du compte NFT et des comptes de jetons fongibles dont dispose un utilisateur. Les utilisateurs doivent disposer de comptes sur le réseau pour effectuer les opérations liées aux jetons.

Un ID de compte est un hachage SHA-256 du paramètre orgId et du paramètre userId. Cette méthode ne peut être appelée que par un Token Admin du code chaîne.

Ctx.ERC1155Account.CreateUserAccount(orgId string, userId string) (interface{}, error)
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Renvoie :
  • En cas de succès, objet JSON du compte utilisateur créé.
Exemple de valeur renvoyée :
{
  "AssetType": "ouaccount",
  "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
  "UserId": "idcqa",
  "OrgId": "appdev",
  "TotalAccounts": 0,
  "TotalFtAccounts": 0,
  "AssociatedFtAccounts": [],
  "AssociatedNftAccount": ""
}
CreateTokenAccount
Cette méthode crée un compte de jeton fongible ou non fongible à associer à un compte utilisateur.

Un utilisateur peut avoir plusieurs comptes de jeton fongibles avec des ID de compte uniques. Les ID de compte de jeton fongibles sont formés par un hachage SHA-256 du paramètre orgId, le paramètre userId, la chaîne constante ft séparée par le symbole tilde (~) et un nombre de compteur qui signifie l'index du compte fongible créé séparé par le symbole tilde (~).

Un utilisateur ne peut avoir qu'un seul compte de jeton non fongible. Les ID de compte de jeton non fongibles sont uniques et sont formés par un hachage SHA-256 du paramètre orgId, du paramètre userId et de la chaîne constante nft séparés par le symbole tilde (~). Tous les jetons non fongibles qu'un utilisateur possède, qu'ils soient entiers ou fractionnaires, sont liés à ce compte unique non fongible.

Cette méthode ne peut être appelée que par un Token Admin du code chaîne.

Ctx.ERC1155Account.CreateTokenAccount(orgId string, userId string, tokenType string) (ERC1155UserAccount, error)
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
  • tokenType erc1155Token.TokenType : type de compte de jeton à créer. Les seuls types de jeton pris en charge sont nonfungible et fungible.
Renvoie :
  • En cas de succès, objet JSON du compte de jeton créé.
Exemple de valeur renvoyée :
{
    "AssetType": "ouaccount",
    "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "TotalAccounts": 1,
    "TotalFtAccounts": 1,
    "AssociatedFtAccounts": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "TokenId": ""
        }
    ],
    "AssociatedNftAccount": ""
}
AssociateTokenToToken
Cette méthode associe le compte de jeton fongible d'un utilisateur à un jeton fongible particulier.
Ctx.ERC1155Account.AssociateTokenToToken(accountId string, tokenId string) (interface{}, error)
Paramètres :
  • accountId string : ID de compte utilisateur.
  • tokenId string : ID du jeton.
Renvoie :
  • En cas de succès, un objet JSON du compte utilisateur, qui indique que le jeton fongible a été associé au compte de jeton. Par exemple, dans l'exemple suivant, le premier objet du tableau AssociatedFtAccounts indique que l'ID de compte de jeton fongible et l'ID de jeton sont associés.
Exemple de valeur renvoyée :
{
    "AssetType": "ouaccount",
    "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "TotalAccounts": 1,
    "TotalFtAccounts": 1,
    "AssociatedFtAccounts": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "TokenId": "tokenOne"
        }
    ],
    "AssociatedNftAccount": ""
}
GetAccountHistory
Cette méthode renvoie l'historique d'un compte de jeton spécifié.
Ctx.ERC1155Account.GetAccountHistory(accountId string)
Paramètres :
  • accountId string : ID du compte de jeton.
Renvoie :
  • En cas de succès, tableau d'objets JSON qui décrit l'historique des comptes.
Exemple de valeur renvoyée :
[
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-06T11:03:48Z",
        "TxId": "c5180f3be3d9130f25a4b4e866f38a4283117dcbfbffb4f55e2c5b03dba0dd29",
        "Value": {
            "AccountCategory": "",
            "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
            "AssetType": "oaccount",
            "Balance": 100,
            "BapAccountVersion": 1
            "OrgId": "appdev",
            "TokenId": "loy1",
            "TokenName": "loyalty",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-06T11:02:39Z",
        "TxId": "6f81b0c94b451d375a3892446aefbdf78d9fd1ac43699daa89f0dff10db5fd22",
        "Value": {
            "AccountCategory": "",
            "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
            "AssetType": "oaccount",
            "Balance": 0,
            "BapAccountVersion": 0
            "OrgId": "appdev",
            "TokenId": "loy1",
            "TokenName": "loyalty",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    },
    {
        "IsDelete": "false",
        "Timestamp": "2023-06-05T16:28:46Z",
        "TxId": "8185af648546e909488e72149be497b210f74f95ada252c42da9c35cb9d98691",
        "Value": {
            "AccountCategory": "",
            "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
            "AssetType": "oaccount",
            "Balance": 0,
            "BapAccountVersion": 0
            "OrgId": "appdev",
            "TokenId": "",
            "TokenName": "",
            "TokenType": "fungible",
            "UserId": "idcqa"
        }
    }
]
GetAccountWithStatus
Cette méthode renvoie les détails du compte de jeton pour un utilisateur spécifié, y compris le statut du compte. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par Account Owner du compte.
Ctx.ERC1155Account.GetAccountWithStatus(userAccountId string, tokenId ...string) (interface{}, error)
Paramètres :
  • userAccountId string : ID de compte de l'utilisateur.
  • tokenId ...string : pour un compte de jeton non fongible, une chaîne vide. Pour un compte de jeton fongible, ID de jeton.
Renvoie :
  • En cas de succès, objet JSON qui inclut les détails du compte de jeton, y compris le statut du compte.
Exemple de valeur de retour (compte de jeton non fongible) :
{
    "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
    "AssetType": "oaccount",
    "BapAccountVersion": 1,
    "NoOfNfts": 1,
    "OrgId": "appdev",
    "Status": "active",
    "TokenType": "nonfungible",
    "UserId": "idcqa"
}
Exemple de valeur de retour (compte de jeton fongible) :
{
    "AccountCategory": "",
    "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
    "AssetType": "oaccount",
    "Balance": 0,
    "BapAccountVersion": 0,
    "OrgId": "appdev",
    "Status": "active",
    "TokenId": "t1",
    "TokenName": "loyalty",
    "TokenType": "fungible",
    "UserId": "idcqa"
}
GetAccount
Cette méthode renvoie les détails du compte de jeton pour un utilisateur spécifié. Cette méthode peut uniquement être appelée par Token Admin du code chaîne ou par Account Owner du compte.
Ctx.ERC1155Account.Get(accountId string, tokenId ...string) (interface{}, error) 
Paramètres :
  • userAccountId string : ID de compte de l'utilisateur.
  • tokenId ...string : pour un compte de jeton non fongible, une chaîne vide. Pour un compte de jeton fongible, ID de jeton.
Renvoie :
  • En cas de succès, objet JSON qui inclut les détails du compte de jeton.
Exemple de valeur de retour (compte de jeton non fongible) :
{
    "AccountId": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
    "BapAccountVersion": 0,
    "AssetType": "oaccount",
    "NoOfNfts": 4,
    "OrgId": "appdev",
    "TokenType": "nonfungible",
    "UserId": "idcqa"
}
Exemple de valeur de retour (compte de jeton fongible) :
{
    "AssetType": "oaccount",
    "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "BapAccountVersion": 0,
    "TokenType": "fungible",
    "TokenId": "loy1",
    "TokenName": "loyalty",
    "Balance": 90,
    "AccountCategory": ""
}
GetAllAccounts
Cette méthode renvoie les détails de tous les comptes utilisateur.
Ctx.ERC1155Account.GetAllAccounts() (interface{}, error)
Paramètres :
  • Aucun élément
Exemple de valeur renvoyée :
[
    {
        "AssetType": "ouaccount",
        "AccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38",
        "UserId": "idcqa",
        "OrgId": "appdev",
        "TotalAccounts": 3,
        "TotalFtAccounts": 2,
        "AssociatedFtAccounts": [
            {
                "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
                "TokenId": "loy1"
            },
            {
                "AccountId": "oaccount~58c5a6b09a41befca2a9ea2550439838c4dcf4d8a2a4f7c98e9319cf8479bfc4",
                "TokenId": ""
            }
        ],
        "AssociatedNftAccount": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371"
    },
    {
        "AssetType": "ouaccount",
        "AccountId": "ouaccount~9501bb774c156eb8354dfe489250ea91f757523d70f08ee494bda98bb352003b",
        "UserId": "user1_minter",
        "OrgId": "appdev",
        "TotalAccounts": 2,
        "TotalFtAccounts": 1,
        "AssociatedFtAccounts": [
            {
                "AccountId": "oaccount~1089ee5122f367ee0ca38c6660298f4b81f199627e4f67f3691c0f628237974c",
                "TokenId": "loy1"
            }
        ],
        "AssociatedNftAccount": "oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446"
    },
]
GetAccountDetailsByUser
Cette méthode renvoie un récapitulatif de compte pour un utilisateur spécifié et les détails des jetons fongibles et non fongibles associés à l'utilisateur.
Ctx.ERC1155Account.GetAccountDetailsByUser(orgId string, userId string) (interface{}, error)
Paramètres :
  • orgId string : ID du fournisseur de services d'adhésion de l'utilisateur dans l'organisation actuelle.
  • userId string : nom d'utilisateur ou adresse électronique de l'utilisateur.
Renvoie :
  • En cas de succès, objet de compte JSON qui inclut et résume le compte pour l'utilisateur spécifié et les détails des jetons fongibles et non fongibles associés à l'utilisateur. Pour les jetons non fongibles fractionnaires, la propriété tokenShare de la section associatedNFTs affiche le partage dont l'utilisateur est propriétaire.
Exemple de valeur renvoyée :
{
    "AssociatedFTAccounts": [
        {
            "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
            "Balance": 90,
            "TokenId": "FT"
        },
    ],
    "AssociatedNFTAccount": {
        "AccountId": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
        "AssociatedNFTs": [
            {
                "NFTTokenId": "FNFT",
                "TokenShare": 230
            },
            {
                "NFTTokenId": "NFT"
            },
            {
                "NFTTokenId": "NFT2"
            }
        ]
    },
    "UserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
}
GetUserByAccountId
Cette méthode renvoie les détails utilisateur d'un ID de compte spécifié.
Ctx.ERC1155Account.GetUserByAccountById(accountId string) (map[string]interface{}, error)
Paramètres :
  • accountId string – ID du compte.
Renvoie :
  • En cas de succès, objet JSON des détails de l'utilisateur (orgId et userId).
Exemple de valeur renvoyée :
{
    "OrgId": "appdev",
    "UserId": "idcqa"
}

Méthodes de gestion des rôles

AddRoleMember
Cette méthode ajoute un rôle à un utilisateur et un jeton spécifiés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton.
Ctx.ERC1155Token.AddRoleMember(userRole string, userAccountId string, asset interface{}) (interface{}, error)
Paramètres :
  • userRole: string : nom du rôle à ajouter à l'utilisateur spécifié.
  • userAccountId: string : ID de compte de l'utilisateur.
  • asset: interface{} : ressource de jeton.
Renvoie :
  • En cas de succès, message avec les détails du compte.
Exemple de valeur renvoyée :
{
    "msg": "Successfully added role minter to oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a (orgId : appdev, userId : idcqa)"
}
IsInRole
Cette méthode renvoie une valeur booléenne pour indiquer si un utilisateur a un rôle spécifié. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton.
Ctx.ERC1155Token.IsInRole(userRole string, userAccountId string, asset interface{}) (bool, error)
Paramètres :
  • userRole: string : nom du rôle à rechercher.
  • userAccountId: string : ID de compte de l'utilisateur.
  • asset: interface{} : ressource de jeton.
Exemple de valeur renvoyée :
{
    "result": true
}
RemoveRoleMember
Cette méthode supprime un rôle d'un utilisateur et d'un jeton spécifiés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton.
Ctx.ERC1155Token.RemoveRoleMember(userRole string, userAccountId string, asset interface{}) (interface{}, error) 
Paramètres :
  • userRole: string : nom du rôle à supprimer.
  • userAccountId: string : ID de compte de l'utilisateur.
  • asset: interface{} : ressource de jeton.
Exemple de valeur renvoyée :
{
    "msg": "Successfully removed role 'minter' from Account Id: oaccount~ec7e4de2f81e3ea071710e07b6ff7d9346e84ef665ca4650885dbe8c3e2bd4c0 (Org-Id: appdev, User-Id: idcqa)"
}
GetAccountsByRole
Cette méthode renvoie la liste de tous les ID de compte pour un rôle et un jeton spécifiés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton.
Ctx.ERC1155Role.GetAccountsByRole(roleName string, token interface{}) (interface{}, error)
Paramètres :
  • roleName: string : nom du rôle à rechercher.
  • token: interface{} : ressource de jeton.
Exemple de valeur renvoyée :
{
    "accounts": [
        "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
        "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b"
    ]
}
GetUsersByRole
Cette méthode renvoie la liste de tous les utilisateurs pour un rôle et un jeton spécifiés. Les jetons fongibles sont spécifiés par l'ID de jeton. Les jetons non fongibles sont spécifiés par le nom du jeton.
Ctx.ERC1155Role.GetUsersByRole(roleName string, token interface{}) (interface{}, error)
Paramètres :
  • roleName: string : nom du rôle à rechercher.
  • token: interface{} : ressource de jeton.
Exemple de valeur renvoyée :
{
    "Users": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "OrgId": "appdev",
            "UserId": "idcqa"
        },
        {
            "AccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
            "OrgId": "appdev",
            "UserId": "user1"
        }
    ]
}

Méthodes de gestion de l'historique des transactions

GetAccountTransactionHistory
Cette méthode renvoie l'historique des transactions de compte. Cette méthode peut être appelée uniquement par un élément Token Admin du code chaîne ou par le propriétaire du compte. Pour les jetons non fongibles, cette méthode ne peut être appelée que lorsqu'elle est connectée au réseau Oracle Blockchain Platform distant.
Ctx.ERC1155Account.GetAccountTransactionHistory(tokenAccountId string) (interface{}, error)
Paramètres :
  • accountId string : ID de compte utilisateur.
Exemple de valeur renvoyée :
[
    {
        "Balance": 90,
        "Timestamp": "2023-06-06T11:11:09Z",
        "TokenId": "FNFT",
        "TransactedAccount": "oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446",
        "TransactedAmount": 10,
        "TransactionId": "otransaction~0f4d96fbf8fed88ea8a3133428977721091467c701848d595ebc3fffa88b3657~7c88c736df38d5622512f1e8dcdd50710eb47c953f1ecb24ac44790a9e2f475b",
        "TransactionType": "DEBIT",
        "TriggeredByUserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
    },
    {
        "Timestamp": "2023-06-06T11:11:09Z",
        "TokenId": "NFT",
        "TransactedAccount": "oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446",
        "TransactionId": "otransaction~0f4d96fbf8fed88ea8a3133428977721091467c701848d595ebc3fffa88b3657~178e3730bc5bee50d02f1464a4eebf733a051905f651e5789039adb4a3edc114",
        "TransactionType": "DEBIT",
        "TriggeredByUserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
    },
    {
        "Timestamp": "2023-06-06T11:06:54Z",
        "TokenId": "NFT",
        "TransactedAccount": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
        "TransactionId": "otransaction~6a13667ea3f6edc4c854e85b127526eccb58783f653c348b42a3869f0f29a4fb~a7cefb22ff39ee7e36967be71de27da6798548c872061a62dabc56d88d50b930",
        "TransactionType": "MINT",
        "TriggeredByUserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
    },
    {
        "Balance": 100,
        "Timestamp": "2023-06-05T16:34:33Z",
        "TokenId": "FNFT",
        "TransactedAccount": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
        "TransactedAmount": 100,
        "TransactionId": "otransaction~2bc15de1766d582d821bd8d61756bca02837dc683c0aa61f69657ccd1d95e335~e4eb15d9354f694230df8835ade012100d82aa43672896a2c7125a86e3048f9f",
        "TransactionType": "MINT",
        "TriggeredByUserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38"
    }
]
GetTransactionById
Cette méthode renvoie les détails de transaction pour un ID de transaction spécifié.
Ctx.ERC1155Transaction.GetTransactionById(trxId string) (interface{}, error)
Paramètres :
  • trxId string : ID de la transaction.
Exemple de valeur renvoyée :
{
    "history": [
        {
            "IsDelete": "false",
            "Timestamp": "2022-12-08T10:45:56Z",
            "TxId": "2da02a53aa1032602df6c68c5628a4ab8b22ba107c0201520ce495948901aa98",
            "Value": {
                "Amount": 5,
                "AssetType": "otransaction",
                "FromAccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
                "Timestamp": "2022-12-08T10:45:56Z",
                "ToAccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
                "TokenId": "tokenOne",
                "TransactionId": "otransaction~2da02a53aa1032602df6c68c5628a4ab8b22ba107c0201520ce495948901aa98~9c3ce5f21abd98ca018c196086d73a812f2f49dba323f1de4f6867eecfeec8ff",
                "TransactionType": "TRANSFER",
                "TriggeredByUserAccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc"
            }
        }
    ],
    "transactionId": "otransaction~2da02a53aa1032602df6c68c5628a4ab8b22ba107c0201520ce495948901aa98~9c3ce5f21abd98ca018c196086d73a812f2f49dba323f1de4f6867eecfeec8ff"
}
DeleteHistoricalTransactions
Cette méthode supprime les transactions antérieures à un horodatage spécifié de la base de données d'état.
Ctx.ERC1155Transaction.DeleteHistoricalTransactions(referenceTime string) (interface{}, error)
Paramètres :
  • referenceTime string – Toutes les transactions antérieures à cet horodatage seront supprimées.
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

MintBatch
Cette méthode crée (affecte) plusieurs jetons dans une opération de batch. Cette méthode crée uniquement des jetons fongibles ou des jetons non fongibles fractionnaires.

Pour les jetons fongibles, si le rôle minter est défini dans le fichier de spécification, tout utilisateur disposant du rôle minter peut appeler cette méthode. Sinon, n'importe quel utilisateur peut utiliser cette méthode pour frapper des jetons. Vous ne pouvez pas dépasser la propriété max_mint_quantity du jeton si cette propriété a été spécifiée lors de la création ou de la mise à jour du jeton.

Pour les jetons non fongibles, si le rôle minter est défini dans le fichier de spécification, tout utilisateur disposant du rôle minter peut appeler cette méthode. Sinon, n'importe quel utilisateur peut utiliser cette méthode pour frapper des jetons. En outre, l'appelant doit également être le créateur du jeton. Il n'y a pas de limite supérieure à la quantité de jetons fractionnaires non fongibles qui peuvent être frappés.

Vous ne pouvez pas utiliser cette méthode pour frapper un jeton non fongible entier.

Ctx.ERC1155Token.MintBatch(accountId string, tokens []interface{}, quantities []float64) (interface{}, error)
Paramètres :
  • accountId string : ID de compte de l'utilisateur.
  • tokenIds []string : liste des ID de jeton pour lesquels les jetons ment.
  • quantity []float64 : liste des quantités de jetons à menthe, correspondant au tableau d'ID de jeton.
Renvoie :
  • En cas de succès, objet JSON qui inclut des détails sur les jetons extraits.
Exemple de valeur renvoyée :
{
    "details": [
        {
            "msg": "Successfully minted 100 tokens of fractional tokenId: plot55 to Org-Id: appdev, User-Id: idcqa"
        },
        {
            "msg": "Successfully minted 100 tokens of tokenId: 'loyalty' to Token-Account-Id 'oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e'"
        }
    ],
    "msg": "Successfully minted batch of tokens for User-Account-Id 'ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38' (Org-Id: 'appdev', User-Id: 'idcqa')"
}

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

BatchTransferFrom
Cette méthode termine une opération par lots qui transfère les jetons spécifiés dans une liste d'ID de jeton d'un utilisateur à un autre.

Pour les NFT, comme la méthode transfère la propriété du NFT, l'expéditeur du NFT doit posséder le jeton.

Pour les NFT fractionnaires, si un utilisateur (y compris le créateur du jeton) transfère tous les partages qu'il possède, il perd la propriété du jeton. Si une partie d'un jeton est transférée à un utilisateur, cet utilisateur devient automatiquement l'un des propriétaires du NFT fractionnaire.

Cette méthode ne vérifie pas que l'appelant de la méthode est l'expéditeur indiqué.

Ctx.ERC1155Token.BatchTransferFrom(fromAccountId string, toAccountId string, tokens []interface{}, quantities []float64) (interface{}, error) 
Paramètres :
  • fromUserAccountId string : ID de compte de l'expéditeur et du propriétaire du jeton dans l'organisation actuelle.
  • toUserAccountId string : ID de compte du destinataire.
  • tokenIds string[] : liste des ID de jeton pour les jetons à transférer.
  • quantity float64[] : liste des quantités de jetons à transférer, correspondant au tableau d'ID de jeton.
Renvoie :
  • En cas de succès, un message contenant les détails de chaque transfert de jeton.
Exemple de valeur renvoyée :
[
    {
        "msg": "Successfully transferred NFT token: 'FNFT' of '10' quantity from Account-Id: oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371 (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446 (Org-Id: appdev, User-Id: user1_minter)"
    },
    {
        "msg": "Successfully transferred 10 FT token: 'FT' from Account-Id: oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~1089ee5122f367ee0ca38c6660298f4b81f199627e4f67f3691c0f628237974c (Org-Id: appdev, User-Id: user1_minter)"
    },
    {
        "msg": "Successfully transferred NFT token: 'NFT' from Account-Id: oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371 (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446 (Org-Id: appdev, User-Id: user1_minter)"
    }
]
SafeBatchTransferFrom
Cette méthode termine une opération par lots qui transfère les jetons spécifiés dans une liste d'ID de jeton d'un utilisateur à un autre.

Pour les NFT, comme la méthode transfère la propriété du NFT, l'expéditeur du NFT doit posséder le jeton.

Pour les NFT fractionnaires, si un utilisateur (y compris le créateur du jeton) transfère tous les partages qu'il possède, il perd la propriété du jeton. Si une partie d'un jeton est transférée à un utilisateur, cet utilisateur devient automatiquement l'un des propriétaires du NFT fractionnaire.

L'appelant de la méthode doit être l'expéditeur spécifié.

Ctx.ERC1155Token.SafeBatchTransferFrom(fromAccountId string, toAccountId string, tokens []interface{}, quantities []float64) (interface{}, error)
Paramètres :
  • fromUserAccountId string : ID de compte de l'expéditeur et du propriétaire du jeton dans l'organisation actuelle.
  • toUserAccountId string : ID de compte du destinataire.
  • tokenIds string[] : liste des ID de jeton pour les jetons à transférer.
  • quantity float64[] : liste des quantités de jetons à transférer, correspondant au tableau d'ID de jeton.
Renvoie :
  • En cas de succès, un message contenant les détails de chaque transfert de jeton.
Exemple de valeur renvoyée :
[
    {
        "msg": "Successfully transferred NFT token: 'FNFT' of '10' quantity from Account-Id: oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371 (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446 (Org-Id: appdev, User-Id: user1_minter)"
    },
    {
        "msg": "Successfully transferred 10 FT token: 'FT' from Account-Id: oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~1089ee5122f367ee0ca38c6660298f4b81f199627e4f67f3691c0f628237974c (Org-Id: appdev, User-Id: user1_minter)"
    },
    {
        "msg": "Successfully transferred NFT token: 'NFT' from Account-Id: oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371 (Org-Id: appdev, User-Id: idcqa) to Account-Id: oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446 (Org-Id: appdev, User-Id: user1_minter)"
    }
]
BalanceOfBatch
Cette méthode termine une opération de batch qui obtient le solde des comptes de jeton. Les détails du compte sont indiqués dans trois listes distinctes d'ID d'organisation, d'ID d'utilisateur et d'ID de jeton. Cette méthode ne peut être appelée que par un Token Admin du code chaîne ou par les propriétaires de compte. Les titulaires de compte ne peuvent voir les détails du solde que pour les comptes dont ils sont propriétaires.
Ctx.ERC1155Account.BalanceOfBatch(accountIds []string, tokens []interface{}) (interface{}, error)
Paramètres :
  • accountIds []string : liste des ID de compte utilisateur.
  • tokenIds []string : liste des ID de jeton.
Exemple de valeur renvoyée :
[
    {
        "OrgId": "appdev",
        "UserId": "idcqa",
        "UserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38",
        "TokenAccountId": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
        "TokenId": "FNFT",
        "Balance": 100
    },
    {
        "OrgId": "appdev",
        "UserId": "idcqa",
        "UserAccountId": "ouaccount~412de5e3998dcd100973e1bad6e8729fddc1c7ff610beab8376d733a35c51f38",
        "TokenAccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
        "TokenId": "FT",
        "Balance": 50
    },
    {
        "OrgId": "appdev",
        "UserId": "user1_minter",
        "UserAccountId": "ouaccount~9501bb774c156eb8354dfe489250ea91f757523d70f08ee494bda98bb352003b",
        "TokenAccountId": "oaccount~dcee860665db8740cb77b846e823752185a1e9a185814d0acb305890f5903446",
        "TokenId": "FNFT",
        "Balance": 10
    }
]
ExchangeToken
Cette méthode échange des jetons entre des comptes spécifiés. Cette méthode prend uniquement en charge l'échange entre un NFT (entier ou fractionnaire) et un jeton fongible ou un jeton fongible et un NFT (entier ou fractionnaire). Cette méthode ne peut être appelée que par le propriétaire du compte.
Ctx.ERC1155Token.ExchangeToken(fromTokenId string, fromUserAccountId string, fromTokenQuantity float64, toTokenId string, toUserAccountId string, toTokenQuantity float64) (interface{}, error) 
Paramètres :
  • fromTokenId string : ID du jeton appartenant à l'expéditeur.
  • fromUserAccountId string : ID de compte de l'expéditeur.
  • fromTokenQuantity float64 : quantité de jetons de l'expéditeur à échanger avec le destinataire.
  • toTokenId string : ID du jeton appartenant au récepteur.
  • toUserAccountId string : ID de compte du destinataire.
  • toTokenQuantity float64 : quantité de jetons du récepteur à échanger avec l'expéditeur.
Renvoie :
  • En cas de succès, message avec les détails de l'échange de jetons.
Exemple de valeur renvoyée :
{
    "msg": "Succesfully exchanged 10 tokens of type 'nonfungible' with tokenId: [r1] from Account 'oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371' (OrgId: appdev, UserId: idcqa) to 10 tokens of type 'fungible' with tokenId: [loy1] from Account 'oaccount~1089ee5122f367ee0ca38c6660298f4b81f199627e4f67f3691c0f628237974c' (OrgId: 'appdev', UserId: 'user1_minter')"
}

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

Burn
Cette méthode désactive, ou brûle, les jetons fongibles et non fongibles spécifiés.
Ctx.ERC1155Token.Burn(accountId string, tokens []interface{}, quantities []float64) (interface{}, error)
Paramètres :
  • accountId string : ID de compte de l'utilisateur.
  • tokenIds []string : liste des ID de jeton à graver.
  • quantity []float64 : liste des quantités de jetons à graver, correspondant au tableau d'ID de jeton.
Renvoie :
  • En cas de succès, message contenant des détails sur les opérations de gravure.
Exemple de valeur renvoyée :
[
    {
        "msg": "Successfully burned NFT token: 'art' from Account-Id: oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6 (Org-Id: appdev, User-Id: idcqa)"
    },
    {
        "msg": "Successfully burned 2 tokens of tokenId: FT from Account-ID oaccount~9a940587fd322ccc8400233244cd3b13f3aa2a52e418e4c71fb819a2217bc49e (Org-Id: AutoF1377358917, User-Id: idcqa)"
    },
    {
        "msg": "Successfully burned 2 token share of tokenId: FNFT from Account-ID oaccount~87bcb699d507368ee3966cd03ee6d7736ffc55dde8c0f0e16b14866334ac504a (Org-Id: AutoF1377358917, User-Id: idcqa)"
    }
]