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 entièrement fonctionnel.

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

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

Référence:

Modèle

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

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 présente 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 autant de classes, de fonctions ou de fichiers que vous le souhaitez, mais seules les méthodes définies dans la classe de contrôleur principale peuvent être appelées. Les autres méthodes sont masquées.

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

Méthodes 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 les jetons, gérer les rôles et les 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 pouvoir être appelées. Les noms de méthode publics commencent par un caractère majuscule. Les noms de méthode qui commencent par un caractère minuscule sont privés.

Gestion des contrôles d'accès
Gestion de configuration de jeton
Gestion des comptes
Gestion des rôles
Gestion de l'historique des transactions
Gestion du comportement de jeton

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 un Token Admin, sinon elle renvoie false. Cette méthode peut uniquement être appelée par l'élément 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 en cours.
userId: string : nom utilisateur ou ID courriel de l'utilisateur.

Renvoie :

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

Exemple de valeur renvoyée :

{"result": true}

AddTokenAdmin

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

func (t *Controller) AddTokenAdmin(orgId string, userId string) (interface{}, error) {
            auth, err := t.Ctx.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 en cours.
userId: string : nom utilisateur ou ID courriel de l'utilisateur.

Renvoie :

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

Valeur renvoyée

{"msg":"Successfully added Admin (orgId: appDev, userId: user1)"}

RemoveTokenAdmin

Cette méthode enlève un utilisateur en tant qu'utilisateur Token Admin du code chaîne. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne. Vous ne pouvez pas vous enlever vous-même 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 en cours.
userId: string : nom utilisateur ou ID courriel de l'utilisateur.

Renvoie :

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

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 l'élément 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, un tableau admins au format JSON.

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 lorsque le code chaîne est instancié. Chaque élément Token Admin est identifié par les informations userId et orgId dans le paramètre adminList. userId est le nom utilisateur ou l'ID courriel du propriétaire de l'instance ou de l'utilisateur connecté à l'instance. orgId est l'ID du fournisseur de services d'adhésion (MSP) de l'utilisateur dans l'organisation réseau actuelle. Le paramètre adminList est obligatoire lors du premier déploiement du code chaîne. Si vous mettez à niveau le code chaîne, transmettez une liste vide ([]). 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. Toutes les autres informations du paramètre adminList sont ignorées 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 élément Token Admin du code chaîne. Pour les jetons non fongibles, si le rôle minter est défini dans le fichier de spécification, tout utilisateur doté du rôle 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 (mint). L'utilisateur qui appelle cette méthode devient le propriétaire de la 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, le nombre de jetons à la menthe. La seule valeur prise en charge pour ce paramètre est 1.

Renvoie :

En cas de réussite, la ressource de jeton au format JSON, qui inclut les informations suivantes, en fonction du type de jeton.
Behaviors : liste des comportements de jeton. Impossible de modifier cette propriété.
CreatedBy : ID de compte de l'appelant, qui est l'utilisateur qui frappe le jeton. Impossible de modifier cette propriété.
CreationDate : horodatage de la transaction d'extraction. Impossible de modifier cette propriété.
IsBurned : cette propriété indique si le jeton est brûlé. Impossible de modifier cette propriété.
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. Impossible de modifier cette propriété.
TokenDesc : description du jeton.
TokenMetadata : informations JSON décrivant le jeton.
TokenName : nom du jeton. Impossible de modifier cette propriété.
TokenStandard : norme du jeton. Impossible de modifier cette propriété.
TokenType : type du jeton (fongible ou non fongible). Impossible de modifier cette propriété.
TokenUnit : unité du jeton (entier ou fractionnaire). Impossible de modifier cette propriété.
TokenUri : URI du jeton.
Quantity : quantité du jeton.

Exemple de valeur de retour (NFT complet)

{
    "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 renvoyée (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 (FTN 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 élément 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 réussite, ressource de jeton mise à jour au format JSON.

Exemple de valeur de retour (NFT complet)

{
    "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é. Tout le monde 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, un tableau JSON contenant l'historique des jetons.

Exemple de valeur renvoyée (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 (FTN 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 de retour (NFT complet)

[
    {
        "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 élément Token Admin du code chaîne. Cette méthode utilise des requêtes enrichies SQL Berkeley DB et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant.

func (t *Controller) GetAllTokens() (interface{}, error) {
            auth, err := t.Ctx.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.

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 ne peut être appelée que par un élément Token Admin du code chaîne ou du propriétaire du jeton.

func (t *Controller) GetTokenById(tokenId string) (interface{}, error) {
            auth, err := t.Ctx.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 de retour (NFT complet)

{
  "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 renvoyée (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 (FTN 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 enrichies SQL Berkeley DB et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant. Cette méthode peut uniquement être appelée par un élément Token Admin du code chaîne ou par le propriétaire du compte.

func (t *Controller) GetAllTokensByUser(orgId string, userId string) (interface{}, error) {
            accountId, err := t.Ctx.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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.

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é. Tout le monde 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 de retour (NFT complet)

{
  "AccountId": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
  "OrgId": "appdev",
  "UserId": "idcqa"
}

Exemple de valeur de retour (FTN 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é. Tout le monde 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.

Valeur renvoyée

{
    "TokenUri": "example.com"
}

Name

Cette méthode renvoie le nom de la classe de jeton. Tout le monde 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.

Valeur renvoyée

{"TokenName": "artcollection"}

TotalSupply

Cette méthode renvoie le nombre total de jetons extraits. 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 élément 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 indiquant le jeton. Pour les jetons fongibles, utilisez le format suivant :
```
{"TokenId":"token1"}
```
Pour les jetons non fongibles, utilisez le format suivant :
```
{"TokenName":"artCollection"}
```

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 élément 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 indiquant le jeton. Pour les jetons fongibles, utilisez le format suivant :
```
{"TokenId":"token1"}
```
Pour les jetons non fongibles, utilisez le format suivant :
```
{"TokenName":"artCollection"}
```

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 enrichies SQL Berkeley DB et ne peut être appelée qu'en cas de connexion au réseau Oracle Blockchain Platform distant. Cette méthode ne peut être appelée que par un élément Token Admin du code chaîne.

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.

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 élément 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.

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 effectue 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 élément 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 à jetons fongibles avec des ID de compte uniques. Les ID de compte de jeton fongible sont formés par un hachage SHA-256 du paramètre orgId, le paramètre userId, la chaîne de constante ft séparée par le symbole tilde (~) et un numéro 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 en cours.
userId string : nom utilisateur ou ID courriel 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éé.

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 effectue 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 élément 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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.

Renvoie :

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

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.

Cette méthode ne peut être appelée que par un élément 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 en cours.
userId string : nom utilisateur ou ID courriel 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éé.

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 l'élément 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 en cours.
userId string : nom utilisateur ou ID courriel 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.

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 l'élément 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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.
tokenId ...string : pour un compte de jeton non fongible, une chaîne vide. Pour un compte de jeton fongible, l'ID de jeton.

Renvoie :

En cas de réussite, tableau d'objets JSON décrivant l'historique des comptes.

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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.
tokenId ...string : pour un compte de jeton non fongible, une chaîne vide. Pour un compte de jeton fongible, l'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 élément 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, un tableau JSON de tous les comptes.

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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.

Renvoie :

En cas de succès, objet de compte JSON qui inclut et récapitule le compte de l'utilisateur indiqué, ainsi que 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.

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 n'importe quel utilisateur.

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).

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 élément 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 avoir un compte de jeton associé au jeton fongible ou un compte de jeton non fongible pour les rôles NFT. Le rôle spécifié doit exister dans le fichier de spécification pour le 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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.
role: string : nom du rôle à ajouter à l'utilisateur indiqué.
tokenDetails erc1155Role.TokenDetail : détails indiquant 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, un message contenant les détails du compte.

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 peut uniquement être appelée par Token Admin du code chaîne ou par Account Owner du compte. L'utilisateur spécifié doit avoir un compte de jeton associé au jeton fongible ou un compte de jeton non fongible pour les rôles NFT. Le rôle spécifié doit exister dans le fichier de spécification pour le 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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.
role: string : nom du rôle à rechercher.
tokenDetails erc1155Role.TokenDetail : détails indiquant le jeton. Pour les jetons fongibles, utilisez le format suivant :
```
{"TokenId":"token1"}
```
Pour les jetons non fongibles, utilisez le format suivant :
```
{"TokenName":"artCollection"}
```

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 l'élément Token Admin du code chaîne. L'utilisateur spécifié doit avoir un compte de jeton associé au jeton fongible ou un compte de jeton non fongible pour les rôles NFT. Le rôle spécifié doit exister dans le fichier de spécification pour le 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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.
role: string : nom du rôle à enlever de l'utilisateur indiqué.
tokenDetails erc1155Role.TokenDetail : détails indiquant le jeton. Pour les jetons fongibles, utilisez le format suivant :
```
{"TokenId":"token1"}
```
Pour les jetons non fongibles, utilisez le format suivant :
```
{"TokenName":"artCollection"}
```

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 l'élément 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 indiquant le jeton. Pour les jetons fongibles, utilisez le format suivant :
```
{"TokenId":"token1"}
```
Pour les jetons non fongibles, utilisez le format suivant :
```
{"TokenName":"artCollection"}
```

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 l'élément 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 indiquant le jeton. Pour les jetons fongibles, utilisez le format suivant :
```
{"TokenId":"token1"}
```
Pour les jetons non fongibles, utilisez le format suivant :
```
{"TokenName":"artCollection"}
```

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 du compte. Cette méthode peut uniquement être appelée par un élément Token Admin du code chaîne ou par le propriétaire du compte. Pour les jetons non fongibles, cette méthode ne peut être appelée qu'en cas de connexion 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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.
tokenId ...string : pour un compte de jeton non fongible, une chaîne vide. Pour un compte de jeton fongible, l'ID de jeton.

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 la transaction pour un ID de transaction spécifié. Tout le monde 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.

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 élément 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.

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 plusieurs jetons (mints) dans une opération par lots. 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 doté du rôle minter peut appeler cette méthode. Si ce n'est pas le cas, n'importe quel utilisateur peut utiliser cette méthode pour obtenir 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 doté du rôle minter peut appeler cette méthode. Si ce n'est pas le cas, n'importe quel utilisateur peut utiliser cette méthode pour obtenir 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 non fongibles fractionnaires qui peuvent être frappés.

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

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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.
tokenIds []string : liste des ID de jeton à utiliser avec les jetons.
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.

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 batch qui transfère les jetons spécifiés dans une liste d'ID de jeton d'un utilisateur à un autre.

Pour les NFT, étant donné que la méthode transfère la propriété de la NFT, l'expéditeur de la NFT doit posséder le jeton.

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

Cette méthode ne vérifie pas que l'appelant de la méthode est l'expéditeur spécifié. Cette méthode peut être appelée par n'importe quel utilisateur.

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 (MSP) de l'expéditeur et du propriétaire du jeton dans l'organisation en cours.
fromUserId string : nom 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 en cours.
toUserId string : nom utilisateur ou ID de 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.

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 batch qui transfère les jetons spécifiés dans une liste d'ID de jeton d'un utilisateur à un autre.

Pour les NFT, étant donné que la méthode transfère la propriété de la NFT, l'expéditeur de la NFT doit posséder le jeton.

L'appelant de la méthode doit être l'expéditeur spécifié. Cette méthode peut être appelée par n'importe quel utilisateur.

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 (MSP) de l'expéditeur et du propriétaire du jeton dans l'organisation en cours.
fromUserId string : nom 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 en cours.
toUserId string : nom utilisateur ou ID de 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.

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 utilisateur et d'ID de jeton. Cette méthode peut uniquement être appelée par un élément Token Admin du code chaîne ou par les propriétaires de compte. Les propriétaires 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 en cours.
userIds []string : liste des ID de nom utilisateur ou 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 fractionnaire non fongible 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 ne prend en charge que 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 utilisateur ou ID de 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 destinataire.
toOrgId string : ID du fournisseur de services d'adhésion du destinataire dans l'organisation en cours.
toUserId string : nom utilisateur ou ID de courriel du destinataire.
toTokenQuantity float64 : quantité de jetons du destinataire à échanger avec l'expéditeur.

Renvoie :

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

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 brûlable

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 en cours.
userId string : nom utilisateur ou ID de courriel.
tokenIds []string : liste des ID de jeton à graver
quantity []float64 : liste des quantités de jetons à brûler, correspondant au tableau d'ID de jeton.

Renvoie :

En cas de succès, un message contenant des détails sur les opérations de gravure.

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 en cours.
userId: string : nom 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.

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

Gestion des contrôles d'accès
Gestion de configuration de jeton
Gestion des comptes
Gestion des rôles
Gestion de l'historique des transactions
Gestion du comportement de jeton

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 ne peuvent être exécutées que par ERC721Admin ou Account Owner du jeton ou par MultipleAccountOwner pour les utilisateurs ayant plusieurs comptes. La méthode CheckAuthorization fait partie de 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 correspondance entre les récepteurs et les méthodes, comme décrit dans le fichier oChainUtil.go.
args : argument de variable dans lequel args[0] prend la constante 'TOKEN' et args[1] prend le paramètre accountId pour ajouter une vérification de contrôle d'accès pour AccountOwner. Afin d'ajouter une vérification de contrôle d'accès pour MultipleAccountOwner, args[1] prend le paramètre orgId et args[2] prend le paramètre userId. Afin d'ajouter une vérification de contrôle d'accès pour un élément TokenOwner, args[1] prend le paramètre 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 les autres cas. 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 en cours.
userId: string : nom utilisateur ou ID courriel de l'utilisateur.

Valeur renvoyée

{
  "result": true
}

AddAdmin

Cette méthode ajoute un utilisateur en tant qu'utilisateur 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 en cours.
userId: string : nom utilisateur ou ID courriel de l'utilisateur.

Renvoie :

En cas de réussite, message répertoriant les détails de l'utilisateur ajouté en tant qu'élément Token Admin du code chaîne de jeton.

Valeur renvoyée

{
  "msg": "Successfully added Admin (orgId: appdev, userId: user1)"
}

RemoveAdmin

Cette méthode enlève un utilisateur en tant qu'utilisateur 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 vous-même 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 en cours.
userId: string : nom utilisateur ou ID courriel de l'utilisateur.

Renvoie :

En cas de réussite, message répertoriant les détails de l'utilisateur enlevé en tant qu'élément Token Admin du code chaîne de jeton.

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 réussite, liste de tous les utilisateurs Token Admin, identifiés par ID organisation et ID utilisateur.

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 minter est défini dans le fichier de spécification, tout utilisateur doté du rôle minter peut appeler cette méthode pour créer un NFT. Dans le cas contraire, n'importe quel utilisateur peut utiliser cette méthode pour créer des NFT (mint). L'utilisateur qui appelle cette méthode devient le 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, le nombre de jetons à la menthe. La seule valeur prise en charge pour ce paramètre est 1.

Renvoie :

En cas de réussite, la ressource de jeton au format JSON, qui inclut les informations suivantes.
Behavior ou Behaviors : liste des comportements de jeton. Impossible de modifier cette propriété.
CreatedBy : ID de compte de l'appelant, qui est l'utilisateur qui frappe le jeton. Impossible de modifier cette propriété.
CreationDate : horodatage de la transaction d'extraction. Impossible de modifier cette propriété.
IsBurned : cette propriété indique si le jeton est brûlé. Impossible de modifier cette propriété.
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. Impossible de modifier cette propriété.
TokenDesc : description du jeton.
TokenMetadata : informations JSON décrivant le jeton.
TokenName : nom du jeton. Impossible de modifier cette propriété.
TokenStandard : norme du jeton. Impossible de modifier cette propriété.
TokenType : type du jeton (fongible ou non fongible). Impossible de modifier cette propriété.
TokenUnit : unité du jeton (entier ou fractionnaire). Impossible de modifier cette propriété.
TokenUri : URI du jeton.
Quantity : quantité du jeton.

Exemple de valeur de retour (NFT complet)

{
    "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 renvoyée (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 (FTN 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 réussite, ressource de jeton mise à jour au format JSON.

Exemple de valeur de retour (NFT complet)

{
    "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, un tableau JSON contenant l'historique des jetons.

Exemple de valeur renvoyée (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 (FTN 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 de retour (NFT complet)

[
    {
        "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

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

Paramètres :

Aucun élément

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 ne peut être appelée que par un élément Token Admin du code chaîne ou du 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 de retour (NFT complet)

{
  "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 renvoyée (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 (FTN 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

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

Paramètres :

accountId string : ID de compte de l'utilisateur.

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.

Valeur renvoyée

{
  "AccountId": "oaccount~76cb672eeb1bd535899562a840d0c15a356db89e24bc8b43ac1dba845a4282c6",
  "OrgId": "appdev",
  "UserId": "idcqa"
}

TokenURI

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

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

Paramètres :

tokenId string : ID du jeton.

Valeur renvoyée

{
    "TokenUri": "example.com"
}

Name

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

Ctx.ERC1155Token.Name(tokenId string) (interface{}, error)

Paramètres :

tokenId string : ID du jeton.

Valeur renvoyée

{"TokenName": "artcollection"}

TotalSupply

Cette méthode renvoie le nombre total de jetons extraits. 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.

Valeur renvoyée

{"TotalSupply": 100}

TotalNetSupply

Ctx.ERC1155Token.TotalNetSupply(token interface{}) (interface{}, error)

Paramètres :

token interface{} : ressource de jeton.

Valeur renvoyée

{"TotalNetSupply": 100}

GetTokensByName

Ctx.ERC1155Token.GetTokensByName(tokenName string) (interface{}, error)

Paramètres :

tokenName: string : nom du jeton.

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 zéro décimale est renvoyée.

Ctx.ERC1155Token.GetDecimals(tokenId string) (int, error)

Paramètres :

tokenId: string : ID du jeton.

Valeur renvoyée

Méthodes de gestion des comptes

CreateAccount

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

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 en cours.
userId string : nom utilisateur ou ID courriel 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éé.

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

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 élément 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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.

Renvoie :

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

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.

Cette méthode ne peut être appelée que par un élément 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 en cours.
userId string : nom utilisateur ou ID courriel 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éé.

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 du 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.

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 de compte de jeton.

Renvoie :

En cas de réussite, tableau d'objets JSON décrivant l'historique des comptes.

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, l'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

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, l'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

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 en cours.
userId string : nom utilisateur ou ID courriel de l'utilisateur.

Renvoie :

En cas de succès, objet de compte JSON qui inclut et récapitule le compte de l'utilisateur indiqué, ainsi que 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.

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).

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 indiqué.
userAccountId: string : ID de compte de l'utilisateur.
asset: interface{} : ressource de jeton.

Renvoie :

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

Valeur renvoyée

{
    "msg": "Successfully added role minter to oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a (orgId : appdev, userId : idcqa)"
}

IsInRole

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.

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 à enlever.
userAccountId: string : ID de compte de l'utilisateur.
asset: interface{} : ressource de jeton.

Valeur renvoyée

{
    "msg": "Successfully removed role 'minter' from Account Id: oaccount~ec7e4de2f81e3ea071710e07b6ff7d9346e84ef665ca4650885dbe8c3e2bd4c0 (Org-Id: appdev, User-Id: idcqa)"
}

GetAccountsByRole

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

Paramètres :

roleName: string : nom du rôle à rechercher.
token: interface{} : ressource de jeton.

Valeur renvoyée

{
    "accounts": [
        "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
        "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b"
    ]
}

GetUsersByRole

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

Paramètres :

roleName: string : nom du rôle à rechercher.
token: interface{} : ressource de jeton.

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

Ctx.ERC1155Account.GetAccountTransactionHistory(tokenAccountId string) (interface{}, error)

Paramètres :

accountId string : ID du compte utilisateur.

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 la transaction pour un ID de transaction spécifié.

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

Paramètres :

trxId string : ID de la transaction.

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.

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 plusieurs jetons (mints) dans une opération par lots. Cette méthode crée uniquement des jetons fongibles ou des jetons non fongibles fractionnaires.

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

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 à utiliser avec les jetons.
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.

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 batch qui transfère les jetons spécifiés dans une liste d'ID de jeton d'un utilisateur à un autre.

Pour les NFT, étant donné que la méthode transfère la propriété de la NFT, l'expéditeur de la NFT doit posséder le jeton.

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

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 en cours.
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.

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 batch qui transfère les jetons spécifiés dans une liste d'ID de jeton d'un utilisateur à un autre.

Pour les NFT, étant donné que la méthode transfère la propriété de la NFT, l'expéditeur de la NFT doit posséder le jeton.

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 en cours.
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.

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

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.

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 ne prend en charge que 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 destinataire.
toUserAccountId string : ID de compte du destinataire.
toTokenQuantity float64 : quantité de jetons du destinataire à échanger avec l'expéditeur.

Renvoie :

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

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 brûlable

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 à brûler, correspondant au tableau d'ID de jeton.

Renvoie :

En cas de succès, un message contenant des détails sur les opérations de gravure.

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)"
    }
]