Scaffolded Go Token Projekt für ERC-1155

Blockchain App Builder übernimmt die Eingabe aus Ihrer Tokenspezifikationsdatei und generiert ein voll funktionsfähiges gerüstetes Chaincode-Projekt.

Das Projekt generiert automatisch Tokenlebenszyklusklassen und -funktionen, einschließlich CRUD- und Nicht-CRUD-Methoden. Validierung von Argumenten, Marshalling/Unmarshalling und transparente Persistenzfähigkeit werden automatisch unterstützt.

Informationen zum gerüsteten Projekt und zu Methoden, die nicht direkt mit Token zusammenhängen, finden Sie unter Scaffolded Go Chaincode Project.

Referenz:

Modell

Transparent Persistence Capability (transparente Persistenzfunktion) oder vereinfachtes ORM wird in der Klasse OchainModel erfasst. Das folgende Modell zeigt ein ganzes nicht fungibles Token.

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"`
}

Das folgende Modell zeigt einen fraktionierten nicht fungiblen Token.

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"`
}

Controller

Es gibt nur einen Hauptcontroller.

type Controller struct {
    Ctx trxcontext.TrxContext
}

Sie können eine beliebige Anzahl von Klassen, Funktionen oder Dateien erstellen, aber nur die Methoden, die in der Hauptcontrollerklasse definiert sind, können aufgerufen werden. Die anderen Methoden sind versteckt.

Mit den Token-SDK-Methoden können Sie benutzerdefinierte Methoden für Ihre Geschäftsanwendung schreiben.

Automatisch generierte Token-Methoden

Blockchain App Builder generiert automatisch Methoden zur Unterstützung von Token und Tokenlebenszyklen. Mit diesen Methoden können Sie Token initialisieren, Rollen und Konten verwalten und andere Tokenlebenszyklusaufgaben ohne zusätzliche Codierung ausführen. Controller-Methoden müssen öffentlich sein, damit sie aufgerufen werden können. Öffentliche Methodennamen beginnen mit einem Großbuchstaben. Methodennamen, die mit einem Kleinbuchstaben beginnen, sind privat.

Methoden für die Zugriffskontrolle

IsTokenAdmin

Diese Methode gibt den booleschen Wert true zurück, wenn der Aufrufer der Funktion ein Token Admin ist. Andernfalls wird false zurückgegeben. Diese Methode kann nur vom Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

orgId: string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId: string: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

Die Methode gibt true zurück, wenn der Aufrufer ein Token Admin ist. Andernfalls wird false zurückgegeben.

Beispiel für einen Rückgabewert:

{"result": true}

AddTokenAdmin

Mit dieser Methode wird ein Benutzer als Token Admin des Chaincodes hinzugefügt. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

orgId: string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId: string: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

Bei erfolgreicher Ausführung eine Meldung mit Details des Benutzers, der als Token Admin des Chaincodes hinzugefügt wurde.

Beispiel für einen Rückgabewert:

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

RemoveTokenAdmin

Mit dieser Methode wird ein Benutzer als Token Admin des Chaincodes entfernt. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden. Sie können sich nicht selbst als Token Admin entfernen.

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

Parameter:

orgId: string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId: string: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

Bei erfolgreicher Ausführung eine Meldung mit Details des Benutzers, der als Token Admin des Chaincodes entfernt wurde.

Beispiel für einen Rückgabewert:

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

GetAllTokenAdmins

Diese Methode gibt eine Liste aller Benutzer zurück, die ein Token Admin des Chaincodes sind. Diese Methode kann nur vom Token Admin des Chaincodes aufgerufen werden.

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()
      }

Parameter:

Kein

Rückgabewert:

Bei Erfolg ein admins-Array im JSON-Format.

Beispiel für einen Rückgabewert:

{
  "admins": [
    {
      "OrgId": "appdev",
      "UserId": "idcqa"
    },
    {
      "OrgId": "appdev",
      "UserId": "user1"
    }
  ]
}

Methoden für die Verwaltung der Tokenkonfiguration

Init

Diese Methode wird aufgerufen, wenn der Chaincode instanziiert wird. Jede Token Admin wird durch die Informationen userId und orgId im Parameter adminList identifiziert. userId ist der Benutzername oder die E-Mail-ID des Instanzeigentümers oder des Benutzers, der bei der Instanz angemeldet ist. orgId ist die Mitgliedschaftsserviceprovider-(MSP-)ID des Benutzers in der aktuellen Netzwerkorganisation. Der Parameter adminList ist erforderlich, wenn Sie den Chaincode zum ersten Mal bereitstellen. Wenn Sie ein Upgrade des Chaincodes durchführen, übergeben Sie eine leere Liste ([]). Wenn Sie der Benutzer sind, der den Chaincode ursprünglich bereitgestellt hat, können Sie beim Upgrade des Chaincodes auch neue Admins im Parameter adminList angeben. Alle anderen Informationen im Parameter adminList werden bei Upgrades ignoriert.

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
}

Parameter:

adminList array: Ein Array mit {OrgId, UserId}-Informationen, das die Liste der Tokenadministratoren angibt. Das Array adminList ist ein obligatorischer Parameter.

Create<Token Name>Token

Diese Methode erstellt Token. Jedes definierte Token verfügt über eine eigene Erstellungsmethode. Bei fungiblen Token kann diese Methode nur von einem Token Admin des Chaincodes aufgerufen werden. Wenn für nicht fungible Token die Minter-Rolle in der Spezifikationsdatei definiert ist, kann jeder Benutzer mit der Minter-Rolle diese Methode aufrufen, um eine NFT zu erstellen. Wenn die Minter-Rolle nicht definiert ist, kann jeder Benutzer diese Methode zum Erstellen (Minten) von NFTs verwenden. Der Benutzer, der diese Methode aufruft, wird Eigentümer der NFT.

Fungible Token:

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

Nicht-fungible Token:

func (t *Controller) Create<Token Name>Token(tokenAsset <Token Class>, quantity float64) (interface{}, error) {
         quantityToPass := []float64{quantity}
          return t.Ctx.ERC1155Token.Save(&tokenAsset, quantityToPass...)
    }

Parameter:

tokenAsset: <Token Class>: Das Tokenasset. Die Eigenschaften des Assets werden in der Modelldatei definiert.
quantity: number - Nur für nicht fungible Token die Anzahl der zu prägenden Token. Der einzige unterstützte Wert für diesen Parameter ist 1.

Rückgabewert:

Bei Erfolg das Tokenasset im JSON-Format, das je nach Tokentyp die folgenden Informationen enthält.
Behaviors: Eine Liste der Tokenverhalten. Diese Eigenschaft kann nicht bearbeitet werden.
CreatedBy: Die Account-ID des Aufrufers, der das Token mintet. Diese Eigenschaft kann nicht bearbeitet werden.
CreationDate: Der Zeitstempel der Prägetransaktion. Diese Eigenschaft kann nicht bearbeitet werden.
IsBurned: Diese Eigenschaft gibt an, ob das Token gebrannt wird. Diese Eigenschaft kann nicht bearbeitet werden.
Mintable: Die Eigenschaften für das Prägen. Der Wert max_mint_quantity definiert die maximale Anzahl von Token, die für die Tokenklasse erstellt werden können.
Owner: Die Account-ID des aktuellen Eigentümers, der die Methode aufruft.
Symbol: Das Symbol des Tokens. Diese Eigenschaft kann nicht bearbeitet werden.
TokenDesc: Die Beschreibung des Tokens.
TokenMetadata: JSON-Informationen, die das Token beschreiben.
TokenName: Der Name des Tokens. Diese Eigenschaft kann nicht bearbeitet werden.
TokenStandard: Der Standard des Tokens. Diese Eigenschaft kann nicht bearbeitet werden.
TokenType: Der Typ des Tokens (Fungible oder Nicht-Fungible). Diese Eigenschaft kann nicht bearbeitet werden.
TokenUnit: Die Einheit des Tokens (ganz oder teilweise). Diese Eigenschaft kann nicht bearbeitet werden.
TokenUri: Die URI des Tokens.
Quantity: Die Menge des Tokens.

Beispiel für Rückgabewert (ganzer NFT):

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

Beispiel für Rückgabewert (ungültiges Token):

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

Beispiel für Rückgabewerte (fraktionaler NFT):

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

Diese Methode aktualisiert Token. Jedes definierte Token verfügt über eine eigene Aktualisierungsmethode. Sie können keine Tokenmetadaten oder die Token-URI von nicht fungiblen Token aktualisieren. Bei fungiblen Token kann diese Methode nur von einem Token Admin des Chaincodes aufgerufen werden. Bei nicht fungiblen Token kann diese Methode nur vom Token-Eigentümer aufgerufen werden.

Fungible Token:

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

Nicht-fungible Token:

func (t *Controller) Update<%=tokenModelName%>Token(tokenAsset <%=tokenModelName%>) (interface{}, error) {
            return t.Ctx.ERC1155Token.Update(&tokenAsset)
    }

Parameter:

tokenAsset: <Token Class>: Das Tokenasset. Die Eigenschaften des Assets werden in der Modelldatei definiert.

Rückgabewert:

Bei Erfolg das aktualisierte Tokenasset im JSON-Format.

Beispiel für Rückgabewert (ganzer NFT):

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

Diese Methode gibt die Historie für eine angegebene Token-ID zurück. Jeder kann diese Methode nennen.

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

Parameter:

tokenId: string: Die ID des Tokens.

Rückgabewert:

Bei Erfolg ein JSON-Array, das die Tokenhistorie enthält.

Beispiel für Rückgabewert (ungültiges Token):

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

Beispiel für Rückgabewerte (fraktionaler NFT):

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

Beispiel für Rückgabewert (ganzer NFT):

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

Diese Methode gibt alle Tokenassets zurück, die in der Statusdatenbank gespeichert sind. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden. Diese Methode verwendet SQL-Rich-Abfragen der Berkeley-DB und kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Oracle Blockchain Platform-Netzwerk besteht.

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()
      }

Parameter:

Kein

Rückgabewert:

Eine Liste aller Tokenassets im JSON-Format.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt ein Tokenobjekt zurück, wenn das Token in der Statusdatenbank vorhanden ist. Bei NFTs mit Bruchteilen wird auch die Liste der Eigentümer zurückgegeben. Diese Methode kann nur von einem Token Admin des Chaincodes oder des Tokeneigentümers aufgerufen werden.

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

Parameter:

tokenId string: Die ID des abzurufenden Tokens.

Beispiel für Rückgabewert (ganzer NFT):

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

Beispiel für Rückgabewert (ungültiges Token):

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

Beispiel für Rückgabewerte (fraktionaler NFT):

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

Diese Methode gibt alle Tokenassets zurück, deren Eigentümer ein angegebener Benutzer ist. Diese Methode verwendet SQL-Rich-Abfragen der Berkeley-DB und kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Oracle Blockchain Platform-Netzwerk besteht. Diese Methode kann nur von einem Token Admin des Chaincodes oder vom Accounteigentümer aufgerufen werden.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt die Konto-ID, Organisations-ID und Benutzer-ID des Eigentümers der angegebenen Token-ID zurück. Jeder kann diese Methode nennen.

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

Parameter:

tokenId string: Die ID des Tokens.

Beispiel für Rückgabewert (ganzer NFT):

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

Beispiel für Rückgabewerte (fraktionaler NFT):

[
    {
        "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
        "OrgId": "Org1MSP",
        "UserId": "admin"
    },
    {
        "AccountId": "oaccount~74108eca702bab6d8548e740254f2cc7955d886885251d52d065042172a59db0",
        "OrgId": "Org1MSP",
        "UserId": "user"
    }
]

URI

Diese Methode gibt die URI eines angegebenen Tokens zurück. Jeder kann diese Methode nennen.

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

Parameter:

tokenId string: Die ID des Tokens.

Beispiel für einen Rückgabewert:

{
    "TokenUri": "example.com"
}

Name

Diese Methode gibt den Namen der Token-Klasse zurück. Jeder kann diese Methode nennen.

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

Parameter:

tokenId string: Die ID des Tokens.

Beispiel für einen Rückgabewert:

{"TokenName": "artcollection"}

TotalSupply

Diese Methode gibt die Gesamtanzahl der geprägten Token zurück. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

tokenDetails erc1155Role.TokenDetail: Die Details, die das Token angeben. Verwenden Sie für fungible Token das folgende Format:
```
{"TokenId":"token1"}
```
Verwenden Sie für nicht fungible Token das folgende Format:
```
{"TokenName":"artCollection"}
```

Beispiel für einen Rückgabewert:

{
    "TotalSupply": 100
}

TotalNetSupply

Diese Methode gibt die Gesamtanzahl der geprägten Token abzüglich der Anzahl der gebrannten Token zurück. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

tokenDetails erc1155Role.TokenDetail: Die Details, die das Token angeben. Verwenden Sie für fungible Token das folgende Format:
```
{"TokenId":"token1"}
```
Verwenden Sie für nicht fungible Token das folgende Format:
```
{"TokenName":"artCollection"}
```

Beispiel für einen Rückgabewert:

{
   "TotalNetSupply": 900
}

GetTokensByName

Diese Methode gibt alle Tokenassets für einen angegebenen Tokennamen zurück. Diese Methode verwendet SQL-Rich-Abfragen der Berkeley-DB und kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Oracle Blockchain Platform-Netzwerk besteht. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

tokenName: string: Der Name des Tokens.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt die Anzahl der Dezimalstellen für ein angegebenes Token zurück. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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
      }

Parameter:

tokenId string: Die ID des Tokens.

Beispiel für einen Rückgabewert:

{
    "msg": "Token Id: tokenOne has 2 decimal places."
}

Methoden für die Accountverwaltung

CreateAccount

Diese Methode erstellt ein Konto für einen angegebenen Benutzer und zugehörige Tokenkonten für fungible oder nicht fungible Token. Ein Konto muss für jeden Benutzer erstellt werden, der zu einem beliebigen Zeitpunkt Token hat. Das Benutzerkonto verfolgt das NFT-Konto und die fungiblen Token-Konten, die ein Benutzer hat. Benutzer müssen über Konten im Netzwerk verfügen, um tokenbezogene Vorgänge abzuschließen. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

Ein Benutzerkonto hat eine eindeutige ID, die durch einen SHA-256-Hash des Parameters orgId und des Parameters userId gebildet wird.

Ein Benutzer kann mehrere fungible Token-Konten mit eindeutigen Konto-IDs haben. Fungible Token-Konto-IDs werden durch einen SHA-256-Hash des Parameters orgId, den Parameter userId, die durch das Tilde-Symbol (~) getrennte konstante Zeichenfolge ft und eine Zählernummer gebildet, die den Index des fungiblen Kontos angibt, das durch das Tilde-Symbol (~) getrennt erstellt wird.

Ein Benutzer kann nur einen nicht fungiblen Tokenaccount haben. Konto-IDs für nicht fungible Token sind eindeutig und werden durch einen SHA-256-Hash des Parameters orgId, den Parameter userId und die durch das Tilde-Symbol (~) getrennte konstante Zeichenfolge nft gebildet. Alle nicht fungiblen Token, für die ein Benutzer verantwortlich ist, ob ganz oder teilweise, sind mit diesem Konto verknüpft.

Benutzeraccount-IDs beginnen mit ouaccount~. Tokenaccount-IDs beginnen mit 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)
      }

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
ftAccount bool: Bei "true" wird ein fungibler Tokenaccount erstellt und mit dem Benutzeraccount verknüpft.
nftAccount bool: Bei "true" wird ein nicht fungibler Tokenaccount erstellt und mit dem Benutzeraccount verknüpft.

Rückgabewert:

Bei Erfolg ein JSON-Objekt des erstellten Accounts.

Beispiel für einen Rückgabewert:

{
  "AssetType": "ouaccount",
  "AccountId": "ouaccount~cf20877546f52687f387e7c91d88b9722c97e1a456cc0484f40c747f7804feae",
  "UserId": "user1",
  "OrgId": "appdev",
  "TotalAccounts": 2,
  "TotalFtAccounts": 1,
  "AssociatedFtAccounts": [
    {
      "AccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
      "TokenId": ""
    }
  ],
  "AssociatedNftAccount": "oaccount~73c3e835dac6d0a56ca9d8def08269f83cefd59b9d297fe2cdc5a9083828fa58"
}

CreateUserAccount

Diese Methode erstellt einen Account für einen angegebenen Benutzer. Ein Konto muss für jeden Benutzer erstellt werden, der zu einem beliebigen Zeitpunkt Token hat. Das Benutzerkonto verfolgt das NFT-Konto und die fungiblen Token-Konten, die ein Benutzer hat. Benutzer müssen über Konten im Netzwerk verfügen, um tokenbezogene Vorgänge abzuschließen.

Eine Konto-ID ist ein SHA-256-Hash des Parameters orgId und des Parameters userId. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

Bei Erfolg ein JSON-Objekt des erstellten Benutzerkontos.

Beispiel für einen Rückgabewert:

{
  "AssetType": "ouaccount",
  "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
  "UserId": "idcqa",
  "OrgId": "appdev",
  "TotalAccounts": 0,
  "TotalFtAccounts": 0,
  "AssociatedFtAccounts": [],
  "AssociatedNftAccount": ""
}

CreateTokenAccount

Diese Methode erstellt ein fungibles oder nicht fungibles Token-Konto, das einem Benutzerkonto zugeordnet werden kann.

Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
tokenType erc1155Token.TokenType: Der Typ des zu erstellenden Tokenaccounts. Die einzigen unterstützten Tokentypen sind nonfungible und fungible.

Rückgabewert:

Bei Erfolg ein JSON-Objekt des erstellten Tokenaccounts.

Beispiel für einen Rückgabewert:

{
    "AssetType": "ouaccount",
    "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "TotalAccounts": 1,
    "TotalFtAccounts": 1,
    "AssociatedFtAccounts": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "TokenId": ""
        }
    ],
    "AssociatedNftAccount": ""
}

AssociateFungibleTokenAccount

Diese Methode verknüpft das fungible Token-Konto eines Benutzers mit einem bestimmten fungiblen Token.

Diese Methode kann nur vom Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
tokenId string: Die ID des Tokens.

Rückgabewert:

Bei Erfolg ein JSON-Objekt des Benutzeraccounts, das zeigt, dass das fungible Token dem Tokenaccount zugeordnet wurde. Beispiel: Im folgenden Beispiel zeigt das erste Objekt im Array associatedFtAccounts, dass die Account-ID des fungiblen Tokens und die Token-ID verknüpft sind.

Beispiel für einen Rückgabewert:

{
    "AssetType": "ouaccount",
    "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "TotalAccounts": 1,
    "TotalFtAccounts": 1,
    "AssociatedFtAccounts": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "TokenId": "tokenOne"
        }
    ],
    "AssociatedNftAccount": ""
}

GetAccountHistory

Diese Methode gibt die Historie für ein angegebenes Token-Konto zurück. Dies ist eine asynchrone Methode. Diese Methode kann nur vom Token Admin des Chaincodes oder vom Accounteigentümer aufgerufen werden.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
tokenId ...string: Bei einem nicht fungiblen Tokenaccount eine leere Zeichenfolge. Bei einem fungiblen Token-Konto die Token-ID.

Rückgabewert:

Bei Erfolg ein Array von JSON-Objekten, das die Kontohistorie beschreibt.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt Tokenaccountdetails für einen angegebenen Benutzer zurück. Diese Methode kann nur von einem Token Admin des Chaincodes oder dem Account Owner des Accounts aufgerufen werden.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
tokenId ...string: Bei einem nicht fungiblen Tokenaccount eine leere Zeichenfolge. Bei einem fungiblen Token-Konto die Token-ID.

Rückgabewert:

Bei Erfolg ein JSON-Objekt, das Tokenaccountdetails enthält. Die Parameter BapAccountVersion und AccountCategory werden im Accountobjekt zur internen Verwendung definiert.

Beispiel für Rückgabewert (Nicht-Fungible Token-Konto):

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

Beispiel für Rückgabewert (Fungible Token-Konto):

{
  "AccountCategory": "",
  "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
  "AssetType": "oaccount",
  "Balance": 0,
  "BapAccountVersion": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenId": "t1",
  "TokenName": "loyalty",
  "TokenType": "fungible",
  "UserId": "idcqa"
}

GetAllAccounts

Diese Methode gibt Details aller Benutzerkonten zurück. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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()
      }

Parameter:

Kein

Rückgabewert:

Bei Erfolg ein JSON-Array aller Konten.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt eine Kontenübersicht für einen angegebenen Benutzer und Details zu fungiblen und nicht fungiblen Token zurück, die dem Benutzer zugeordnet sind. Diese Methode kann nur von einem Token Admin des Chaincodes oder dem Account Owner des Accounts aufgerufen werden.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

Bei Erfolg ein JSON-Accountobjekt, das eine Zusammenfassung für den angegebenen Benutzer und Details zu fungiblen und nicht fungiblen Token enthält, die dem Benutzer zugeordnet sind. Bei partiellen nicht fungiblen Token zeigt die Eigenschaft TokenShare im Abschnitt AssociatedNFTs den Anteil an, für den der Benutzer verantwortlich ist.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt die Benutzerdetails einer angegebenen Konto-ID zurück. Diese Methode kann von jedem Benutzer aufgerufen werden.

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

Parameter:

accountId string: Die ID des Accounts.

Rückgabewert:

Bei Erfolg ein JSON-Objekt der Benutzerdetails (orgId und userId).

Beispiel für einen Rückgabewert:

{
    "OrgId": "appdev",
    "UserId": "user2"
}

Methoden für die Rollenverwaltung

AddRole

Mit dieser Methode wird eine Rolle zu einem angegebenen Benutzer und Token hinzugefügt. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben. Der angegebene Benutzer muss über ein Tokenkonto verfügen, das mit dem fungiblen Token verknüpft ist, oder über ein nicht fungibles Tokenkonto für NFT-Rollen. Die angegebene Rolle muss in der Spezifikationsdatei für das Token vorhanden sein.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
role: string: Der Name der Rolle, die dem angegebenen Benutzer hinzugefügt werden soll.
tokenDetails erc1155Role.TokenDetail: Die Details, die das Token angeben. Verwenden Sie für fungible Token das folgende Format:
```
{"TokenId":"token1"}
```
Verwenden Sie für nicht fungible Token das folgende Format:
```
{"TokenName":"artCollection"}
```

Rückgabewert:

Bei Erfolg eine Nachricht mit Accountdetails.

Beispiel für einen Rückgabewert:

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

IsInRole

Diese Methode gibt einen booleschen Wert zurück, um anzugeben, ob ein Benutzer über eine angegebene Rolle verfügt. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben. Diese Methode kann nur vom Token Admin des Chaincodes oder vom Account Owner des Accounts aufgerufen werden. Der angegebene Benutzer muss über ein Tokenkonto verfügen, das mit dem fungiblen Token verknüpft ist, oder über ein nicht fungibles Tokenkonto für NFT-Rollen. Die angegebene Rolle muss in der Spezifikationsdatei für das Token vorhanden sein.

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
      }

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
role: string: Der Name der Rolle, nach der gesucht werden soll.
tokenDetails erc1155Role.TokenDetail: Die Details, die das Token angeben. Verwenden Sie für fungible Token das folgende Format:
```
{"TokenId":"token1"}
```
Verwenden Sie für nicht fungible Token das folgende Format:
```
{"TokenName":"artCollection"}
```

Beispiel für einen Rückgabewert:

{
    "result": true
}

RemoveRole

Diese Methode entfernt eine Rolle aus einem angegebenen Benutzer und Token. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben. Diese Methode kann nur vom Token Admin des Chaincodes aufgerufen werden. Der angegebene Benutzer muss über ein Tokenkonto verfügen, das mit dem fungiblen Token verknüpft ist, oder über ein nicht fungibles Tokenkonto für NFT-Rollen. Die angegebene Rolle muss in der Spezifikationsdatei für das Token vorhanden sein.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
role: string: Der Name der Rolle, die vom angegebenen Benutzer entfernt werden soll.
tokenDetails erc1155Role.TokenDetail: Die Details, die das Token angeben. Verwenden Sie für fungible Token das folgende Format:
```
{"TokenId":"token1"}
```
Verwenden Sie für nicht fungible Token das folgende Format:
```
{"TokenName":"artCollection"}
```

Beispiel für einen Rückgabewert:

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

GetAccountsByRole

Diese Methode gibt eine Liste aller Konto-IDs für eine angegebene Rolle und ein bestimmtes Token zurück. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben. Diese Methode kann nur vom Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

role: string: Der Name der Rolle, nach der gesucht werden soll.
tokenDetails erc1155Role.TokenDetail: Die Details, die das Token angeben. Verwenden Sie für fungible Token das folgende Format:
```
{"TokenId":"token1"}
```
Verwenden Sie für nicht fungible Token das folgende Format:
```
{"TokenName":"artCollection"}
```

Beispiel für einen Rückgabewert:

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

GetUsersByRole

Diese Methode gibt eine Liste aller Benutzer für eine angegebene Rolle und ein bestimmtes Token zurück. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben. Diese Methode kann nur vom Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

role: string: Der Name der Rolle, nach der gesucht werden soll.
tokenDetails erc1155Role.TokenDetail: Die Details, die das Token angeben. Verwenden Sie für fungible Token das folgende Format:
```
{"TokenId":"token1"}
```
Verwenden Sie für nicht fungible Token das folgende Format:
```
{"TokenName":"artCollection"}
```

Beispiel für einen Rückgabewert:

{
    "Users": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "OrgId": "appdev",
            "UserId": "idcqa"
        },
        {
            "AccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
            "OrgId": "appdev",
            "UserId": "user1"
        }
    ]
}

Methoden für das Transaktionshistorienmanagement

GetAccountTransactionHistory

Diese Methode gibt die Kontotransaktionshistorie zurück. Diese Methode kann nur von einem Token Admin des Chaincodes oder vom Accounteigentümer aufgerufen werden. Bei nicht fungiblen Token kann diese Methode nur aufgerufen werden, wenn eine Verbindung zum Remote-Oracle Blockchain Platform-Netzwerk besteht.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
tokenId ...string: Bei einem nicht fungiblen Tokenaccount eine leere Zeichenfolge. Bei einem fungiblen Token-Konto die Token-ID.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt die Transaktionsdetails für eine angegebene Transaktions-ID zurück. Jeder kann diese Methode nennen.

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

Parameter:

transactionId: string: Die ID der Transaktion.

Beispiel für einen Rückgabewert:

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

Diese Methode löscht Transaktionen vor einem angegebenen Zeitstempel aus der Statusdatenbank. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

timestamp: string: Alle Transaktionen vor diesem Zeitstempel werden gelöscht.

Beispiel für einen Rückgabewert:

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

Methoden für das Tokenverhaltensmanagement - Mintable Behavior

MintBatch

Diese Methode erstellt (mindert) mehrere Token in einem Batchvorgang. Diese Methode erstellt nur fungible Token oder fraktionierte nicht fungible Token.

Wenn für fungible Token die Minter-Rolle in der Spezifikationsdatei definiert ist, kann jeder Benutzer mit der Minter-Rolle diese Methode aufrufen. Wenn nicht, kann jeder Benutzer diese Methode verwenden, um Token zu mintieren. Sie können nicht mehr als die Eigenschaft max_mint_quantity des Tokens mintieren, wenn diese Eigenschaft beim Erstellen oder Aktualisieren des Tokens angegeben wurde.

Wenn für nicht fungible Token die Minter-Rolle in der Spezifikationsdatei definiert ist, kann jeder Benutzer mit der Minter-Rolle diese Methode aufrufen. Wenn nicht, kann jeder Benutzer diese Methode verwenden, um Token zu mintieren. Darüber hinaus muss der Aufrufer auch der Ersteller des Tokens sein. Es gibt keine Obergrenze für die Menge an fraktionierten nicht fungiblen Token, die geprägt werden können.

Sie können diese Methode nicht verwenden, um ein ganzes nicht fungibles Token zu prägen.

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

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
tokenIds []string: Die Liste der Token-IDs, für die Token geprägt werden sollen.
quantity []float64: Die Liste der Mengen der zu prägenden Token, die dem Token-ID-Array entsprechen.

Rückgabewert:

Bei Erfolg ein JSON-Objekt, das Details zu den geprägten Token enthält.

Beispiel für einen Rückgabewert:

{
    "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')"
}

Methoden für das Tokenverhaltensmanagement - Übertragbares Verhalten

BatchTransferFrom

Diese Methode schließt einen Batchvorgang ab, bei dem Token, die in einer Liste mit Token-IDs angegeben sind, von einem Benutzer an einen anderen Benutzer übertragen werden.

Bei NFTs muss der Absender des NFT das Token besitzen, da die Methode das Eigentum an dem NFT überträgt.

Bei teilweisen NFTs verliert ein Benutzer (einschließlich des Erstellers des Tokens) alle Aktien, die er besitzt, das Eigentum an dem Token. Wenn ein Teil eines Tokens an einen Benutzer übertragen wird, wird dieser Benutzer automatisch zu einem Eigentümer des partiellen NFT.

Diese Methode validiert nicht, ob der Aufrufer der Methode der angegebene Absender ist. Diese Methode kann von jedem Benutzer aufgerufen werden.

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

Parameter:

fromOrgId string: Die Mitgliedschaftsserviceprovider-(MSP-)ID des Absenders und Tokeneigentümers in der aktuellen Organisation.
fromUserId string: Der Benutzername oder die E-Mail-ID des Absenders und Tokeneigentümers.
toOrgId string: Die Mitgliedschaftsdienstleister-ID (MSP) des Empfängers in der aktuellen Organisation.
toUserId string: Der Benutzername oder die E-Mail-ID des Empfängers.
tokenIds string[]: Eine Liste der Token-IDs für die zu übertragenden Token.
quantity float64[]: Die Liste der zu übertragenden Tokenmengen entsprechend dem Token-ID-Array.

Rückgabewert:

Bei erfolgreicher Ausführung wird eine Nachricht mit Details für jede Tokentransfer angezeigt.

Beispiel für einen Rückgabewert:

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

Diese Methode schließt einen Batchvorgang ab, bei dem Token, die in einer Liste mit Token-IDs angegeben sind, von einem Benutzer an einen anderen Benutzer übertragen werden.

Bei NFTs muss der Absender des NFT das Token besitzen, da die Methode das Eigentum an dem NFT überträgt.

Der Aufrufer der Methode muss der angegebene Absender sein. Diese Methode kann von jedem Benutzer aufgerufen werden.

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

Parameter:

fromOrgId string: Die Mitgliedschaftsserviceprovider-(MSP-)ID des Absenders und Tokeneigentümers in der aktuellen Organisation.
fromUserId string: Der Benutzername oder die E-Mail-ID des Absenders und Tokeneigentümers.
toOrgId string: Die Mitgliedschaftsdienstleister-ID (MSP) des Empfängers in der aktuellen Organisation.
toUserId string: Der Benutzername oder die E-Mail-ID des Empfängers.
tokenIds string[]: Eine Liste der Token-IDs für die zu übertragenden Token.
quantity float64[]: Die Liste der zu übertragenden Tokenmengen entsprechend dem Token-ID-Array.

Rückgabewert:

Bei erfolgreicher Ausführung wird eine Nachricht mit Details für jede Tokentransfer angezeigt.

Beispiel für einen Rückgabewert:

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

Diese Methode schließt einen Batchvorgang ab, der den Saldo von Tokenkonten abruft. Die Kontodetails werden in drei separaten Listen mit Organisationskennungen, Benutzerkennungen und Tokenkennungen angegeben. Diese Methode kann nur von einem Token Admin des Chaincodes oder von Accounteigentümern aufgerufen werden. Kontoinhaber können Saldendetails nur für Konten anzeigen, für die sie verantwortlich sind.

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

Parameter:

orgIds []string: Eine Liste der Mitgliedschaftsserviceprovider-(MSP-)IDs in der aktuellen Organisation.
userIds []string: Eine Liste der Benutzernamen oder E-Mail-IDs.
tokenIds []string: Eine Liste der Token-IDs.

Beispiel für einen Rückgabewert:

Im folgenden Beispiel stellt die Token-ID FNFT ein fraktioniertes nicht fungibles Token dar, und die Token-ID FT stellt ein fungibles Token dar.

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

Diese Methode tauscht Token zwischen angegebenen Konten aus. Diese Methode unterstützt nur den Austausch zwischen einem NFT und einem fungiblen Token oder einem fungiblen Token und einem NFT. Diese Methode kann nur vom Kontoinhaber aufgerufen werden.

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

Parameter:

fromTokenId string: Die ID des Tokens, dessen Eigentümer der Absender ist.
fromOrgId string - Die Mitgliedschaftsdienstleister-ID (MSP) des Absenders in der aktuellen Organisation.
fromUserId string: Der Benutzername oder die E-Mail-ID des Absenders.
fromTokenQuantity float64 - Die Anzahl der Token vom Absender, die mit dem Empfänger ausgetauscht werden sollen.
toTokenId string: Die ID des Tokens, dessen Eigentümer der Empfänger ist.
toOrgId string: Die Mitgliedschaftsdienstleister-ID (MSP) des Empfängers in der aktuellen Organisation.
toUserId string: Der Benutzername oder die E-Mail-ID des Empfängers.
toTokenQuantity float64 - Die Anzahl der Token vom Empfänger, die mit dem Absender ausgetauscht werden sollen.

Rückgabewert:

Bei Erfolg eine Nachricht mit Details zum Tokenaustausch.

Beispiel für einen Rückgabewert:

{
    "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')"
}

Methoden für das Tokenverhaltensmanagement - Burnable Behavior

BurnBatch

Diese Methode deaktiviert oder verbrennt die angegebenen fungiblen und nicht fungiblen Token. Jeder Benutzer kann diese Methode aufrufen.

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

Parameter:

orgId string – Die Mitgliedschaftsdienstleister-ID (MSP) in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID.
tokenIds []string: Die Liste der zu brennenden Token-IDs
quantity []float64 - Die Liste der zu brennenden Tokenmengen, die dem Token-ID-Array entsprechen.

Rückgabewert:

Bei Erfolg eine Meldung mit Details zu den Burn-Vorgängen.

Beispiel für einen Rückgabewert:

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

Diese Methode deaktiviert oder verbrennt das angegebene nicht fungible Token und gibt ein Tokenobjekt und eine Tokenhistorie zurück. Jeder Benutzer mit der Brennerrolle kann diese Methode aufrufen.

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
      }

Parameter:

orgId: string – Die Mitgliedschaftsdienstleister-ID (MSP) in der aktuellen Organisation.
userId: string: Der Benutzername oder die E-Mail-ID.
tokenId: string - Die ID des nicht fungiblen Tokens zum Verbrennen

Rückgabewert:

Bei Erfolg ein Tokenobjekt im JSON-Format, das Informationen zur Tokenhistorie enthält.

Beispiel für einen Rückgabewert:

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

SDK-Methoden

Methoden für die Zugriffskontrolle

CheckAuthorization

Mit dieser Methode können Sie einem Vorgang eine Zugriffskontrollprüfung hinzufügen. Dies ist eine asynchrone Funktion. Die meisten automatisch generierten Methoden umfassen die Zugriffskontrolle. Bestimmte Tokenmethoden können nur von der ERC721Admin oder Account Owner des Tokens oder von einer MultipleAccountOwner für Benutzer mit mehreren Accounts ausgeführt werden. Die Methode CheckAuthorization ist Teil der Klasse erc721Auth, auf die Sie über das Objekt Ctx zugreifen. Die Zugriffskontrollzuordnung wird in der Datei oChainUtil.go beschrieben, wie im folgenden Text dargestellt. Sie können die Zugriffskontrolle ändern, indem Sie die Datei oChainUtil.go bearbeiten.

  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)

Parameter:

funcName string: Der Zuordnungswert zwischen den Empfängern und Methoden, wie in der Datei oChainUtil.go beschrieben.
args: Ein Variablenargument, bei dem args[0] die Konstante 'TOKEN' übernimmt und args[1] den Parameter accountId verwendet, um eine Zugriffskontrollprüfung für eine AccountOwner hinzuzufügen. Um eine Zugriffskontrollprüfung für eine MultipleAccountOwner hinzuzufügen, übernimmt args[1] den Parameter orgId und args[2] den Parameter userId. Um eine Zugriffskontrollprüfung für eine TokenOwner hinzuzufügen, übernimmt args[1] den Token-ID-Parameter.

Rückgabewert:

Eine bool-Antwort des Fehlers nach Bedarf.

IsUserTokenAdmin

Diese Methode gibt den booleschen Wert true zurück, wenn der angegebene Benutzer ein Token Admin und ansonsten false ist. Die Methode kann nur von einem Token Admin des Token Chaincodes aufgerufen werden.

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

Parameter:

orgId: string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId: string: Der Benutzername oder die E-Mail-ID des Benutzers.

Beispiel für einen Rückgabewert:

{
  "result": true
}

AddAdmin

Diese Methode fügt einen Benutzer als Token Admin des Token Chaincodes hinzu. Die Methode kann nur von einem Token Admin des Token Chaincodes aufgerufen werden.

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

Parameter:

orgId: string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId: string: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

Bei Erfolg eine Meldung, in der Details für den Benutzer aufgeführt werden, der als Token Admin des Token Chaincodes hinzugefügt wurde.

Beispiel für einen Rückgabewert:

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

RemoveAdmin

Diese Methode entfernt einen Benutzer als Token Admin des Token Chaincodes. Die Methode kann nur von einem Token Admin des Token Chaincodes aufgerufen werden. Sie können sich nicht selbst als Token Admin entfernen.

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

Parameter:

orgId: string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId: string: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

Bei erfolgreicher Ausführung eine Meldung mit Details für den Benutzer, die als Token Admin des Token Chaincodes entfernt wurden.

Beispiel für einen Rückgabewert:

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

GetAllAdminUsers

Diese Methode gibt eine Liste aller Token Admin-Benutzer zurück.

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

Parameter:

Kein

Rückgabewert:

Bei Erfolg eine Liste aller Token Admin-Benutzer, identifiziert nach Organisations-ID und Benutzer-ID.

Beispiel für einen Rückgabewert:

{
  "admins": [
    {
      "OrgId": "appdev",
      "UserId": "idcqa"
    },
    {
      "OrgId": "appdev",
      "UserId": "user1"
    }
  ]
}

Methoden für die Verwaltung der Tokenkonfiguration

Save

Diese Methode erstellt Token. Jedes definierte Token verfügt über eine eigene Erstellungsmethode. Wenn bei nicht fungiblen Token die Minter-Rolle in der Spezifikationsdatei definiert ist, kann jeder Benutzer mit der Minter-Rolle diese Methode aufrufen, um eine NFT zu erstellen. Wenn nicht, kann jeder Benutzer diese Methode verwenden, um NFTs zu erstellen (mint). Der Benutzer, der diese Methode aufruft, wird Eigentümer der NFT (ganz oder teilweise).

Ctx.ERC1155Token.Save(token interface{}, quantity ...float64) (interface{}, error)

Parameter:

tokenAsset: interface{}: Das Tokenasset. Die Eigenschaften des Assets werden in der Modelldatei definiert.
quantity: number - Nur für nicht fungible Token die Anzahl der zu prägenden Token. Der einzige unterstützte Wert für diesen Parameter ist 1.

Rückgabewert:

Bei Erfolg das Tokenasset im JSON-Format, das die folgenden Informationen enthält.
Behavior oder Behaviors – Eine Liste der Tokenverhalten. Diese Eigenschaft kann nicht bearbeitet werden.
CreatedBy: Die Account-ID des Aufrufers, der das Token mintet. Diese Eigenschaft kann nicht bearbeitet werden.
CreationDate: Der Zeitstempel der Prägetransaktion. Diese Eigenschaft kann nicht bearbeitet werden.
IsBurned: Diese Eigenschaft gibt an, ob das Token gebrannt wird. Diese Eigenschaft kann nicht bearbeitet werden.
Mintable: Die Eigenschaften für das Prägen. Der Wert max_mint_quantity definiert die maximale Anzahl von Token, die für die Tokenklasse erstellt werden können.
Owner: Die Account-ID des aktuellen Eigentümers, der die Methode aufruft.
Symbol: Das Symbol des Tokens. Diese Eigenschaft kann nicht bearbeitet werden.
TokenDesc: Die Beschreibung des Tokens.
TokenMetadata: JSON-Informationen, die das Token beschreiben.
TokenName: Der Name des Tokens. Diese Eigenschaft kann nicht bearbeitet werden.
TokenStandard: Der Standard des Tokens. Diese Eigenschaft kann nicht bearbeitet werden.
TokenType: Der Typ des Tokens (Fungible oder Nicht-Fungible). Diese Eigenschaft kann nicht bearbeitet werden.
TokenUnit: Die Einheit des Tokens (ganz oder teilweise). Diese Eigenschaft kann nicht bearbeitet werden.
TokenUri: Die URI des Tokens.
Quantity: Die Menge des Tokens.

Beispiel für Rückgabewert (ganzer NFT):

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

Beispiel für Rückgabewert (ungültiges Token):

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

Beispiel für Rückgabewerte (fraktionaler NFT):

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

Diese Methode aktualisiert Token. Sie können keine Tokenmetadaten oder die Token-URI von nicht fungiblen Token aktualisieren.

Ctx.ERC1155Token.Update(tokenAsset interface{}) (interface{}, error)

Parameter:

tokenAsset: interface{}: Das Tokenasset. Die Eigenschaften des Assets werden in der Modelldatei definiert.

Rückgabewert:

Bei Erfolg das aktualisierte Tokenasset im JSON-Format.

Beispiel für Rückgabewert (ganzer NFT):

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

Diese Methode gibt die Historie für eine angegebene Token-ID zurück.

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

Parameter:

tokenId string: Die ID des Tokens.

Rückgabewert:

Bei Erfolg ein JSON-Array, das die Tokenhistorie enthält.

Beispiel für Rückgabewert (ungültiges Token):

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

Beispiel für Rückgabewerte (fraktionaler NFT):

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

Beispiel für Rückgabewert (ganzer NFT):

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

Parameter:

Kein

Beispiel für einen Rückgabewert:

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

Diese Methode gibt ein Tokenobjekt zurück, wenn das Token in der Statusdatenbank vorhanden ist. Diese Methode kann nur von einem Token Admin des Chaincodes oder des Tokeneigentümers aufgerufen werden. Bei NFTs mit Bruchteilen wird auch die Liste der Eigentümer zurückgegeben.

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

Parameter:

id string: Die ID des abzurufenden Tokens.

Beispiel für Rückgabewert (ganzer NFT):

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

Beispiel für Rückgabewert (ungültiges Token):

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

Beispiel für Rückgabewerte (fraktionaler NFT):

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

Parameter:

accountId string: Die Konto-ID des Benutzers.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt die Konto-ID, Organisations-ID und Benutzer-ID des Eigentümers der angegebenen Token-ID zurück.

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

Parameter:

tokenId string: Die ID des Tokens.

Beispiel für einen Rückgabewert:

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

TokenURI

Diese Methode gibt die URI eines angegebenen Tokens zurück. Jeder kann diese Methode nennen.

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

Parameter:

tokenId string: Die ID des Tokens.

Beispiel für einen Rückgabewert:

{
    "TokenUri": "example.com"
}

Name

Diese Methode gibt den Namen der Token-Klasse zurück. Jeder kann diese Methode nennen.

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

Parameter:

tokenId string: Die ID des Tokens.

Beispiel für einen Rückgabewert:

{"TokenName": "artcollection"}

TotalSupply

Diese Methode gibt die Gesamtanzahl der geprägten Token zurück. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben.

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

Parameter:

tokenAsset interface{}: Das Tokenasset.

Beispiel für einen Rückgabewert:

{"TotalSupply": 100}

TotalNetSupply

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

Parameter:

token interface{}: Das Tokenasset.

Beispiel für einen Rückgabewert:

{"TotalNetSupply": 100}

GetTokensByName

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

Parameter:

tokenName: string: Der Name des Tokens.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt die Anzahl der Dezimalstellen für ein angegebenes Token zurück. Wenn das teilbare Verhalten für das Token nicht angegeben ist, wird der Standardwert von null Dezimalstellen zurückgegeben.

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

Parameter:

tokenId: string: Die ID des Tokens.

Beispiel für einen Rückgabewert:

Methoden für die Accountverwaltung

CreateAccount

Ein Benutzerkonto hat eine eindeutige ID, die durch einen SHA-256-Hash des Parameters orgId und des Parameters userId gebildet wird.

Ein Benutzer kann nur einen nicht fungiblen Tokenaccount haben. Konto-IDs für nicht fungible Token sind eindeutig und werden durch einen SHA-256-Hash des Parameters orgId, den Parameter userId und die durch das Tilde-Symbol (~) getrennte konstante Zeichenfolge nft gebildet. Alle nicht fungiblen Token, die ein Benutzer besitzt, unabhängig davon, ob sie ganz oder teilweise sind, sind mit diesem einzigen nicht fungiblen Token-Konto verknüpft.

Ctx.ERC1155Account.CreateAccount(orgId string, userId string, ftAccount bool, nftAccount bool) (ERC1155UserAccount, error)

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
ftAccount bool: Bei "true" wird ein fungibler Tokenaccount erstellt und mit dem Benutzeraccount verknüpft.
nftAccount bool: Bei "true" wird ein nicht fungibler Tokenaccount erstellt und mit dem Benutzeraccount verknüpft.

Rückgabewert:

Bei Erfolg ein JSON-Objekt des erstellten Accounts.

Beispiel für einen Rückgabewert:

{
  "AssetType": "ouaccount",
  "AccountId": "ouaccount~cf20877546f52687f387e7c91d88b9722c97e1a456cc0484f40c747f7804feae",
  "UserId": "user1",
  "OrgId": "appdev",
  "TotalAccounts": 2,
  "TotalFtAccounts": 1,
  "AssociatedFtAccounts": [
    {
      "AccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
      "TokenId": ""
    }
  ],
  "AssociatedNftAccount": "oaccount~73c3e835dac6d0a56ca9d8def08269f83cefd59b9d297fe2cdc5a9083828fa58"
}

CreateUserAccount

Eine Konto-ID ist ein SHA-256-Hash des Parameters orgId und des Parameters userId. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

Ctx.ERC1155Account.CreateUserAccount(orgId string, userId string) (interface{}, error)

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

Bei Erfolg ein JSON-Objekt des erstellten Benutzerkontos.

Beispiel für einen Rückgabewert:

{
  "AssetType": "ouaccount",
  "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
  "UserId": "idcqa",
  "OrgId": "appdev",
  "TotalAccounts": 0,
  "TotalFtAccounts": 0,
  "AssociatedFtAccounts": [],
  "AssociatedNftAccount": ""
}

CreateTokenAccount

Diese Methode erstellt ein fungibles oder nicht fungibles Token-Konto, das einem Benutzerkonto zugeordnet werden kann.

Ein Benutzer kann nur einen nicht fungiblen Tokenaccount haben. Konto-IDs für nicht fungible Token sind eindeutig und werden durch einen SHA-256-Hash des Parameters orgId, den Parameter userId und die durch das Tilde-Symbol (~) getrennte konstante Zeichenfolge nft gebildet. Alle nicht fungiblen Token, die ein Benutzer besitzt, unabhängig davon, ob sie ganz oder teilweise sind, sind mit diesem einzigen nicht fungiblen Token-Konto verknüpft.

Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

Ctx.ERC1155Account.CreateTokenAccount(orgId string, userId string, tokenType string) (ERC1155UserAccount, error)

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.
tokenType erc1155Token.TokenType: Der Typ des zu erstellenden Tokenaccounts. Die einzigen unterstützten Tokentypen sind nonfungible und fungible.

Rückgabewert:

Bei Erfolg ein JSON-Objekt des erstellten Tokenaccounts.

Beispiel für einen Rückgabewert:

{
    "AssetType": "ouaccount",
    "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "TotalAccounts": 1,
    "TotalFtAccounts": 1,
    "AssociatedFtAccounts": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "TokenId": ""
        }
    ],
    "AssociatedNftAccount": ""
}

AssociateTokenToToken

Diese Methode verknüpft das fungible Token-Konto eines Benutzers mit einem bestimmten fungiblen Token.

Ctx.ERC1155Account.AssociateTokenToToken(accountId string, tokenId string) (interface{}, error)

Parameter:

accountId string: Die Benutzeraccount-ID.
tokenId string: Die ID des Tokens.

Rückgabewert:

Bei Erfolg ein JSON-Objekt des Benutzeraccounts, das zeigt, dass das fungible Token dem Tokenaccount zugeordnet wurde. Beispiel: Im folgenden Beispiel zeigt das erste Objekt im Array AssociatedFtAccounts, dass die Account-ID des fungiblen Tokens und die Token-ID verknüpft sind.

Beispiel für einen Rückgabewert:

{
    "AssetType": "ouaccount",
    "AccountId": "ouaccount~24ffd4d32a028a85b4b960f5d55536c837b5429bc7f346150adfa904ec2937cc",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "TotalAccounts": 1,
    "TotalFtAccounts": 1,
    "AssociatedFtAccounts": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "TokenId": "tokenOne"
        }
    ],
    "AssociatedNftAccount": ""
}

GetAccountHistory

Diese Methode gibt die Historie für ein angegebenes Token-Konto zurück.

Ctx.ERC1155Account.GetAccountHistory(accountId string)

Parameter:

accountId string: Die Tokenaccount-ID.

Rückgabewert:

Bei Erfolg ein Array von JSON-Objekten, das die Kontohistorie beschreibt.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt Tokenaccountdetails für einen angegebenen Benutzer zurück, einschließlich Accountstatus. Diese Methode kann nur von einem Token Admin des Chaincodes oder dem Account Owner des Accounts aufgerufen werden.

Ctx.ERC1155Account.GetAccountWithStatus(userAccountId string, tokenId ...string) (interface{}, error)

Parameter:

userAccountId string: Die Konto-ID des Benutzers.
tokenId ...string: Bei einem nicht fungiblen Tokenaccount eine leere Zeichenfolge. Bei einem fungiblen Token-Konto die Token-ID.

Rückgabewert:

Bei Erfolg ein JSON-Objekt, das Tokenaccountdetails einschließlich Accountstatus enthält.

Beispiel für Rückgabewert (Nicht-Fungible Token-Konto):

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

Beispiel für Rückgabewert (Fungible Token-Konto):

{
    "AccountCategory": "",
    "AccountId": "oaccount~2de8db6b91964f8c9009136831126d3cfa94e1d00c4285c1ea3e6d1f36479ed4",
    "AssetType": "oaccount",
    "Balance": 0,
    "BapAccountVersion": 0,
    "OrgId": "appdev",
    "Status": "active",
    "TokenId": "t1",
    "TokenName": "loyalty",
    "TokenType": "fungible",
    "UserId": "idcqa"
}

GetAccount

Diese Methode gibt Tokenaccountdetails für einen angegebenen Benutzer zurück. Diese Methode kann nur von einem Token Admin des Chaincodes oder dem Account Owner des Accounts aufgerufen werden.

Ctx.ERC1155Account.Get(accountId string, tokenId ...string) (interface{}, error)

Parameter:

userAccountId string: Die Konto-ID des Benutzers.
tokenId ...string: Bei einem nicht fungiblen Tokenaccount eine leere Zeichenfolge. Bei einem fungiblen Token-Konto die Token-ID.

Rückgabewert:

Bei Erfolg ein JSON-Objekt, das Tokenaccountdetails enthält.

Beispiel für Rückgabewert (Nicht-Fungible Token-Konto):

{
    "AccountId": "oaccount~e88276a3be547e31b567346bdddde52d37734da4d5fae83ab2e5c98a10097371",
    "BapAccountVersion": 0,
    "AssetType": "oaccount",
    "NoOfNfts": 4,
    "OrgId": "appdev",
    "TokenType": "nonfungible",
    "UserId": "idcqa"
}

Beispiel für Rückgabewert (Fungible Token-Konto):

{
    "AssetType": "oaccount",
    "AccountId": "oaccount~21206f309941a2a23c4f158a0fe1b8f12bb8e2b0c9a2e1358f5efebc0c7d410e",
    "UserId": "idcqa",
    "OrgId": "appdev",
    "BapAccountVersion": 0,
    "TokenType": "fungible",
    "TokenId": "loy1",
    "TokenName": "loyalty",
    "Balance": 90,
    "AccountCategory": ""
}

GetAllAccounts

Diese Methode gibt Details aller Benutzerkonten zurück.

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

Parameter:

Kein

Beispiel für einen Rückgabewert:

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

Diese Methode gibt eine Kontenübersicht für einen angegebenen Benutzer und Details zu fungiblen und nicht fungiblen Token zurück, die dem Benutzer zugeordnet sind.

Ctx.ERC1155Account.GetAccountDetailsByUser(orgId string, userId string) (interface{}, error)

Parameter:

orgId string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
userId string: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

Bei Erfolg ein JSON-Accountobjekt, das eine Zusammenfassung für den angegebenen Benutzer und Details zu fungiblen und nicht fungiblen Token enthält, die dem Benutzer zugeordnet sind. Bei partiellen nicht fungiblen Token zeigt die Eigenschaft tokenShare im Abschnitt associatedNFTs den Anteil an, für den der Benutzer verantwortlich ist.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt die Benutzerdetails einer angegebenen Konto-ID zurück.

Ctx.ERC1155Account.GetUserByAccountById(accountId string) (map[string]interface{}, error)

Parameter:

accountId string: Die ID des Accounts.

Rückgabewert:

Bei Erfolg ein JSON-Objekt der Benutzerdetails (orgId und userId).

Beispiel für einen Rückgabewert:

{
    "OrgId": "appdev",
    "UserId": "idcqa"
}

Methoden für die Rollenverwaltung

AddRoleMember

Mit dieser Methode wird eine Rolle zu einem angegebenen Benutzer und Token hinzugefügt. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben.

Ctx.ERC1155Token.AddRoleMember(userRole string, userAccountId string, asset interface{}) (interface{}, error)

Parameter:

userRole: string: Der Name der Rolle, die dem angegebenen Benutzer hinzugefügt werden soll.
userAccountId: string: Die Konto-ID des Benutzers.
asset: interface{}: Das Tokenasset.

Rückgabewert:

Bei Erfolg eine Nachricht mit Accountdetails.

Beispiel für einen Rückgabewert:

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

IsInRole

Ctx.ERC1155Token.IsInRole(userRole string, userAccountId string, asset interface{}) (bool, error)

Parameter:

userRole: string: Der Name der Rolle, nach der gesucht werden soll.
userAccountId: string: Die Konto-ID des Benutzers.
asset: interface{}: Das Tokenasset.

Beispiel für einen Rückgabewert:

{
    "result": true
}

RemoveRoleMember

Diese Methode entfernt eine Rolle aus einem angegebenen Benutzer und Token. Fungible Token werden durch die Token-ID angegeben. Nicht fungible Token werden durch den Tokennamen angegeben.

Ctx.ERC1155Token.RemoveRoleMember(userRole string, userAccountId string, asset interface{}) (interface{}, error)

Parameter:

userRole: string: Der Name der zu entfernenden Rolle.
userAccountId: string: Die Konto-ID des Benutzers.
asset: interface{}: Das Tokenasset.

Beispiel für einen Rückgabewert:

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

Parameter:

roleName: string: Der Name der Rolle, nach der gesucht werden soll.
token: interface{}: Das Tokenasset.

Beispiel für einen Rückgabewert:

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

GetUsersByRole

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

Parameter:

roleName: string: Der Name der Rolle, nach der gesucht werden soll.
token: interface{}: Das Tokenasset.

Beispiel für einen Rückgabewert:

{
    "Users": [
        {
            "AccountId": "oaccount~1422a74d262a3a55a37cd9023ef8836f765d0be7b49d397696b9961d7434d22a",
            "OrgId": "appdev",
            "UserId": "idcqa"
        },
        {
            "AccountId": "oaccount~60bb20c14a83f6e426e1437c479c5891e1c6477dfd7ad18b73acac5d80bc504b",
            "OrgId": "appdev",
            "UserId": "user1"
        }
    ]
}

Methoden für das Transaktionshistorienmanagement

GetAccountTransactionHistory

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

Parameter:

accountId string: Die Benutzeraccount-ID.

Beispiel für einen Rückgabewert:

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

Diese Methode gibt die Transaktionsdetails für eine angegebene Transaktions-ID zurück.

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

Parameter:

trxId string: Die ID der Transaktion.

Beispiel für einen Rückgabewert:

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

Diese Methode löscht Transaktionen vor einem angegebenen Zeitstempel aus der Statusdatenbank.

Ctx.ERC1155Transaction.DeleteHistoricalTransactions(referenceTime string) (interface{}, error)

Parameter:

referenceTime string: Alle Transaktionen vor diesem Zeitstempel werden gelöscht.

Beispiel für einen Rückgabewert:

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

Methoden für das Tokenverhaltensmanagement - Mintable Behavior

MintBatch

Diese Methode erstellt (mindert) mehrere Token in einem Batchvorgang. Diese Methode erstellt nur fungible Token oder fraktionierte nicht fungible Token.

Sie können diese Methode nicht verwenden, um ein ganzes nicht fungibles Token zu prägen.

Ctx.ERC1155Token.MintBatch(accountId string, tokens []interface{}, quantities []float64) (interface{}, error)

Parameter:

accountId string: Die Konto-ID des Benutzers.
tokenIds []string: Die Liste der Token-IDs, für die Token geprägt werden sollen.
quantity []float64: Die Liste der Mengen der zu prägenden Token, die dem Token-ID-Array entsprechen.

Rückgabewert:

Bei Erfolg ein JSON-Objekt, das Details zu den geprägten Token enthält.

Beispiel für einen Rückgabewert:

{
    "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')"
}

Methoden für das Tokenverhaltensmanagement - Übertragbares Verhalten

BatchTransferFrom

Diese Methode schließt einen Batchvorgang ab, bei dem Token, die in einer Liste mit Token-IDs angegeben sind, von einem Benutzer an einen anderen Benutzer übertragen werden.

Bei NFTs muss der Absender des NFT das Token besitzen, da die Methode das Eigentum an dem NFT überträgt.

Diese Methode validiert nicht, ob der Aufrufer der Methode der angegebene Absender ist.

Ctx.ERC1155Token.BatchTransferFrom(fromAccountId string, toAccountId string, tokens []interface{}, quantities []float64) (interface{}, error)

Parameter:

fromUserAccountId string: Die Konto-ID des Absenders und Tokeneigentümers in der aktuellen Organisation.
toUserAccountId string: Die Konto-ID des Empfängers.
tokenIds string[]: Eine Liste der Token-IDs für die zu übertragenden Token.
quantity float64[]: Die Liste der zu übertragenden Tokenmengen entsprechend dem Token-ID-Array.

Rückgabewert:

Bei erfolgreicher Ausführung wird eine Nachricht mit Details für jede Tokentransfer angezeigt.

Beispiel für einen Rückgabewert:

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

Diese Methode schließt einen Batchvorgang ab, bei dem Token, die in einer Liste mit Token-IDs angegeben sind, von einem Benutzer an einen anderen Benutzer übertragen werden.

Bei NFTs muss der Absender des NFT das Token besitzen, da die Methode das Eigentum an dem NFT überträgt.

Der Aufrufer der Methode muss der angegebene Absender sein.

Ctx.ERC1155Token.SafeBatchTransferFrom(fromAccountId string, toAccountId string, tokens []interface{}, quantities []float64) (interface{}, error)

Parameter:

fromUserAccountId string: Die Konto-ID des Absenders und Tokeneigentümers in der aktuellen Organisation.
toUserAccountId string: Die Konto-ID des Empfängers.
tokenIds string[]: Eine Liste der Token-IDs für die zu übertragenden Token.
quantity float64[]: Die Liste der zu übertragenden Tokenmengen entsprechend dem Token-ID-Array.

Rückgabewert:

Bei erfolgreicher Ausführung wird eine Nachricht mit Details für jede Tokentransfer angezeigt.

Beispiel für einen Rückgabewert:

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

Parameter:

accountIds []string: Eine Liste der Benutzerkonto-IDs.
tokenIds []string: Eine Liste der Token-IDs.

Beispiel für einen Rückgabewert:

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

Diese Methode tauscht Token zwischen angegebenen Konten aus. Diese Methode unterstützt nur den Austausch zwischen einem NFT (ganz oder fraktioniert) und einem fungiblen Token oder einem fungiblen Token und einem NFT (ganz oder fraktioniert). Diese Methode kann nur vom Kontoinhaber aufgerufen werden.

Ctx.ERC1155Token.ExchangeToken(fromTokenId string, fromUserAccountId string, fromTokenQuantity float64, toTokenId string, toUserAccountId string, toTokenQuantity float64) (interface{}, error)

Parameter:

fromTokenId string: Die ID des Tokens, dessen Eigentümer der Absender ist.
fromUserAccountId string: Die Konto-ID des Absenders.
fromTokenQuantity float64 - Die Anzahl der Token vom Absender, die mit dem Empfänger ausgetauscht werden sollen.
toTokenId string: Die ID des Tokens, dessen Eigentümer der Empfänger ist.
toUserAccountId string: Die Konto-ID des Empfängers.
toTokenQuantity float64 - Die Anzahl der Token vom Empfänger, die mit dem Absender ausgetauscht werden sollen.

Rückgabewert:

Bei Erfolg eine Nachricht mit Details zum Tokenaustausch.

Beispiel für einen Rückgabewert:

{
    "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')"
}

Methoden für das Tokenverhaltensmanagement - Burnable Behavior

Burn

Diese Methode deaktiviert oder verbrennt die angegebenen fungiblen und nicht fungiblen Token.

Ctx.ERC1155Token.Burn(accountId string, tokens []interface{}, quantities []float64) (interface{}, error)

Parameter:

accountId string: Die Konto-ID des Benutzers.
tokenIds []string: Die Liste der zu brennenden Token-IDs.
quantity []float64: Die Liste der zu brennenden Tokenmengen entsprechend dem Token-ID-Array.

Rückgabewert:

Bei Erfolg eine Meldung mit Details zu den Burn-Vorgängen.

Beispiel für einen Rückgabewert:

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