Scaffolded Go NFT-Projekt für ERC-721

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

Das Projekt generiert automatisch NFT-Lebenszyklusklassen 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 NFTs in Zusammenhang stehen, finden Sie unter Scaffolded Go Chaincode Project.

Referenz:

• Modell
• Controller
  • Automatisch generierte NFT-Methoden
  • Benutzerdefinierte Methoden
• NFT-SDK-Methoden

Modell

Transparent Persistence Capability (transparente Persistenzfunktion) oder vereinfachtes ORM wird in der Klasse OchainModel erfasst.

package model

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

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

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

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

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

	TokenMetadata ArtCollectionMetadata `json:"TokenMetadata"`

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

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

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 NFT-Methoden

Blockchain App Builder generiert automatisch Methoden zur Unterstützung von NFTs und NFT-Lebenszyklen. Mit diesen Methoden können Sie NFTs initialisieren, Rollen und Konten verwalten und andere NFT-Lebenszyklusaufgaben ohne zusätzliche Codierung ausführen.

Blockchain App Builder generiert automatisch Methoden zur Unterstützung von NFTs und NFT-Lebenszyklen. Mit diesen Methoden können Sie NFTs initialisieren, Rollen und Konten verwalten und andere NFT-Lebenszyklusaufgaben 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.

• Access Control Management
• Tokenkonfigurationsverwaltung
• Accountverwaltung
• Rollenverwaltung
• Verwaltung der Transaktionshistorie
• Tokenverhaltensverwaltung
  • Unbedingtes Verhalten
  • Übertragbares Verhalten
  • Brennbares Verhalten

Methoden für die Zugriffskontrolle

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.ERC721Auth.CheckAuthorization("ERC721ADMIN.AddAdmin", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Admin.AddAdmin(orgId, userId)
}

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: Org1MSP, 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 diese Methode nicht verwenden, um sich selbst als Token Admin zu entfernen.

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

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 Org1MSP UserId user1)"}

IsTokenAdmin

Diese Methode gibt den booleschen Wert true zurück, wenn der Aufrufer der Funktion ein Token Admin ist. Andernfalls wird false zurückgegeben. Eine Token Admin kann diese Funktion bei jedem anderen Benutzer im Blockchain-Netzwerk aufrufen. Andere Benutzer können diese Methode nur für ihre eigenen Konten aufrufen.

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

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}

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.ERC721Auth.CheckAuthorization("ERC721ADMIN.GetAllAdmins", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Admin.GetAllAdminUsers()
}

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg eine JSON-Liste der Administratoren, die OrgId- und UserId-Objekte enthält.

Beispiel für einen Rückgabewert:

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

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 ([]). Alle anderen Informationen im Parameter adminList werden bei Upgrades ignoriert.

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

Parameter:

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

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 von Berkeley DB und kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Netzwerk von Oracle Blockchain Platform besteht.

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

Parameter:

• Kein

Rückgabewert:

• Eine Liste aller Tokenassets im JSON-Format.

Beispiel für einen Rückgabewert:

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

GetAllTokensByUser

Diese Methode gibt alle Tokenassets zurück, deren Eigentümer ein angegebener Benutzer ist. Diese Methode verwendet SQL-Rich-Abfragen von Berkeley DB und kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Netzwerk von Oracle Blockchain Platform 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.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetAllTokensByUser", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
    return t.Ctx.ERC721Token.GetAllTokensByUser(accountId)
}

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:

• Eine Liste der Tokenassets im JSON-Format.

Beispiel für einen Rückgabewert:

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

GetTokenById

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.

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

Parameter:

• tokenId: string: Die ID des abzurufenden Tokens.

Rückgabewert:

• Das Tokenasset im JSON-Format.

Beispiel für einen Rückgabewert:

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

GetTokenHistory

Diese Methode gibt die Historie für eine angegebene Token-ID zurück. Diese Methode kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Oracle Blockchain Platform-Netzwerk besteht. Jeder kann diese Methode nennen.

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

Parameter:

• tokenId: string: Die ID des Tokens.

Beispiel für einen Rückgabewert:

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

getTokenObject

Dies ist eine Utilitymethode, die eine Instanz des Tokens für eine angegebene Token-ID zurückgibt. Diese Methode wird von vielen automatisch generierten Methoden zum Abrufen von Tokenobjekten verwendet. Sie können diese Methode nach Bedarf über Ihre benutzerdefinierten Methoden aufrufen. Wenn Sie ein tokenisiertes Asset oder eine tokenisierte Klasse erstellen, aktualisieren Sie die Switch-Groß-/Kleinschreibung mit der entsprechenden Token-Klasse, um das korrekte Tokenobjekt zurückzugeben. Der Befehl ochain sync in Blockchain App Builder erstellt automatisch einen Wechselfall, wenn ein tokenisiertes Asset in der Spezifikationsdatei erstellt wird. Da diese Methode privat ist, ist sie nicht direkt aufrufbar und kann nur von anderen Methoden aufgerufen werden.

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

Parameter:

• tokenId: string: Die ID des Tokens.

OwnerOf

Diese Methode gibt die Konto-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.ERC721Token.OwnerOf(tokenId)
}

Parameter:

• tokenId: string: Die ID des Tokens.

Rückgabewert:

• Ein JSON-Objekt der Account-ID des Verantwortlichen.

Beispiel für einen Rückgabewert:

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}

Name

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

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

Parameter:

• Kein

Rückgabewert:

• Ein JSON-Objekt mit dem Tokennamen.

Beispiel für einen Rückgabewert:

{"TokenName": "paintingnft"}

Symbol

Diese Methode gibt das Symbol der Token-Klasse zurück. Jeder kann diese Methode nennen.

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

Parameter:

• Kein

Rückgabewert:

• Ein JSON-Objekt des Tokensymbols.

Beispiel für einen Rückgabewert:

{"Symbol": "PNT"}

TokenURI

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

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

Parameter:

• tokenId: string: Die ID des Tokens.

Rückgabewert:

• Bei Erfolg ein JSON-Objekt der Token-URI.

Beispiel für einen Rückgabewert:

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

TotalSupply

Diese Methode gibt die Gesamtanzahl der geprägten Token zurück. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg ein JSON-Objekt der Tokenanzahl.

Beispiel für einen Rückgabewert:

{"TotalSupply": 3}

TotalNetSupply

Diese Methode gibt die Gesamtanzahl der geprägten Token abzüglich der Anzahl der gebrannten Token zurück. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg ein JSON-Objekt der Tokenanzahl.

Beispiel für einen Rückgabewert:

{"TotalNetSupply": 2}

Methoden für die Accountverwaltung

CreateAccount

Diese Methode erstellt einen Account für einen angegebenen Benutzer und ein bestimmtes Token. Ein Konto muss für jeden Benutzer erstellt werden, der zu einem beliebigen Zeitpunkt Token hat. Konten verfolgen die Anzahl der NFTs, die ein Benutzer hat. Benutzer müssen über Konten im Netzwerk verfügen, um tokenbezogene Vorgänge abzuschließen. Sie können nur ein NFT-Konto pro Benutzer erstellen.

Eine Account-ID ist ein alphanumerisches Zeichenset mit dem Präfix oaccount~, gefolgt von einem SHA-256-Hash der Mitgliedschaftsserviceprovider-ID (OrgId) des Benutzers in der aktuellen Netzwerkorganisation, dem Benutzernamen oder der E-Mail-ID (UserId) des Instanzeigentümers oder des Benutzers, der bei der Instanz angemeldet ist, und der konstanten Zeichenfolge nft. Diese Methode kann nur vom Token Admin des Chaincodes aufgerufen werden.

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

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: string: Der einzige unterstützte Tokentyp ist nonfungible.

Rückgabewert:

• Bei Erfolg ein JSON-Objekt des erstellten Accounts.

Beispiel für einen Rückgabewert:

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

BalanceOf

Diese Methode gibt die Gesamtanzahl der NFTs zurück, die ein bestimmter Benutzer enthält. Diese Methode kann nur von einem Token Admin des Chaincodes oder vom Accounteigentümer aufgerufen werden.

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

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:

• Ein JSON-Objekt der aktuellen NFT-Anzahl.

Beispiel für einen Rückgabewert:

{"totalNfts": 0}

GetAllAccounts

Diese Methode gibt eine Liste aller Konten zurück. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden. Diese Methode verwendet SQL-Rich-Abfragen von Berkeley DB und kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Netzwerk von Oracle Blockchain Platform besteht.

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

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg ein JSON-Array aller Konten.

Beispiel für einen Rückgabewert:

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

GetAccountByUser

Diese Methode gibt Kontodetails 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) GetAccountByUser(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.GetAccountByUser", "TOKEN", map[string]string{"orgId": orgId, "userId": userId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Account.GetAccountWithStatusByUser(orgId, userId)
}

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 die folgenden Eigenschaften enthält:
• AccountId: Die ID des Benutzeraccounts.
• UserId: Der Benutzername oder die E-Mail-ID des Benutzers.
• OrgId - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
• TokenType: Der Typ des Tokens, das der Account enthält.
• NoOfNfts - Die Gesamtanzahl der NFTs, die vom Konto gehalten werden.
• BapAccountVersion: Ein Accountobjektparameter für die interne Verwendung.
• Status: Der aktuelle Status des Benutzeraccounts.

Beispiel für einen Rückgabewert:

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

GetUserByAccountId

Diese Methode gibt die Benutzerdetails eines angegebenen Accounts zurück. Diese Methode kann von jedem Benutzer aufgerufen werden.

func (t *Controller) GetUserByAccountId(accountId string) (interface{}, error) {
      return t.Ctx.ERC721Account.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": "Org1MSP",
    "UserId": "admin"
}

GetAccountHistory

Diese Methode gibt die Kontohistorie für einen angegebenen Benutzer zurück. Diese Methode kann nur von einem Token Admin des Chaincodes oder vom Accounteigentümer aufgerufen werden.

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

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 Liste von Objekten.

Beispiel für einen Rückgabewert:

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

Methoden für die Rollenverwaltung

AddRole

Mit dieser Methode wird eine Rolle zu einem angegebenen Benutzer hinzugefügt. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

• userRole: string: Der Name der Rolle, die dem angegebenen Benutzer hinzugefügt werden soll. Die Verhaltensweisen mintable und burnable entsprechen den Eigenschaften minter_role_name und burner_role_name der Spezifikationsdatei.
• 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 mit Benutzerdetails.

Beispiel für einen Rückgabewert:

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

RemoveRole

Diese Methode entfernt eine Rolle von einem angegebenen Benutzer. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

• userRole: string: Der Name der Rolle, die aus dem angegebenen Benutzer entfernt werden soll. Die Verhaltensweisen mintable und burnable entsprechen den Eigenschaften minter_role_name und burner_role_name der Spezifikationsdatei.
• 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 mit Benutzerdetails.

Beispiel für einen Rückgabewert:

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

GetAccountsByRole

Diese Methode gibt eine Liste aller Konto-IDs für eine angegebene Rolle zurück. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

• userRole: string: Der Name der Rolle, nach der gesucht werden soll.

Rückgabewert:

• Bei Erfolg ein JSON-Array mit Konto-IDs.

Beispiel für einen Rückgabewert:

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

GetUsersByRole

Diese Methode gibt eine Liste aller Benutzer für eine angegebene Rolle zurück. Diese Methode kann nur von einem Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

• userRole: string: Der Name der Rolle, nach der gesucht werden soll.

Rückgabewert:

• Bei Erfolg ein JSON-Array der Benutzerobjekte (orgId und userId).

Beispiel für einen Rückgabewert:

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

IsInRole

Diese Methode gibt einen booleschen Wert zurück, um anzugeben, ob ein Benutzer über eine angegebene Rolle verfügt. Diese Methode kann nur von einem Token Admin des Chaincodes oder dem Account Owner des Accounts aufgerufen werden.

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

Parameter:

• orgId: string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
• userId: string: Der Benutzername oder die E-Mail-ID des Benutzers.
• userRole: string: Der Name der Rolle, nach der gesucht werden soll.

Rückgabewert:

• Bei Erfolg eine JSON-Zeichenfolge des booleschen Ergebnisses.

Beispiel für einen Rückgabewert:

{"result":"true"}

Methoden für das Transaktionshistorienmanagement

GetAccountTransactionHistory

Diese Methode gibt die Kontotransaktionshistorie für einen angegebenen Benutzer zurück. Diese Methode kann vom Token Admin des Chaincodes oder vom Eigentümer des Accounts aufgerufen werden.

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

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

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 Liste von Objekten.

Beispiel für einen Rückgabewert:

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

GetAccountTransactionHistoryWithFilters

Diese Methode gibt die Kontotransaktionshistorie für einen angegebenen Benutzer zurück, gefiltert nach PageSize, Bookmark, StartTime und EndTime. Diese Methode 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) GetAccountTransactionHistoryWithFilters(orgId string, userId string, filters ...erc721Account.AccountHistoryFilters) (interface{}, error) {
      accountId, err := t.Ctx.ERC721Account.GenerateAccountId(orgId, userId)
      if err != nil {
            return nil, err
      }
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ACCOUNT.GetAccountTransactionHistoryWithFilters", "TOKEN", map[string]string{"accountId": accountId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }

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

Parameter:

• orgId: string - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
• userId: string: Der Benutzername oder die E-Mail-ID des Benutzers.
• filters: string: Ein optionaler Parameter. Wenn leer, werden alle Datensätze zurückgegeben. Die Eigenschaft PageSize bestimmt die Anzahl der zurückzugebenden Datensätze. Wenn PageSize 0 ist, ist die Standardseitengröße 20. Die Eigenschaft Bookmark bestimmt den Anfangsindex der zurückzugebenden Datensätze. Weitere Informationen finden Sie in der Hyperledger Fabric-Dokumentation. Die Eigenschaften StartTime und EndTime müssen im RFC-3339-Format angegeben werden.

Rückgabewert:

• Bei Erfolg eine Liste von Objekten.

Beispiel für einen Rückgabewert:

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

GetTransactionById

Diese Methode gibt die Transaktionshistorie für eine angegebene Transaktions-ID zurück. Diese Methode kann nur von einem Token Admin des Chaincodes oder vom Accounteigentümer aufgerufen werden.

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

Parameter:

• transactionId: string: Die ID des Transaktionsassets.

Rückgabewert:

• Bei Erfolg eine Liste von Objekten.

Beispiel für einen Rückgabewert:

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

DeleteHistoricalTransactions

Diese Methode löscht Transaktionen, die älter sind als ein bestimmter Zeitstempel in der Statusdatenbank. Diese Methode kann nur vom Token Admin des Chaincodes aufgerufen werden.

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

Parameter:

• timestamp: Date – Ein Zeitstempel. Alle Transaktionen vor dem Zeitstempel werden gelöscht.

Rückgabewert:

• Bei Erfolg eine Liste von Objekten.

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

Create<Token Name>Token

Diese Methode erstellt (mints) einen NFT. Das Asset und die zugehörigen Eigenschaften werden in der Statusdatenbank gespeichert. Der Aufrufer dieser Transaktion muss ein Token-Konto haben. Der Anrufer dieser Transaktion wird Eigentümer der NFT. Wenn die Tokenspezifikationsdatei den Abschnitt roles für behaviors und die Eigenschaft minter_role_name für roles enthält, muss der Aufrufer der Transaktion die Minter-Rolle haben. Ansonsten kann jeder Anrufer NFTs prägen.

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

Parameter:

• tokenAsset: <Token Class>: Das Tokenasset für die Minze. Weitere Informationen zu den Eigenschaften des Tokenassets finden Sie in der Eingabespezifikationsdatei.

Rückgabewert:

• Bei Erfolg ein JSON-Tokenassetobjekt, das die folgenden Eigenschaften enthält:
• Behavior: Eine Beschreibung aller Tokenverhaltensweisen.
• CreatedBy: Die Konto-ID des Benutzers, der die Transaktion aufgerufen hat, um das Token zu prägen.
• CreationDate: Der Zeitstempel der Transaktion.
• IsBurned: Ein boolescher Wert, der angibt, ob der mit tokenId identifizierte NFT gebrannt wird.
• Mintable: Eine Beschreibung der Eigenschaften desprägnierbaren Verhaltens. Die Eigenschaft max_mint_quantity gibt die maximale Anzahl von NFTs dieser Tokenklasse an, die erstellt werden können.
• Owner: Die Konto-ID des aktuellen Eigentümers des Tokens. Während des Prägeprozesses wird der Aufrufer dieser Methode zum Eigentümer des Tokens.
• Symbol: Das Symbol des Tokens.
• TokenDesc: Die Beschreibung des Tokens.
• TokenMetadata: JSON-Informationen, die das Token beschreiben.
• TokenName: Der Name des Tokens.
• TokenStandard: Der Standard des Tokens.
• TokenType: Der Typ des Tokens, der von diesem Konto gehalten wird.
• TokenUnit: Die Einheit des Tokens.
• TokenUri: Die URI des Tokens.

Beispiel für einen Rückgabewert:

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

Update<Token Name>Token

Diese Methode aktualisiert Tokeneigenschaften. Diese Methode kann nur von dem Benutzer aufgerufen werden, der Eigentümer oder Ersteller des Tokens ist. Nachdem ein Tokenasset erstellt wurde, kann nur der Tokeneigentümer die benutzerdefinierten Eigenschaften des Tokens aktualisieren. Wenn der Benutzer sowohl Tokeneigentümer als auch Ersteller eines Tokens ist, kann er auch die Eigenschaft TokenDesc aktualisieren. Tokenmetadaten können nicht aktualisiert werden. Sie müssen alle Tokeneigenschaften an diese Methode übergeben, auch wenn Sie nur bestimmte Eigenschaften aktualisieren möchten.

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

Parameter:

• tokenAsset: <Token Class>: Das zu aktualisierende Tokenasset. Weitere Informationen zu den Eigenschaften des Tokenassets finden Sie in der Eingabespezifikationsdatei.

Rückgabewert:

• Bei Erfolg ein aktualisiertes JSON-Tokenassetobjekt

Beispiel für einen Rückgabewert:

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

Methoden für das Tokenverhaltensmanagement - Übertragbares Verhalten

SafeTransferFrom

Diese Methode überträgt die Verantwortung für den angegebenen NFT vom Aufrufer auf ein anderes Konto. Diese Methode umfasst die folgenden Validierungen:

• Der Token existiert und wird nicht verbrannt.
• Das Absenderkonto und das Empfängerkonto sind vorhanden und nicht dasselbe Konto.
• Das Absenderkonto ist Eigentümer des Tokens.
• Der Aufrufer der Funktion ist der Absender.

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

Parameter:

• fromOrgId: string - Die Mitgliedschaftsdienstleister-ID (MSP) des Absenders in der aktuellen Organisation.
• fromUserId: string: Der Benutzername oder die E-Mail-ID des Absenders.
• 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.
• tokenId: string: Die ID des zu übertragenden Tokens.
• data: string: Optionale zusätzliche Informationen zum Speichern im Transaktionsdatensatz.

Rückgabewert:

• Bei erfolgreicher Ausführung eine Nachricht mit den Details zum Absender- und Empfängerkonto.

Beispiel für einen Rückgabewert:

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

TransferFrom

Diese Methode überträgt die Verantwortung für den angegebenen NFT von einem Absenderkonto auf ein Empfängerkonto. Es liegt in der Verantwortung des Aufrufers, die richtigen Parameter zu übergeben. Diese Methode kann von jedem Benutzer aufgerufen werden, nicht nur vom Token-Eigentümer. Diese Methode umfasst die folgenden Validierungen:

• Der Token existiert und wird nicht verbrannt.
• Das Absenderkonto und das Empfängerkonto sind vorhanden und nicht dasselbe Konto.
• Das Absenderkonto ist Eigentümer des Tokens.

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

Parameter:

• fromOrgId: string - Die Mitgliedschaftsdienstleister-ID (MSP) des Absenders in der aktuellen Organisation.
• fromUserId: string: Der Benutzername oder die E-Mail-ID des Absenders.
• 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.
• tokenId: string: Die ID des zu übertragenden Tokens.

Rückgabewert:

• Bei erfolgreicher Ausführung eine Nachricht mit den Details zum Absender- und Empfängerkonto.

Beispiel für einen Rückgabewert:

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

Methoden für das Tokenverhaltensmanagement - Burnable Behavior

Burn

Diese Methode deaktiviert oder brennt den angegebenen NFT aus dem Account des Aufrufers. Der Aufrufer dieser Methode muss über ein Konto verfügen. Ein Token kann nur gebrannt werden, wenn die Tokenspezifikationsdatei das Verhalten burnable enthält. Wenn im Abschnitt roles der Spezifikationsdatei keine Eigenschaft burner_role_name angegeben ist, kann der Eigentümer des Tokens das Token brennen. Wenn im Abschnitt roles eine Eigenschaft burner_role_name angegeben wird, kann der Benutzer, dem die Brennerrolle zugewiesen wurde, die auch der Minter (Ersteller) des Tokens ist, das Token brennen.

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

Parameter:

• tokenId: string: Die ID des zu brennenden Tokens.

Rückgabewert:

• Bei Erfolg wird eine Meldung mit den Accountdetails angezeigt.

Beispiel für einen Rückgabewert:

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

BurnNFT

Diese Methode deaktiviert oder brennt die angegebene NFT aus dem Account des Aufrufers und gibt ein Tokenobjekt und eine Tokenhistorie zurück. Der Aufrufer dieser Methode muss über ein Konto verfügen. Ein Token kann nur gebrannt werden, wenn die Tokenspezifikationsdatei das Verhalten burnable enthält. Wenn im Abschnitt roles der Spezifikationsdatei keine Eigenschaft burner_role_name angegeben ist, kann der Eigentümer des Tokens das Token brennen. Wenn im Abschnitt roles eine Eigenschaft burner_role_name angegeben ist, kann der Benutzer, dem die Brennerrolle zugewiesen wurde, die auch der Minter (Ersteller) oder Eigentümer des Tokens ist, das Token brennen.

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

Parameter:

• tokenId: string: Die ID des zu brennenden Tokens.

Rückgabewert:

• Bei Erfolg ein Tokenobjekt, das Informationen zur Tokenhistorie enthält.

Beispiel für einen Rückgabewert:

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

Benutzerdefinierte Methoden

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

Das folgende Beispiel zeigt, wie Sie Token-SDK-Methoden in benutzerdefinierten Methoden verwenden. Wenn die Methode Sell aufgerufen wird, wird ein Token für den Verkauf zu einem angegebenen Preis veröffentlicht.

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

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

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

NFT-SDK-Methoden

• Access Control Management
• Tokenkonfigurationsverwaltung
• Accountverwaltung
• Rollenverwaltung
• Verwaltung der Transaktionshistorie
• Tokenverhaltensverwaltung
  • Unbedingtes Verhalten
  • Übertragbares Verhalten
  • Brennbares Verhalten

Methoden für die Zugriffskontrolle

Das NFT SDK bietet eine Zugriffskontrollfunktion. Einige Methoden können nur von einem Token Admin oder Account Owner des Tokens aufgerufen werden. Mit dieser Funktion können Sie sicherstellen, dass Vorgänge nur von den beabsichtigten Benutzern ausgeführt werden. Jeder nicht autorisierte Zugriff führt zu einem Fehler. Um die Zugriffskontrollfunktion zu verwenden, importieren Sie die Klasse Authorization aus dem Modul ../lib/auth.

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

CheckAuthorization

Mit dieser Methode können Sie einem Vorgang eine Zugriffskontrollprüfung hinzufügen. Die meisten automatisch generierten Methoden umfassen die Zugriffskontrolle. Bestimmte Tokenmethoden können nur von einem ERC721Admin oder dem Account Owner des Tokens oder von MultipleAccountOwner für Benutzer mit mehreren Accounts ausgeführt werden. Die Methode CheckAuthorization ist Teil des Packages erc721Auth, auf das Sie über die Struktur Ctx (Empfänger) 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. Um Ihre eigene Zugriffskontrolle zu verwenden oder die Zugriffskontrolle zu deaktivieren, entfernen Sie den Zugriffskontrollcode aus den automatisch generierten Controllermethoden und benutzerdefinierten Methoden.

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

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

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

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

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

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

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

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

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, verwendet args[1] den Parameter tokenId.

Rückgabewert:

• Eine boolesche Antwort und bei Bedarf ein Fehler.

Beispiele:

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

Admin-Zugriff

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

AccountOwner-Zugriff

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

MultipleAccountOwner-Zugriff

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

TokenOwner-Zugriff

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

IsUserTokenAdmin

Diese Methode gibt eine Zuordnung mit dem booleschen Wert true zurück, wenn der Aufrufer der Funktion ein Token Admin ist. Andernfalls gibt die Methode false zurück.

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

Parameter:

• orgId – Die Mitgliedschaftsdienstleister-ID (MSP) des Benutzers in der aktuellen Netzwerkorganisation.
• userId: Der Benutzername oder die E-Mail-ID des Benutzers.

Rückgabewert:

• Eine boolesche Antwort.

Beispiel:

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

{"result":true}

AddAdmin

Diese Methode fügt einen Benutzer als Token Admin des Token Chaincodes hinzu.

Ctx.ERC721Admin.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. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

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

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

RemoveAdmin

Diese Methode entfernt einen Benutzer als Token Admin des Token Chaincodes.

Ctx.ERC721Admin.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. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

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

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

GetAllAdmins

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

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

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg eine Liste aller Token Admin-Benutzer. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Admin.GetAllAdmins()

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

GetAllAdminUsers

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

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

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg eine Liste aller Token Admin-Benutzer im Format map[string]interface{}. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Admin.GetAllAdminUsers()

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

Methoden für die Verwaltung der Tokenkonfiguration

CreateToken

Diese Methode erstellt ein Token und speichert seine Eigenschaften in der Statusdatenbank. Diese Methode kann nur von Benutzern mit der Minter-Rolle aufgerufen werden.

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

Parameter:

• Ein Variablenargument, bei dem args[0] eine Referenz auf das Token struct des erforderlichen Typs enthält.

Rückgabewert:

• Bei Erfolg eine interface[] mit Tokendetails. Bei Fehler ein Nicht-Nil-Objekt mit einer Fehlermeldung.

Beispiel:

t.Ctx.ERC721Token.CreateToken(&tokenAsset)

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

GetTokenUri

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

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

Parameter:

• tokenId: string: Die ID des Tokens.

Rückgabewert:

• Bei Erfolg gibt es eine Zuordnung der neuen Token-URI im Datentyp String zurück. Bei Fehler ein Nicht-Nil-Objekt mit einer Fehlermeldung.

Beispiel:

t.Ctx.ERC721Token.GetTokenURI(tokenId)

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

TokenUri

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

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

Parameter:

• tokenId: string: Die ID des Tokens.

Rückgabewert:

• Bei Erfolg gibt es eine Zuordnung der neuen Token-URI im Datentyp String zurück. Bei Fehler ein Nicht-Nil-Objekt mit einer Fehlermeldung.

Beispiel für einen Rückgabewert:

t.Ctx.ERC721Token.TokenURI(tokenId)

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

Symbol

Diese Methode gibt das Symbol der Token-Klasse zurück.

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

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg eine Karte des Symbols im Datentyp "Zeichenfolge". Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}

Name

Diese Methode gibt den Namen der Token-Klasse zurück.

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

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg eine Zuordnung des Tokennamens im Datentyp "Zeichenfolge". Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Token.Name()

{"TokenName": "paintingnft"}

OwnerOf

Diese Methode gibt die Konto-ID des Eigentümers eines angegebenen Tokens zurück.

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

Parameter:

• tokenId: string: Die ID des Tokens.

Rückgabewert:

• Bei Erfolg eine Zuordnung der Account-ID des Eigentümers im Datentyp "Zeichenfolge". Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Token.OwnerOf(tokenId)

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}

TotalSupply

Diese Methode gibt die Gesamtanzahl der geprägten NFTs zurück.

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

Parameter:

• tokenId: string: Die ID des Tokens.

Rückgabewert:

• Bei Erfolg eine Karte der Gesamtmenge an Token im Datentyp "Number". Bei Fehler eine Ablehnung mit einer Fehlermeldung.

Beispiel:

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}

GetAllTokens

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

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

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg eine Karte aller Tokenassets. Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Token.GetAllTokens()

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

GetAllTokensByUser

Diese Methode gibt alle Token zurück, für die eine angegebene Konto-ID verantwortlich ist. Diese Methode verwendet SQL-Rich-Abfragen von Berkeley DB und kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Netzwerk von Oracle Blockchain Platform besteht.

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

Parameter:

• accountId: string: Die ID des Accounts.

Rückgabewert:

• Bei Erfolg eine Zuordnung von Tokenassets für das angegebene Konto. Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Token.GetAllTokensByUser(accountId)

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

Get

Diese Methode gibt das angegebene Tokenobjekt zurück, wenn es in der Statusdatenbank vorhanden ist.

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

Parameter:

• tokenId: string: Die ID des Tokens.
• result: Ein Variablenargument, bei dem das erste Argument result[0] eine Referenz auf ein leeres Token-Objekt des richtigen Typs ist, das die Tokendaten nach einem erfolgreichen Aufruf der Methode enthält.

Rückgabewert:

• Bei Erfolg eine Karte mit den Tokenassetdaten. Wenn result[0] übergeben wird, werden die Daten auch result[0] zugewiesen. Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

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

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

UpdateToken

Diese Methode aktualisiert Tokeneigenschaften. Diese Methode kann nur vom Eigentümer oder Ersteller des Tokens aufgerufen werden. Nachdem ein Tokenasset erstellt wurde, kann nur der Tokeneigentümer die benutzerdefinierten Eigenschaften des Tokens aktualisieren. Wenn der Benutzer sowohl Tokeneigentümer als auch Ersteller eines Tokens ist, kann er auch die Eigenschaft TokenDesc aktualisieren. Tokenmetadaten können nicht aktualisiert werden. Sie müssen alle Tokeneigenschaften an diese Methode übergeben, auch wenn Sie nur bestimmte Eigenschaften aktualisieren möchten.

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

Parameter:

• Eine Referenz auf die Tokenstrukturdaten des erforderlichen Typs

Rückgabewert:

• Bei Erfolg eine Promise-Nachricht mit Tokendetails. Bei Fehler eine Ablehnung mit einer Fehlermeldung.

Beispiel:

t.Ctx.ERC721Token.UpdateToken(&asset)

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

History

Diese Methode gibt die Historie für das angegebene Token zurück.

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

Parameter:

• tokenId: string: Die ID des Tokens.

Rückgabewert:

• Zum Erfolg eine Reihe von Karten. Bei Fehler eine Ablehnung mit einer Fehlermeldung.

Beispiel:

t.Ctx.ERC721Token.History(tokenId)

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

GetNewCtx

Diese Methode gibt ein neues TrxContext-Objekt zurück. Die Struktur trxcontext enthält Referenzen auf alle SDK-Librarys. Greifen Sie nur mit diesem Objekt auf die SDK-Methoden zu. Das Objekt trxcontext behält die gegenseitige Ausschließlichkeit von Transaktions-Stubs in SDK-Librarys bei, wenn gleichzeitige Transaktionen ausgeführt werden.

GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext

Parameter:

• stub: Der Transaktionsstub.

Rückgabewert:

• Eine trxcontext-Struktur.

Beispiel:

trxcontext.GetNewCtx(stub)

trxcontext object.

Methoden für die Accountverwaltung

GenerateAccountId

Diese Methode gibt eine Konto-ID zurück, die gebildet wird, indem die Mitgliedsdienstleister-ID (orgId) und der Benutzername oder die E-Mail-ID (userId) verkettet und dann ein SHA-256-Hash erstellt wird.

Ctx.ERC721Account.GenerateAccountId(orgId string, userId string) (string, 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 die generierte Konto-ID. Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

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

oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507

CreateAccount

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. Konten verfolgen die Anzahl der NFTs, die ein Benutzer hat. Benutzer müssen über Konten im Netzwerk verfügen, um tokenbezogene Vorgänge abzuschließen. Sie können nur ein NFT-Konto pro Benutzer erstellen.

Eine Account-ID ist ein alphanumerisches Zeichenset mit dem Präfix oaccount~, gefolgt von einem SHA-256-Hash der Mitgliedschaftsserviceprovider-ID (org_id) des Benutzers in der aktuellen Netzwerkorganisation, dem Benutzernamen oder der E-Mail-ID (userId) des Instanzeigentümers oder des Benutzers, der bei der Instanz angemeldet ist, und der konstanten Zeichenfolge nft.

Ctx.ERC721Account.CreateAccount(orgId string, userId string, tokenType string) (ERC721Account, 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: string: Der einzige unterstützte Tokentyp ist nonfungible.

Rückgabewert:

• Bei Erfolg das neue Firmenobjekt. Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält

Beispiel:

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

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

GetAllAccounts

Diese Methode gibt eine Liste aller Konten zurück. Diese Methode verwendet SQL-Rich-Abfragen von Berkeley DB und kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Netzwerk von Oracle Blockchain Platform besteht.

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

Parameter:

• Kein

Rückgabewert:

• Ein JSON-Array aller Konten.

Beispiel:

t.Ctx.ERC721Account.GetAllAccounts()

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

History

Diese Methode gibt ein Array der Kontohistoriendetails für ein angegebenes Konto zurück.

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

Parameter:

• accountId: string: Die ID des Accounts.

Rückgabewert:

• Bei Erfolg ein map[string]interface{}-Array, das die Accounthistoriendetails für den angegebenen Account enthält. Die Kontodaten werden in der Karte unter dem Schlüssel value angezeigt. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Account.History(accountId)

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

GetUserByAccountId

Diese Methode gibt die Benutzerdetails für einen angegebenen Account zurück.

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

Parameter:

• accountId: string: Die ID des Accounts.

Rückgabewert:

• Bei Erfolg ein JSON-Objekt, das Benutzerdetails in den folgenden Eigenschaften enthält:
  • OrgId – Die Mitgliedschaftsdienstleister-ID (MSP) des Benutzers in der aktuellen Netzwerkorganisation.
  • UserId: Der Benutzername oder die E-Mail-ID des Benutzers.
• Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

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

GetAccountWithStatusByUser

Diese Methode gibt Accountdetails 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.ERC721Account.GetAccountWithStatusByUser(orgId, userId) (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 die folgenden Eigenschaften enthält:
• AccountId: Die ID des Benutzeraccounts.
• UserId: Der Benutzername oder die E-Mail-ID des Benutzers.
• OrgId - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
• TokenType: Der Typ des Tokens, das der Account enthält.
• NoOfNfts - Die Gesamtanzahl der NFTs, die vom Konto gehalten werden.
• BapAccountVersion: Ein Accountobjektparameter für die interne Verwendung.
• Status: Der aktuelle Status des Benutzeraccounts.
• Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

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

GetAccountByUser

Diese Methode gibt Kontodetails 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.ERC721Account.GetAccountByUser(orgId, userId) (ERC721Account, 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 die folgenden Eigenschaften enthält:
• AccountId: Die ID des Benutzeraccounts.
• UserId: Der Benutzername oder die E-Mail-ID des Benutzers.
• OrgId - Die Mitgliedschaftsserviceanbieter-ID (MSP) des Benutzers in der aktuellen Organisation.
• TokenType: Der Typ des Tokens, das der Account enthält.
• NoOfNfts - Die Gesamtanzahl der NFTs, die vom Konto gehalten werden.
• Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

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

BalanceOf

Diese Methode gibt die Gesamtanzahl der NFTs zurück, die der angegebene Benutzer speichert.

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

Parameter:

• accountId: string: Die Konto-ID des Benutzers.

Rückgabewert:

• Bei erfolgreicher Ausführung eine Schnittstelle mit einer Nachricht und der Gesamtanzahl von NFTs. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Account.BalanceOf(accountId)

{"TotalNfts": 0}

Methoden für die Rollenverwaltung

AddRoleMember

Mit dieser Methode wird eine Rolle zu einem angegebenen Benutzer hinzugefügt.

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

Parameter:

• role: string: Der Name der Rolle, die dem angegebenen Benutzer hinzugefügt werden soll. Die Verhaltensweisen mintable und burnable entsprechen den Eigenschaften minter_role_name und burner_role_name der Spezifikationsdatei.
• accountId: number: Die zu bearbeitende Konto-ID.

Rückgabewert:

• Bei Erfolg wird eine Map mit einer Erfolgsmeldung angezeigt. Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

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

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

RemoveRoleMember

Diese Methode entfernt eine Rolle aus einem angegebenen Benutzer und Token. Eine Konto-ID wird durch die Erstellung eines SHA-256-Hashs der Provider-ID des verketteten Mitgliedschaftsservice (orgId) und des Benutzernamens oder der E-Mail-ID (userId) gebildet.

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

Parameter:

• role: string: Der Name der Rolle, die vom angegebenen Benutzer entfernt werden soll. Die Verhaltensweisen mintable und burnable entsprechen den Eigenschaften minter_role_name und burner_role_name der Spezifikationsdatei.
• accountId: number: Die zu bearbeitende Konto-ID.

Rückgabewert:

• Bei Erfolg wird eine Karte mit einer Erfolgsmeldung angezeigt. Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält.

Beispiel:

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

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

IsInRole

Diese Methode gibt einen booleschen Wert zurück, um anzugeben, ob ein Benutzer und ein Token über eine angegebene Rolle verfügen. Eine Konto-ID wird durch die Erstellung eines SHA-256-Hashs der Provider-ID des verketteten Mitgliedschaftsservice (orgId) und des Benutzernamens oder der E-Mail-ID (userId) gebildet.

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

Parameter:

• role: string: Der Name der Rolle, die auf den angegebenen Benutzer geprüft werden soll. Die Verhaltensweisen mintable und burnable entsprechen den Eigenschaften minter_role_name und burner_role_name der Spezifikationsdatei.
• accountId: number: Die zu bearbeitende Konto-ID.

Rückgabewert:

• Bei Erfolg ein boolescher Wert, der "true" ist, wenn die Rolle für die angegebene Konto-ID vorhanden ist, andernfalls "false". Bei Fehler ein Nicht-Nil-Objekt, das eine Fehlermeldung enthält

Beispiel:

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

{"result": false}

GetAccountsByRole

Diese Methode gibt eine Liste aller Konto-IDs für eine angegebene Rolle zurück.

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

Parameter:

• roleName: string: Der Name der Rolle, nach der gesucht werden soll.

Rückgabewert:

• Bei Erfolg ein JSON-Array mit Konto-IDs. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Role.GetAccountsByRole(userRole)

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

GetUsersByRole

Diese Methode gibt eine Liste aller Benutzer für eine angegebene Rolle zurück.

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

Parameter:

• roleName: string: Der Name der Rolle, nach der gesucht werden soll.

Rückgabewert:

• Bei Erfolg ein JSON-Array mit Benutzerobjekten. Jedes Objekt enthält die Benutzer-ID und die Organisations-ID. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Role.GetUsersByRole(userRole)

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

Methoden für das Transaktionshistorienmanagement

GetAccountTransactionHistory

Diese Methode gibt ein Array der Transaktionshistoriendetails für ein angegebenes Konto zurück.

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

Parameter:

• accountId: string: Die ID des Accounts.

Rückgabewert:

• Bei Erfolg ein Array von Kontotransaktionsobjekten im JSON-Format:
  • TransactionId: Die ID der Transaktion.
  • TransactedAccount: Das Konto, mit dem die Transaktion stattgefunden hat.
  • TransactionType: Der Typ der Transaktion.
  • Timestamp: Der Zeitpunkt der Transaktion.
  • Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Account.GetAccountTransactionHistory(accountId)

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

GetAccountTransactionHistoryWithFilters

Diese Methode gibt die Kontotransaktionshistorie für einen angegebenen Benutzer zurück, gefiltert nach PageSize, Bookmark, startTime und endTime. Diese Methode kann nur aufgerufen werden, wenn eine Verbindung zum Remote-Oracle Blockchain Platform-Netzwerk besteht.

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

Parameter:

• accountId: string: ID des Accounts.
• filters: string: Ein optionaler Parameter. Wenn leer, werden alle Datensätze zurückgegeben. Die Eigenschaft PageSize bestimmt die Anzahl der zurückzugebenden Datensätze. Wenn PageSize 0 ist, ist die Standardseitengröße 20. Die Eigenschaft Bookmark bestimmt den Anfangsindex der zurückzugebenden Datensätze. Weitere Informationen finden Sie in der Hyperledger Fabric-Dokumentation. Die Eigenschaften StartTime und EndTime müssen im RFC-3339-Format angegeben werden.

Rückgabewert:

• Bei Erfolg ein Array von Kontotransaktionsobjekten im JSON-Format:
  • TransactionId: Die ID der Transaktion.
  • TransactedAccount: Das Konto, mit dem die Transaktion stattgefunden hat.
  • TransactionType: Der Typ der Transaktion.
  • Timestamp: Der Zeitpunkt der Transaktion.
  • Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

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

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

GetTransactionById

Diese Methode gibt die Historie eines Transaction-Assets zurück.

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

Parameter:

• trxId: string: Die ID des Transaktionsassets.

Rückgabewert:

• Bei Erfolg eine Reihe von Karten von Transaktionsassets. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Transaction.GetTransactionById(transactionId)

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

DeleteHistoricalTransactions

Diese Methode löscht Transaktionen, die älter als ein angegebenes Datum sind, aus der Statusdatenbank.

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

Parameter:

• referenceTime: string: Transaktionen, die älter als die angegebene Zeit sind, werden gelöscht.

Rückgabewert:

• Bei Erfolg ein Array der gelöschten Transaktions-IDs und eine Erfolgsmeldung. Bei Fehler ein Nicht-Nil-Fehlerobjekt, das eine Fehlermeldung enthält.

Beispiel:

t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)

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

Tokenverhaltensverwaltung - Münzverhalten

GetMaxMintQuantity

Diese Methode gibt die maximale Münzmenge eines Tokens zurück. Wenn das max_mint_quantity-Verhalten nicht in der Spezifikationsdatei konfiguriert ist, ist der Standardwert 0, und eine unbegrenzte Anzahl von Token kann geprägt werden.

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

Parameter:

• id: Die ID des zu bearbeitenden Tokens.

Rückgabewert:

• Bei Erfolg die maximale mintable Menge des Tokens im Datentyp "Number". Bei Fehler ein Nicht-Nil-Objekt mit einer Fehlermeldung.

Beispiel:

t.Ctx.ERC721Token.GetMaxMintQuantity(tokenId);

20000

GetTotalMintedTokens

Diese Methode gibt die Gesamtanzahl der im System verfügbaren Token für das angegebene Token zurück. Die Netto-Anzahl der verfügbaren Token ist die Gesamtanzahl der geprägten Token abzüglich der Anzahl der gebrannten Token.

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

Parameter:

• Kein

Rückgabewert:

• Bei Erfolg eine Übersicht über die Gesamtanzahl der geprägten Token, den Datentyp "Number" und eine Erfolgsmeldung. Bei Fehler ein Nicht-Nil-Objekt mit einer Fehlermeldung.

Beispiel:

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

Tokenverhalten verwalten - Übertragbares Verhalten

SafeTransferFrom

Diese Methode überträgt die Verantwortung für den angegebenen NFT vom Aufrufer auf ein anderes Konto. Diese Methode umfasst die folgenden Validierungen:

• Der Token existiert und wird nicht verbrannt.
• Das Absenderkonto und das Empfängerkonto sind vorhanden und nicht dasselbe Konto.
• Das Absenderkonto ist Eigentümer des Tokens.
• Der Aufrufer der Funktion ist der Absender.

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

Parameter:

• fromAccountId: string: Die Konto-ID des Absenders in der aktuellen Organisation.
• toAccountId: string: Die Konto-ID des Empfängers in der aktuellen Organisation.
• tokenAsset: Die Referenz auf das zu bearbeitende Tokenasset.
• data: string: Optionale zusätzliche Informationen zum Speichern in der Transaktion.

Rückgabewert:

• Bei Erfolg ein Versprechen mit einer Erfolgsmeldung, die Accountdetails enthält. Bei Fehler ein Nicht-Nil-Objekt mit einer Fehlermeldung.

Beispiel:

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

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

TransferFrom

Diese Methode überträgt die Verantwortung für den angegebenen NFT von einem Absenderkonto auf ein Empfängerkonto. Es liegt in der Verantwortung des Aufrufers, die richtigen Parameter zu übergeben. Diese Methode kann von jedem Benutzer aufgerufen werden, nicht nur vom Token-Eigentümer. Diese Methode umfasst die folgenden Validierungen:

• Der Token existiert und wird nicht verbrannt.
• Das Absenderkonto und das Empfängerkonto sind vorhanden und nicht dasselbe Konto.
• Das Absenderkonto ist Eigentümer des Tokens.

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

Parameter:

• fromAccountId: string: Die Konto-ID des Absenders in der aktuellen Organisation.
• toAccountId: string: Die Konto-ID des Empfängers in der aktuellen Organisation.
• tokenAsset: Die Referenz auf das zu bearbeitende Tokenasset.

Rückgabewert:

• Bei Erfolg ein Versprechen mit einer Erfolgsmeldung, die Accountdetails enthält. Account-IDs haben das Präfix oaccount~. Bei Fehler ein Nicht-Nil-Objekt mit einer Fehlermeldung.

\Beispiel:

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

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

Tokenverhaltensverwaltung - Burnable Behavior

Burn

Diese Methode deaktiviert oder brennt den angegebenen NFT aus dem Account des Aufrufers. Der Aufrufer dieser Methode muss über ein Konto verfügen. Ein Token kann nur gebrannt werden, wenn die Tokenspezifikationsdatei das Verhalten burnable enthält. Wenn im Abschnitt roles der Spezifikationsdatei keine Eigenschaft burner_role_name angegeben ist, kann der Eigentümer des Tokens das Token brennen. Wenn im Abschnitt roles eine Eigenschaft burner_role_name angegeben wird, kann der Benutzer, dem die Brennerrolle zugewiesen wurde, die auch der Minter (Ersteller) des Tokens ist, das Token brennen. Die Methode burn ist Teil des Packages ERC721Token, auf das Sie über den Empfänger der Struktur Ctx zugreifen.

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

Parameter:

• tokenAsset: Die Referenz auf das zu bearbeitende Tokenasset.

Rückgabewert:

• Bei Erfolg ein Versprechen mit einer Erfolgsmeldung, die Accountdetails enthält. Bei Fehler ein Nicht-Nil-Objekt mit einer Fehlermeldung.

Beispiel:

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

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