1. Utilizzo di Oracle Blockchain Platform
  2. Crea codici concatenati con App Builder di blockchain con uso ridotto di codice
  3. Supporto alla cogenerazione mediante Blockchain App Builder
  4. ERC-721
  5. Progetto NFT Go impalcato per ERC-721

Progetto NFT Go impalcato per ERC-721

Blockchain App Builder prende l'input dal file di specifica NFT e genera un progetto di codice concatenato impalcato completamente funzionale.

Il progetto genera automaticamente classi e funzioni del ciclo di vita NFT, inclusi i metodi CRUD e non CRUD. La convalida degli argomenti, il marshalling/unmarshalling e la capacità di persistenza trasparente sono tutti supportati automaticamente.

Per informazioni sul progetto e sui metodi scaffolded non direttamente correlati agli NFT, vedere Scaffolded Go Chaincode Project.

Di riferimento:

Modello

La funzionalità di persistenza trasparente o ORM semplificato viene acquisita nella classe OchainModel. 

package model

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

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

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

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

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

	TokenMetadata ArtCollectionMetadata `json:"TokenMetadata"`

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

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

Controllore

C'è un solo controller principale.

type Controller struct {
    Ctx trxcontext.TrxContext
}

È possibile creare un numero qualsiasi di classi, funzioni o file, ma è possibile richiamare solo i metodi definiti all'interno della classe controller principale. Gli altri metodi sono nascosti.

È possibile utilizzare i metodi SDK token per scrivere metodi personalizzati per l'applicazione business.

Metodi NFT generati automaticamente

Blockchain App Builder genera automaticamente metodi per supportare i cicli di vita NFT e NFT. È possibile utilizzare questi metodi per inizializzare NFT, gestire ruoli e account e completare altri task del ciclo di vita NFT senza alcuna codifica aggiuntiva.

Blockchain App Builder genera automaticamente metodi per supportare i cicli di vita NFT e NFT. È possibile utilizzare questi metodi per inizializzare NFT, gestire ruoli e account e completare altri task del ciclo di vita NFT senza alcuna codifica aggiuntiva. I metodi del controller devono essere pubblici per poter essere richiamati. I nomi dei metodi pubblici iniziano con un carattere maiuscolo. I nomi dei metodi che iniziano con un carattere minuscolo sono privati.

Metodi per la gestione del controllo dell'accesso

AddTokenAdmin
Questo metodo aggiunge un utente come Token Admin del codice concatenato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
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)
}
Parametri:
  • orgId string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un messaggio che include i dettagli dell'utente aggiunto come Token Admin del codice concatenato.
Esempio di valore restituito:
{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveTokenAdmin
Questo metodo rimuove un utente come Token Admin del codice concatenato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. Non è possibile utilizzare questo metodo per rimuovere se stessi come Token Admin. 
func (t *Controller) RemoveTokenAdmin(orgId string, userId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721ADMIN.RemoveAdmin", "TOKEN")
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      return t.Ctx.ERC721Admin.RemoveAdmin(orgId, userId)
}
Parametri:
  • orgId string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un messaggio che include i dettagli dell'utente rimosso come Token Admin del codice concatenato.
Esempio di valore restituito:
{"msg":"Successfully removed Admin (OrgId Org1MSP UserId user1)"}
IsTokenAdmin
Questo metodo restituisce il valore booleano true se il chiamante della funzione è un valore Token Admin, altrimenti restituisce false. Un Token Admin può chiamare questa funzione su qualsiasi altro utente della rete blockchain. Altri utenti possono chiamare questo metodo solo sui propri account. 
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)
}
Parametri:
  • orgId string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • Il metodo restituisce true se il chiamante è un Token Admin, altrimenti restituisce false.
Esempio di valore restituito:
{"result":true}
GetAllTokenAdmins
Questo metodo restituisce un elenco di tutti gli utenti che sono un Token Admin del codice concatenato. Questo metodo può essere richiamato solo dal Token Admin del codice concatenato. 
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()
}
Parametri:
  • nessuno
Restituisce:
  • In caso di operazione riuscita, una lista JSON di amministratori che include oggetti OrgId e UserId.
Esempio di valore restituito:
{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}

Metodi per la gestione della configurazione dei token

Init
Questo metodo viene chiamato quando viene creata un'istanza del codice concatenato. Ogni Token Admin viene identificato dalle informazioni UserId e OrgId nel parametro adminList. UserId è il nome utente o l'ID di posta elettronica del proprietario dell'istanza o dell'utente che ha eseguito il login all'istanza. OrgId è l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione di rete corrente. Il parametro adminList è obbligatorio la prima volta che si distribuisce il codice concatenato. Se si sta aggiornando il codice concatenato, passare una lista vuota ([]). Qualsiasi altra informazione nel parametro adminList viene ignorata durante gli aggiornamenti. 
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
}
Parametri:
  • adminList array: un array di informazioni {OrgId, UserId} che specifica la lista degli amministratori di token. L'array adminList è un parametro obbligatorio.
GetAllTokens
Questo metodo restituisce tutti gli asset token salvati nel database di stato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. Questo metodo utilizza query rich SQL di Berkeley DB e può essere richiamato solo quando si è connessi alla rete remota di Oracle Blockchain Platform. 
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()
}
Parametri:
  • nessuno
Restituisce:
  • Lista di tutti gli asset token in formato JSON.
Esempio di valore restituito:
[
    {
        "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
Questo metodo restituisce tutti gli asset token di proprietà di un utente specificato. Questo metodo utilizza query rich SQL di Berkeley DB e può essere richiamato solo quando si è connessi alla rete remota di Oracle Blockchain Platform. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal proprietario del conto. 
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)
}
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • Lista di asset token in formato JSON.
Esempio di valore restituito:
[
    {
        "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
Questo metodo restituisce un oggetto token se il token è presente nel database di stato. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal proprietario del token. 
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
}
Parametri:
  • tokenId: string: l'ID del token da ottenere.
Restituisce:
  • Asset token in formato JSON.
Esempio di valore restituito:
{
    "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
Questo metodo restituisce la cronologia per un ID token specificato. Questo metodo può essere richiamato solo quando è connesso alla rete remota di Oracle Blockchain Platform. Chiunque può chiamare questo metodo.
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)
}
Parametri:
  • tokenId: string: l'ID del token.
Esempio di valore restituito:
[
    {
        "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
Questo è un metodo di utility che restituisce un'istanza del token per un ID token specificato. Questo metodo viene utilizzato da molti dei metodi generati automaticamente per recuperare gli oggetti token. È possibile richiamare questo metodo in base alle esigenze dai metodi personalizzati. Quando si crea un asset o una classe tokenizzata, aggiornare il caso di scambio con la classe Token corrispondente per restituire l'oggetto token corretto. Il comando ochain sync in Blockchain App Builder crea automaticamente un caso di scambio quando un asset tokenizzato viene creato nel file di specifica. Poiché questo metodo è privato, non è direttamente richiamabile e può essere chiamato solo da altri metodi. 
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)
      }
}
Parametri:
  • tokenId: string: l'ID del token.
OwnerOf
Questo metodo restituisce l'ID account del proprietario dell'ID token specificato. Chiunque può chiamare questo metodo.
func (t *Controller) Ownerof(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.OwnerOf(tokenId)
}
Parametri:
  • tokenId: string: l'ID del token.
Restituisce:
  • Oggetto JSON dell'ID account del proprietario.
Esempio di valore restituito:
{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
Name
Questo metodo restituisce il nome della classe di token. Chiunque può chiamare questo metodo.
func (t *Controller) Name() (interface{}, error) {
      return t.Ctx.ERC721Token.Name()
}
Parametri:
  • nessuno
Restituisce:
  • Oggetto JSON del nome token.
Esempio di valore restituito:
{"TokenName": "paintingnft"}
Symbol
Questo metodo restituisce il simbolo della classe di token. Chiunque può chiamare questo metodo.
func (t *Controller) Symbol() (interface{}, error) {
      return t.Ctx.ERC721Token.Symbol()
}
Parametri:
  • nessuno
Restituisce:
  • Oggetto JSON del simbolo del token.
Esempio di valore restituito:
{"Symbol": "PNT"}
TokenURI
Questo metodo restituisce l'URI di un token specificato. Chiunque può chiamare questo metodo.
func (t *Controller) TokenURI(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.TokenURI(tokenId)
}
Parametri:
  • tokenId: string: l'ID del token.
Restituisce:
  • In caso di operazione riuscita, un oggetto JSON dell'URI token.
Esempio di valore restituito:
{"TokenURI": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
TotalSupply
Questo metodo restituisce il numero totale di token coniati. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
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()
}
Parametri:
  • nessuno
Restituisce:
  • In caso di operazione riuscita, un oggetto JSON del conteggio dei token.
Esempio di valore restituito:
{"TotalSupply": 3}
TotalNetSupply
Questo metodo restituisce il numero totale di token coniati meno il numero di token bruciati. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
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()
}
Parametri:
  • nessuno
Restituisce:
  • In caso di operazione riuscita, un oggetto JSON del conteggio dei token.
Esempio di valore restituito:
{"TotalNetSupply": 2}

Metodi per la gestione degli account

CreateAccount
Questo metodo crea un account per un utente e un token specificati. È necessario creare un account per qualsiasi utente che avrà token in qualsiasi momento. Gli account tengono traccia del numero di operazioni NFT di cui dispone un utente. Per completare le operazioni relative ai token, gli utenti devono disporre di account nella rete. È possibile creare un solo conto NFT per utente.

Un ID account è un set alfanumerico di caratteri, preceduto da oaccount~ e seguito da un hash SHA-256 dell'ID provider di servizi di appartenenza (OrgId) dell'utente nell'organizzazione di rete corrente, dal nome utente o dall'ID di posta elettronica (UserId) del proprietario dell'istanza o dell'utente che ha eseguito il login all'istanza e dalla stringa costante nft. Questo metodo può essere richiamato solo dal Token Admin del codice concatenato. 

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)
}
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
  • tokenType: string: l'unico tipo di token supportato è nonfungible.
Restituisce:
  • In caso di operazione riuscita, un oggetto JSON dell'account creato.
Esempio di valore restituito:
{
    "AssetType": "oaccount",
    "BapAccountVersion" : 0,
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
BalanceOf
Questo metodo restituisce il numero totale di operazioni NFT detenute da un utente specificato. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal proprietario del conto. 
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)
}
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • Oggetto JSON del conteggio NFT corrente.
Esempio di valore restituito:
{"totalNfts": 0}
GetAllAccounts
Questo metodo restituisce un elenco di tutti i conti. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. Questo metodo utilizza query rich SQL di Berkeley DB e può essere richiamato solo quando si è connessi alla rete remota di Oracle Blockchain Platform. 
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()
}
Parametri:
  • nessuno
Restituisce:
  • In caso di operazione riuscita, un array JSON di tutti gli account.
Esempio di valore restituito:
[
    {
        "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
Questo metodo restituisce i dettagli dell'account per un utente specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato o dall'Account Owner dell'account. 
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)
}
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un oggetto account JSON che include le proprietà riportate di seguito.
  • AccountId: l'ID dell'account utente.
  • UserId: il nome utente o l'ID e-mail dell'utente.
  • OrgId: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • TokenType: il tipo di token che contiene il conto.
  • NoOfNfts - Il numero totale di NFT detenuti dal conto.
  • BapAccountVersion: parametro dell'oggetto conto per uso interno.
  • Status: lo stato corrente dell'account utente.
Esempio di valore restituito:
{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}
GetUserByAccountId
Questo metodo restituisce i dettagli utente di un account specificato. Questo metodo può essere chiamato da qualsiasi utente.
func (t *Controller) GetUserByAccountId(accountId string) (interface{}, error) {
      return t.Ctx.ERC721Account.GetUserByAccountById(accountId)
}
Parametri:
  • accountId: string: l'ID dell'account.
Restituisce:
  • In caso di operazione riuscita, un oggetto JSON dei dettagli utente (OrgId e UserId).
Esempio di valore restituito:
{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
GetAccountHistory
Questo metodo restituisce la cronologia dell'account per un utente specificato. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal proprietario del conto. 
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)
}
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di successo, una lista di oggetti.
Esempio di valore restituito:
[
    {
        "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"
        }
    }
]

Metodi per la gestione dei ruoli

AddRole
Questo metodo aggiunge un ruolo a un utente specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
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)
}
Parametri:
  • userRole: string: il nome del ruolo da aggiungere all'utente specificato. I comportamenti mintable e burnable corrispondono alle proprietà minter_role_name e burner_role_name del file di specifica.
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un messaggio con i dettagli utente.
Esempio di valore restituito:
{"msg": "Successfully added role minter to oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin)"}
RemoveRole
Questo metodo rimuove un ruolo da un utente specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
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)
}
Parametri:
  • userRole: string: il nome del ruolo da rimuovere dall'utente specificato. I comportamenti mintable e burnable corrispondono alle proprietà minter_role_name e burner_role_name del file di specifica.
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un messaggio con i dettagli utente.
Esempio di valore restituito:
{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}
GetAccountsByRole
Questo metodo restituisce un elenco di tutti gli ID account per un ruolo specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
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)
}
Parametri:
  • userRole: string: il nome del ruolo da cercare.
Restituisce:
  • In caso di operazione riuscita, un array JSON di ID account.
Esempio di valore restituito:
{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
Questo metodo restituisce un elenco di tutti gli utenti per un ruolo specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
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)
}
Parametri:
  • userRole: string: il nome del ruolo da cercare.
Restituisce:
  • In caso di operazione riuscita, un array JSON degli oggetti utente (orgId e userId).
Esempio di valore restituito:
{
    "Users": [
        {
            "OrgId": "Org1MSP",
            "UserId": "admin"
        }
    ]
}
IsInRole
Questo metodo restituisce un valore booleano per indicare se un utente dispone di un ruolo specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato o dall'Account Owner dell'account. 
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
}
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
  • userRole: string: il nome del ruolo da cercare.
Restituisce:
  • In caso di operazione riuscita, una stringa JSON del risultato booleano.
Esempio di valore restituito:
{"result":"true"}

Metodi per la gestione della cronologia delle transazioni

GetAccountTransactionHistory
Questo metodo restituisce la cronologia delle transazioni conto per un utente specificato. Questo metodo può essere chiamato dal Token Admin del codice concatenato o dal proprietario del conto. 
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
}
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di successo, una lista di oggetti.
Esempio di valore restituito:
[
     {
        "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
Questo metodo restituisce la cronologia delle transazioni conto per un utente specificato, filtrata in base a PageSize, Bookmark, StartTime e EndTime. Questo metodo può essere richiamato solo quando è connesso alla rete remota di Oracle Blockchain Platform. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal proprietario del conto. 
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
}
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
  • filters: string: parametro facoltativo. Se vuoto, vengono restituiti tutti i record. La proprietà PageSize determina il numero di record da restituire. Se PageSize è 0, la dimensione predefinita della pagina è 20. La proprietà Bookmark determina l'indice iniziale dei record da restituire. Per ulteriori informazioni, vedere la documentazione di Hyperledger Fabric. Le proprietà StartTime e EndTime devono essere specificate in formato RFC-3339.
Restituisce:
  • In caso di successo, una lista di oggetti.
Esempio di valore restituito:
[
     {
        "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
Questo metodo restituisce la cronologia delle transazioni per un ID transazione specificato. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal proprietario del conto. 
func (t *Controller) GetTransactionById(transactionId string) (interface{}, error) {
      return t.Ctx.ERC721Transaction.GetTransactionById(transactionId)
}
Parametri:
  • transactionId: string: l'ID del cespite transazione.
Restituisce:
  • In caso di successo, una lista di oggetti.
Esempio di valore restituito:
{
    "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
Questo metodo elimina le transazioni più vecchie di un indicatore orario specificato nel database di stato. Questo metodo può essere richiamato solo dal Token Admin del codice concatenato. 
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)
}
Parametri:
  • timestamp: Date: un indicatore orario. Tutte le transazioni precedenti all'indicatore orario verranno eliminate.
Restituisce:
  • In caso di successo, una lista di oggetti.
Esempio di valore restituito:
{
    "Transactions": [
        "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7"
    ],
    "msg": "Successfuly deleted transaction older than date:2022-04-06T08:17:53Z"
}

Metodi per la gestione del comportamento dei token - Funzionamento minimo

Create<Token Name>Token
Questo metodo crea (mint) un NFT. L'asset e le proprietà associate vengono salvati nel database di stato. Il chiamante di questa transazione deve disporre di un account token. Il chiamante di questa transazione diventa il proprietario dell'NFT. Se il file di specifica del token include la sezione roles per behaviors e la proprietà minter_role_name per roles, il chiamante della transazione deve disporre del ruolo secondario. In caso contrario, qualsiasi chiamante può coniare NFT. 
func (t *Controller) Create<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
      return t.Ctx.ERC721Token.CreateToken(&tokenAsset)
}
Parametri:
  • tokenAsset: <Token Class>: asset token da coniare. Per ulteriori informazioni sulle proprietà dell'asset token, vedere il file di specifica di input.
Restituisce:
  • In caso di operazione riuscita, un oggetto asset token JSON che include le proprietà riportate di seguito.
  • Behavior: descrizione di tutti i comportamenti dei token.
  • CreatedBy: l'ID account dell'utente che ha chiamato la transazione per coniare il token.
  • CreationDate: l'indicatore orario della transazione.
  • IsBurned: un valore booleano che indica se l'NFT identificato da tokenId viene masterizzato.
  • Mintable: una descrizione delle proprietà del comportamento mintable. La proprietà max_mint_quantity specifica il numero massimo di NFT di questa classe di token che è possibile creare.
  • Owner: l'ID account del proprietario corrente del token. Durante il processo di conio, il chiamante di questo metodo diventa il proprietario del token.
  • Symbol: il simbolo del token.
  • TokenDesc: la descrizione del token.
  • TokenMetadata: informazioni JSON che descrivono il token.
  • TokenName: il nome del token.
  • TokenStandard: lo standard del token.
  • TokenType: il tipo di token posseduto da questo account.
  • TokenUnit: l'unità del token.
  • TokenUri: l'URI del token.
Esempio di valore restituito:
{
    "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
Questo metodo aggiorna le proprietà del token. Questo metodo può essere chiamato solo dall'utente che è il proprietario o il creatore del token. Dopo la creazione di un asset token, solo il proprietario del token può aggiornare le proprietà personalizzate del token. Se l'utente è sia proprietario che creatore di un token, può anche aggiornare la proprietà TokenDesc. Impossibile aggiornare i metadati del token. È necessario passare tutte le proprietà del token a questo metodo, anche se si desidera aggiornare solo determinate proprietà. 
func (t *Controller) Update<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
      return t.Ctx.ERC721Token.UpdateToken(&tokenAsset)
}
Parametri:
  • tokenAsset: <Token Class>: l'asset token da aggiornare. Per ulteriori informazioni sulle proprietà dell'asset token, vedere il file di specifica di input.
Restituisce:
  • In caso di operazione riuscita, un oggetto asset token JSON aggiornato
Esempio di valore restituito:
{
    "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",
}

Metodi per la gestione del comportamento dei token - Funzionamento trasferibile

SafeTransferFrom
Questo metodo trasferisce la proprietà dell'NFT specificato dal chiamante a un altro conto. Questo metodo include le seguenti convalide:
  • Il token esiste e non viene masterizzato.
  • L'account mittente e l'account ricevente esistono e non sono lo stesso account.
  • L'account mittente è proprietario del token.
  • Il chiamante della funzione è il mittente.
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...)
}
Parametri:
  • fromOrgId: string: l'ID del provider di servizi di appartenenza (MSP) del mittente nell'organizzazione corrente.
  • fromUserId: string: il nome utente o l'ID e-mail del mittente.
  • toOrgId: string: l'ID del provider di servizi di appartenenza (MSP) del destinatario nell'organizzazione corrente.
  • toUserId: string: il nome utente o l'ID e-mail del destinatario.
  • tokenId: string: l'ID del token da trasferire.
  • data: string: informazioni aggiuntive facoltative da memorizzare nel record transazione.
Restituisce:
  • In caso di operazione riuscita, un messaggio con i dettagli dell'account del mittente e del destinatario.
Esempio di valore restituito:
{"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
Questo metodo trasferisce la proprietà dell'operazione NFT specificata da un conto mittente a un conto ricevente. È responsabilità del chiamante passare i parametri corretti. Questo metodo può essere richiamato da qualsiasi utente, non solo dal proprietario del token. Questo metodo include le seguenti convalide:
  • Il token esiste e non viene masterizzato.
  • L'account mittente e l'account ricevente esistono e non sono lo stesso account.
  • L'account mittente è proprietario del token.
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())
}
Parametri:
  • fromOrgId: string: l'ID del provider di servizi di appartenenza (MSP) del mittente nell'organizzazione corrente.
  • fromUserId: string: il nome utente o l'ID e-mail del mittente.
  • toOrgId: string: l'ID del provider di servizi di appartenenza (MSP) del destinatario nell'organizzazione corrente.
  • toUserId: string: il nome utente o l'ID e-mail del destinatario.
  • tokenId: string: l'ID del token da trasferire.
Restituisce:
  • In caso di operazione riuscita, un messaggio con i dettagli dell'account del mittente e del destinatario.
Esempio di valore restituito:
{"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)"}

Metodi per la gestione del comportamento dei token - Funzionamento attivabile

Burn
Questo metodo disattiva o brucia l'NFT specificato dall'account del chiamante. Il chiamante di questo metodo deve avere un account. Impossibile masterizzare un token a meno che il file di specifica del token non includa il comportamento burnable. Se nella sezione roles del file di specifica non viene specificata alcuna proprietà burner_role_name, il proprietario del token può masterizzare il token. Se nella sezione roles è specificata una proprietà burner_role_name, l'utente ha assegnato il ruolo di masterizzatore che è anche il creatore (minter) del token può masterizzare il token. 
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())
}
Parametri:
  • tokenId: string: l'ID del token da masterizzare.
Restituisce:
  • In caso di operazione riuscita, un messaggio con i dettagli dell'account.
Esempio di valore restituito:
{"msg": "Successfully burned NFT token: 'monalisa' from Account-Id: oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (Org-Id: Org1MSP, User-Id: admin"}
BurnNFT
Questo metodo disattiva o masterizza l'NFT specificato dall'account del chiamante e restituisce un oggetto token e una cronologia token. Il chiamante di questo metodo deve avere un account. Impossibile masterizzare un token a meno che il file di specifica del token non includa il comportamento burnable. Se nella sezione roles del file di specifica non viene specificata alcuna proprietà burner_role_name, il proprietario del token può masterizzare il token. Se nella sezione roles è specificata una proprietà burner_role_name, l'utente ha assegnato il ruolo di masterizzatore che è anche il creatore o il proprietario del token può masterizzare il token. 
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
}
Parametri:
  • tokenId: string: l'ID del token da masterizzare.
Restituisce:
  • In caso di operazione riuscita, un oggetto token che include informazioni sulla cronologia token.
Esempio di valore restituito:
{
    "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"
}

Metodi personalizzati

È possibile utilizzare i metodi SDK token per scrivere metodi personalizzati per l'applicazione business.

L'esempio riportato di seguito mostra come utilizzare i metodi SDK token nei metodi personalizzati. Quando viene chiamato il metodo Sell, pubblica un token in vendita per un prezzo specificato. 

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
}

Metodi SDK NFT

Metodi per la gestione del controllo dell'accesso

NFT SDK fornisce una funzione di controllo dell'accesso. Alcuni metodi possono essere chiamati solo da un Token Admin o Account Owner del token. È possibile utilizzare questa funzione per garantire che le operazioni vengano eseguite solo dagli utenti previsti. Qualsiasi accesso non autorizzato genera un errore. Per utilizzare la funzione di controllo dell'accesso, importare la classe Authorization dal modulo ../lib/auth.
import { ERC721Authorization } from '../lib/erc721-auth';
CheckAuthorization
Utilizzare questo metodo per aggiungere un controllo dell'accesso a un'operazione. La maggior parte dei metodi generati automaticamente includono il controllo dell'accesso. Alcuni metodi token possono essere eseguiti solo da un ERC721Admin o dall'Account Owner del token o da MultipleAccountOwner per gli utenti con più account. Il metodo CheckAuthorization fa parte del pacchetto erc721Auth, al quale si accede tramite la struttura Ctx (ricevitore). Il mapping del controllo dell'accesso è descritto nel file oChainUtil.go, come illustrato nel testo seguente. È possibile modificare il controllo dell'accesso modificando il file oChainUtil.go. Per utilizzare il proprio controllo dell'accesso o per disabilitare il controllo dell'accesso, rimuovere il codice di controllo dell'accesso dai metodi e dai metodi personalizzati generati automaticamente dal controller.
  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)
Parametri:
  • funcName: string: il valore della mappa tra i ricevitori e i metodi, come descritto nel file oChainUtil.go.
  • ...args: un argomento di variabile in cui args[0] accetta la costante 'TOKEN' e args[1] accetta il parametro accountId per aggiungere un controllo di accesso per un AccountOwner. Per aggiungere un controllo dell'accesso per un MultipleAccountOwner, args[1] accetta il parametro orgId e args[2] accetta il parametro userId. Per aggiungere un controllo dell'accesso per un TokenOwner, args[1] accetta il parametro tokenId.
Restituisce:
  • Risposta booleana e, se necessario, errore.
Esempi:
t.Ctx.ERC721Auth.CheckAuthorization(<parameters>)

Admin accesso 

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

AccountOwner accesso 

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

MultipleAccountOwner accesso 

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

TokenOwner accesso 

t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.Get", "TOKEN", tokenId)
IsUserTokenAdmin
Questo metodo restituisce una mappa con il valore booleano true se il chiamante della funzione è un valore Token Admin. In caso contrario il metodo restituisce false. 
Ctx.ERC721Auth.IsUserTokenAdmin(orgId string, userId string)  (interface{}, error)
Parametri:
  • orgId: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione di rete corrente.
  • userId: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • Risposta booleana.
Esempio:

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

{"result":true}
AddAdmin
Questo metodo aggiunge un utente come Token Admin del codice concatenato del token. 
Ctx.ERC721Admin.AddAdmin(orgId string, userId string) (interface{}, error)
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un messaggio che elenca i dettagli per l'utente aggiunto come Token Admin del codice concatenato del token. In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

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

{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveAdmin
Questo metodo rimuove un utente come Token Admin del codice concatenato del token. 
Ctx.ERC721Admin.RemoveAdmin(orgId string, userId string) (interface{}, error)
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un messaggio che elenca i dettagli per l'utente rimosso come Token Admin del codice concatenato del token. In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

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

{"msg":"Successfuly removed Admin (OrgId Org1MSP UserId user1)"}
GetAllAdmins
Questo metodo restituisce un elenco di tutti gli utenti Token Admin. 
Ctx.ERC721Admin.GetAllAdmins() (Admin[], error)
Parametri:
  • nessuno
Restituisce:
  • In caso di successo, un elenco di tutti gli utenti Token Admin. In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

t.Ctx.ERC721Admin.GetAllAdmins()

{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}
GetAllAdminUsers
Questo metodo restituisce un elenco di tutti gli utenti Token Admin. 
Ctx.ERC721Admin.GetAllAdminUsers() (interface{}, error)
Parametri:
  • nessuno
Restituisce:
  • In caso di operazione riuscita, un elenco di tutti gli utenti Token Admin in formato map[string]interface{}. In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

t.Ctx.ERC721Admin.GetAllAdminUsers()

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

Metodi per la gestione della configurazione dei token

CreateToken
Questo metodo crea un token e ne salva le proprietà nel database di stato. Questo metodo può essere richiamato solo dagli utenti con il ruolo di minter.
Ctx.ERC721Token.CreateToken(args ...interface{})
Parametri:
  • Argomento di variabile in cui args[0] contiene un riferimento al token struct del tipo richiesto.
Restituisce:
  • In caso di operazione riuscita, un interface[] con i dettagli del token. In caso di errore, un oggetto non nullo con un messaggio di errore.
Esempio:

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
Questo metodo restituisce l'URI del token per un token specificato.
Ctx.ERC721Token.GetTokenURI(tokenId string) (interface{}, error)
Parametri:
  • tokenId: string: l'ID del token.
Restituisce:
  • In caso di operazione riuscita, restituisce una mappa del nuovo URI token nel tipo di dati stringa. In caso di errore, un oggetto non nullo con un messaggio di errore.
Esempio:

t.Ctx.ERC721Token.GetTokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
TokenUri
Questo metodo restituisce l'URI del token per un token specificato.
Ctx.ERC721Token.TokenURI(tokenId string) (interface{}, error)
Parametri:
  • tokenId: string: l'ID del token.
Restituisce:
  • In caso di operazione riuscita, restituisce una mappa del nuovo URI token nel tipo di dati stringa. In caso di errore, un oggetto non nullo con un messaggio di errore.
Esempio di valore restituito:

t.Ctx.ERC721Token.TokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
Symbol
Questo metodo restituisce il simbolo della classe di token.
Ctx.ERC721Token.Symbol() (interface{}, error)
Parametri:
  • nessuno
Restituisce:
  • In caso di operazione riuscita, una mappa del simbolo nel tipo di dati stringa. In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}
Name
Questo metodo restituisce il nome della classe di token.
Ctx.ERC721Token.Name() (interface{}, error)
Parametri:
  • nessuno
Restituisce:
  • In caso di operazione riuscita, una mappa del nome del token nel tipo di dati stringa. In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

t.Ctx.ERC721Token.Name()

{"TokenName": "paintingnft"}
OwnerOf
Questo metodo restituisce l'ID account del proprietario di un token specificato.
Ctx.ERC721Token.OwnerOf(tokenId string) (interface{}, error)
Parametri:
  • tokenId: string: l'ID del token.
Restituisce:
  • In caso di operazione riuscita, una mappa dell'ID account del proprietario nel tipo di dati stringa. In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

t.Ctx.ERC721Token.OwnerOf(tokenId)

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
TotalSupply
Questo metodo restituisce il numero totale di operazioni NFT coniate.
Ctx.ERC721Token.TotalSupply() (map[string]interface{}, error)
Parametri:
  • tokenId: string: l'ID del token.
Restituisce:
  • In caso di operazione riuscita, una mappa della fornitura totale di token nel tipo di dati numero. In caso di errore, un rifiuto con un messaggio di errore.
Esempio:

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}
GetAllTokens
Questo metodo restituisce tutti gli asset token salvati nel database di stato. Questo metodo utilizza query rich SQL di Berkeley DB e può essere richiamato solo quando si è connessi alla rete remota di Oracle Blockchain Platform.
Ctx.ERC721Token.GetAllTokens()  (interface{}, error)
Parametri:
  • nessuno
Restituisce:
  • In caso di operazione riuscita, una mappa di tutti gli asset token. In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

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
Questo metodo restituisce tutti i token di proprietà di un ID account specificato. Questo metodo utilizza query rich SQL di Berkeley DB e può essere richiamato solo quando si è connessi alla rete remota di Oracle Blockchain Platform.
Ctx.ERC721Token.GetAllTokensByUser(accountId string) (interface{}, error)
Parametri:
  • accountId: string: l'ID dell'account.
Restituisce:
  • In caso di operazione riuscita, una mappa degli asset token per l'account specificato. In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

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
Questo metodo restituisce l'oggetto token specificato se è presente nel database di stato.
Ctx.Get(Id string, result ...interface{}) (interface{}, error)
Parametri:
  • tokenId: string: l'ID del token.
  • result: un argomento di variabile in cui il primo argomento result[0] è un riferimento a un oggetto Token vuoto di tipo corretto, che conterrà i dati del token dopo una chiamata riuscita del metodo.
Restituisce:
  • In caso di operazione riuscita, una mappa con i dati dell'asset token. Inoltre, se viene passato result[0], i dati vengono assegnati a result[0]. In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

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
Questo metodo aggiorna le proprietà del token. Questo metodo può essere chiamato solo dal proprietario o dal creatore del token. Dopo la creazione di un asset token, solo il proprietario del token può aggiornare le proprietà personalizzate del token. Se l'utente è sia proprietario che creatore di un token, può anche aggiornare la proprietà TokenDesc. Impossibile aggiornare i metadati del token. È necessario passare tutte le proprietà del token a questo metodo, anche se si desidera aggiornare solo determinate proprietà. 
Ctx.ERC721Token.UpdateToken(asset interface{}) (interface{}, error)
Parametri:
  • Riferimento ai dati di struttura del token del tipo richiesto
Restituisce:
  • In caso di operazione riuscita, un messaggio di promessa con i dettagli del token. In caso di errore, un rifiuto con un messaggio di errore.
Esempio:

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
Questo metodo restituisce la cronologia per il token specificato.
Ctx.ERC721Token.History(tokenId: string)  (interface{}, error)
Parametri:
  • tokenId: string: l'ID del token.
Restituisce:
  • In caso di successo, una serie di mappe. In caso di errore, un rifiuto con un messaggio di errore.
Esempio:

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
Questo metodo restituisce un nuovo oggetto TrxContext. La struttura trxcontext contiene riferimenti a tutte le librerie SDK. Accedere ai metodi sdk utilizzando solo questo oggetto. L'oggetto trxcontext mantiene l'esclusività reciproca degli stub delle transazioni nelle librerie SDK quando sono in esecuzione transazioni concorrenti. 
GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext
Parametri:
  • stub: lo stub della transazione.
Restituisce:
  • Struttura trxcontext.
Esempio:

trxcontext.GetNewCtx(stub)

trxcontext object.

Metodi per la gestione degli account

GenerateAccountId
Questo metodo restituisce un ID account, formato dalla concatenazione dell'ID provider di servizi di appartenenza (orgId) e del nome utente o dell'ID e-mail (userId), quindi dalla creazione di un hash SHA-256. 
Ctx.ERC721Account.GenerateAccountId(orgId string, userId string) (string, error)
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, l'ID account generato. In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

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

oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507
CreateAccount
Questo metodo crea un account per un utente specificato. È necessario creare un account per qualsiasi utente che avrà token in qualsiasi momento. Gli account tengono traccia del numero di operazioni NFT di cui dispone un utente. Per completare le operazioni relative ai token, gli utenti devono disporre di account nella rete. È possibile creare un solo conto NFT per utente.

Un ID account è un set alfanumerico di caratteri, preceduto da oaccount~ e seguito da un hash SHA-256 dell'ID provider di servizi di appartenenza (org_id) dell'utente nell'organizzazione di rete corrente, dal nome utente o dall'ID di posta elettronica (userId) del proprietario dell'istanza o dell'utente che ha eseguito il login all'istanza e dalla stringa costante nft. 

Ctx.ERC721Account.CreateAccount(orgId string, userId string, tokenType string) (ERC721Account, error)
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
  • tokenType: string: l'unico tipo di token supportato è nonfungible.
Restituisce:
  • In caso di operazione riuscita, il nuovo oggetto cliente. In caso di errore, un oggetto diverso da zero contenente un messaggio di errore
Esempio:

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

{
    "AssetType": "oaccount",
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "BapAccountVersion" : 0,
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
GetAllAccounts
Questo metodo restituisce un elenco di tutti i conti. Questo metodo utilizza query rich SQL di Berkeley DB e può essere richiamato solo quando si è connessi alla rete remota di Oracle Blockchain Platform.
Ctx.ERC721Account.GetAllAccounts() (interface{}, error)
Parametri:
  • nessuno
Restituisce:
  • Un array JSON di tutti gli account.
Esempio:

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
Questo metodo restituisce un array dei dettagli della cronologia dell'account per un account specificato.
Ctx.ERC721Account.History(accountId string) (interface{}, error)
Parametri:
  • accountId: string: l'ID dell'account.
Restituisce:
  • In caso di operazione riuscita, un array map[string]interface{} contenente i dettagli della cronologia degli account per l'account specificato. I dati dell'account vengono visualizzati sotto la chiave value nella mappa. In caso di errore, un oggetto di errore non nullo contenente un messaggio di errore.
Esempio:

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
Questo metodo restituisce i dettagli utente per un account specificato.
Ctx.ERC721Account.GetUserByAccountId(accountId string) (interface{}, error)
Parametri:
  • accountId: string: l'ID dell'account.
Restituisce:
  • In caso di operazione riuscita, un oggetto JSON che include i dettagli utente nelle seguenti proprietà:
    • OrgId: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione di rete corrente.
    • UserId: il nome utente o l'ID e-mail dell'utente.
  • In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
GetAccountWithStatusByUser
Questo metodo restituisce i dettagli dell'account per un utente specificato, incluso lo stato dell'account. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato o dall'Account Owner dell'account. 
Ctx.ERC721Account.GetAccountWithStatusByUser(orgId, userId) (interface{}, error)
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un oggetto account JSON che include le proprietà riportate di seguito.
  • AccountId: l'ID dell'account utente.
  • UserId: il nome utente o l'ID e-mail dell'utente.
  • OrgId: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • TokenType: il tipo di token che contiene il conto.
  • NoOfNfts - Il numero totale di NFT detenuti dal conto.
  • BapAccountVersion: parametro dell'oggetto conto per uso interno.
  • Status: lo stato corrente dell'account utente.
  • In caso di errore, un oggetto non nullo che contiene un messaggio di errore.
Esempio:
{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}
GetAccountByUser
Questo metodo restituisce i dettagli dell'account per un utente specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato o dall'Account Owner dell'account. 
Ctx.ERC721Account.GetAccountByUser(orgId, userId) (ERC721Account, error)
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un oggetto account JSON che include le proprietà riportate di seguito.
  • AccountId: l'ID dell'account utente.
  • UserId: il nome utente o l'ID e-mail dell'utente.
  • OrgId: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • TokenType: il tipo di token che contiene il conto.
  • NoOfNfts - Il numero totale di NFT detenuti dal conto.
  • In caso di errore, un oggetto non nullo che contiene un messaggio di errore.
Esempio:
{
    "AssetType": "oaccount",
    "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "BapAccountVersion" : 0,
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
BalanceOf
Questo metodo restituisce il numero totale di operazioni NFT bloccate dall'utente specificato.
Ctx.ERC721Account.BalanceOf(accountId string) (interface{}, error)
Parametri:
  • accountId: string: l'ID account dell'utente.
Restituisce:
  • In caso di successo, un'interfaccia con un messaggio e il numero totale di NFT. In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

t.Ctx.ERC721Account.BalanceOf(accountId)

{"TotalNfts": 0}

Metodi per la gestione dei ruoli

AddRoleMember
Questo metodo aggiunge un ruolo a un utente specificato.
Ctx.ERC721Token.AddRoleMember(role string, accountId string) (interface{}, error)
Parametri:
  • role: string: il nome del ruolo da aggiungere all'utente specificato. I comportamenti mintable e burnable corrispondono alle proprietà minter_role_name e burner_role_name del file di specifica.
  • accountId: number: l'ID account su cui eseguire l'operazione.
Restituisce:
  • In caso di successo, una mappa con un messaggio di successo. In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

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

{"msg": "Successfully added role minter to oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin)"}
RemoveRoleMember
Questo metodo rimuove un ruolo da un utente e un token specificati. Un ID account viene formato mediante la creazione di un hash SHA-256 dell'ID provider di servizi di appartenenza concatenato (orgId) e del nome utente o dell'ID e-mail (userId). 
Ctx.Token.RemoveRoleMember(role string, accountId string) (interface{}, error)
Parametri:
  • role: string: il nome del ruolo da rimuovere dall'utente specificato. I comportamenti mintable e burnable corrispondono alle proprietà minter_role_name e burner_role_name del file di specifica.
  • accountId: number: l'ID account su cui eseguire l'operazione.
Restituisce:
  • In caso di successo, una mappa con un messaggio di successo. In caso di errore, un oggetto non nullo contenente un messaggio di errore.
Esempio:

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

{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}
IsInRole
Questo metodo restituisce un valore booleano per indicare se un utente e un token hanno un ruolo specificato. Un ID account viene formato mediante la creazione di un hash SHA-256 dell'ID provider di servizi di appartenenza concatenato (orgId) e del nome utente o dell'ID e-mail (userId). 
Ctx.ERC721Token.IsInRole(role string, accountId string) (bool, error)
Parametri:
  • role: string: il nome del ruolo da controllare per l'utente specificato. I comportamenti mintable e burnable corrispondono alle proprietà minter_role_name e burner_role_name del file di specifica.
  • accountId: number: l'ID account su cui eseguire l'operazione.
Restituisce:
  • In caso di operazione riuscita, un valore booleano che è vero se il ruolo è presente per l'ID account specificato, altrimenti è falso. In caso di errore, un oggetto diverso da zero contenente un messaggio di errore
Esempio:

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

{"result": false}
GetAccountsByRole
Questo metodo restituisce un elenco di tutti gli ID account per un ruolo specificato.
Ctx.ERC721Role.GetAccountsByRole(roleName string) (interface{}, error)
Parametri:
  • roleName: string: il nome del ruolo da cercare.
Restituisce:
  • In caso di operazione riuscita, un array JSON di ID account. In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

t.Ctx.ERC721Role.GetAccountsByRole(userRole)

{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
Questo metodo restituisce un elenco di tutti gli utenti per un ruolo specificato.
Ctx.ERC721Role.GetUsersByRole(roleName string) (interface{}, error)
Parametri:
  • roleName: string: il nome del ruolo da cercare.
Restituisce:
  • In caso di operazione riuscita, un array JSON di oggetti utente. Ogni oggetto contiene l'ID utente e l'ID organizzazione. In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

t.Ctx.ERC721Role.GetUsersByRole(userRole)

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

Metodi per la gestione della cronologia delle transazioni

GetAccountTransactionHistory
Questo metodo restituisce un array dei dettagli della cronologia delle transazioni per un conto specificato.
Ctx.ERC721Account.GetAccountTransactionHistory(accountId string) (interface{}, error)
Parametri:
  • accountId: string: l'ID dell'account.
Restituisce:
  • In caso di operazione riuscita, un array di oggetti transazione conto in formato JSON:
    • TransactionId: l'ID della transazione.
    • TransactedAccount - Il conto con cui ha avuto luogo la transazione.
    • TransactionType: il tipo di transazione.
    • Timestamp: l'ora della transazione.
    • In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

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
Questo metodo restituisce la cronologia delle transazioni conto per un utente specificato, filtrata in base a PageSize, Bookmark, startTime e endTime. Questo metodo può essere richiamato solo quando è connesso alla rete remota di Oracle Blockchain Platform. 
Ctx.ERC721Account.GetAccountTransactionHistoryWithFilters(accountId string, filters ...erc721Account.AccountHistoryFilters)
Parametri:
  • accountId: string: l'ID dell'account.
  • filters: string: parametro facoltativo. Se vuoto, vengono restituiti tutti i record. La proprietà PageSize determina il numero di record da restituire. Se PageSize è 0, la dimensione predefinita della pagina è 20. La proprietà Bookmark determina l'indice iniziale dei record da restituire. Per ulteriori informazioni, vedere la documentazione di Hyperledger Fabric. Le proprietà StartTime e EndTime devono essere specificate in formato RFC-3339.
Restituisce:
  • In caso di operazione riuscita, un array di oggetti transazione conto in formato JSON:
    • TransactionId: l'ID della transazione.
    • TransactedAccount - Il conto con cui ha avuto luogo la transazione.
    • TransactionType: il tipo di transazione.
    • Timestamp: l'ora della transazione.
    • In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

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
Questo metodo restituisce la cronologia di un asset Transaction. 
Ctx.ERC721Transaction.GetTransactionById(trxId string) (interface{}, error)
Parametri:
  • trxId: string: l'ID del cespite transazione.
Restituisce:
  • In caso di operazione riuscita, una serie di mappe dei cespiti transazione. In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

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
Questo metodo elimina dal database di stato le transazioni che risalgono a una data precedente a quella specificata.
func (t *Controller) DeleteHistoricalTransactions(referenceTime string) (interface{}, error)
Parametri:
  • referenceTime: string: le transazioni precedenti all'ora specificata verranno eliminate.
Restituisce:
  • In caso di operazione riuscita, un array degli ID transazione eliminati e un messaggio di operazione riuscita. In caso di errore, un oggetto di errore non nullo che contiene un messaggio di errore.
Esempio:

t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)

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

Gestione del comportamento dei token - Comportamento minimo

GetMaxMintQuantity
Questo metodo restituisce la quantità minima massima di un token. Se il funzionamento di max_mint_quantity non è configurato nel file di specifica, il valore predefinito è 0 e è possibile creare un numero infinito di token. 
Ctx.ERC721Token.GetMaxMintQuantity(id string) (float64, error)
Parametri:
  • id: l'ID del token su cui eseguire l'operazione.
Restituisce:
  • In caso di operazione riuscita, la quantità minima massima del token nel tipo di dati numerico. In caso di errore, un oggetto non nullo con un messaggio di errore.
Esempio:

t.Ctx.ERC721Token.GetMaxMintQuantity(tokenId);

20000
GetTotalMintedTokens
Questo metodo restituisce il numero netto totale di token disponibili nel sistema per il token specificato. Il numero netto di token disponibili è il numero totale di token coniati meno il numero di token bruciati.
Ctx.ERC721Token.GetTotalMintedTokens() (map[string]interface{}, error)
Parametri:
  • nessuno
Restituisce:
  • In caso di operazione riuscita, una mappa dei token con coni totali, il tipo di dati numerici e un messaggio di operazione riuscita. In caso di errore, un oggetto non nullo con un messaggio di errore.
Esempio:

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

Gestione del comportamento dei token - Funzionamento trasferibile

SafeTransferFrom
Questo metodo trasferisce la proprietà dell'NFT specificato dal chiamante a un altro conto. Questo metodo include le seguenti convalide:
  • Il token esiste e non viene masterizzato.
  • L'account mittente e l'account ricevente esistono e non sono lo stesso account.
  • L'account mittente è proprietario del token.
  • Il chiamante della funzione è il mittente.
Ctx.ERC721Token.SafeTransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}, data ...string) (interface{}, error)
Parametri:
  • fromAccountId: string: l'ID account del mittente nell'organizzazione corrente.
  • toAccountId: string: l'ID conto del ricevente nell'organizzazione corrente.
  • tokenAsset: il riferimento all'asset token su cui eseguire le operazioni.
  • data: string - Informazioni aggiuntive facoltative da memorizzare nella transazione.
Restituisce:
  • In caso di operazione riuscita, una promessa con un messaggio di operazione riuscita che include i dettagli dell'account. In caso di errore, un oggetto non nullo con un messaggio di errore.
Esempio:

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
Questo metodo trasferisce la proprietà dell'operazione NFT specificata da un conto mittente a un conto ricevente. È responsabilità del chiamante passare i parametri corretti. Questo metodo può essere richiamato da qualsiasi utente, non solo dal proprietario del token. Questo metodo include le seguenti convalide:
  • Il token esiste e non viene masterizzato.
  • L'account mittente e l'account ricevente esistono e non sono lo stesso account.
  • L'account mittente è proprietario del token.
Ctx.ERC721Token.TransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}) (interface{}, error)
Parametri:
  • fromAccountId: string: l'ID account del mittente nell'organizzazione corrente.
  • toAccountId: string: l'ID conto del ricevente nell'organizzazione corrente.
  • tokenAsset: il riferimento all'asset token su cui eseguire le operazioni.
Restituisce:
  • In caso di operazione riuscita, una promessa con un messaggio di operazione riuscita che include i dettagli dell'account. Gli ID account hanno il prefisso oaccount~. In caso di errore, un oggetto non nullo con un messaggio di errore.
\Ad esempio:

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

Gestione del comportamento dei token - Comportamento utilizzabile

Burn
Questo metodo disattiva o brucia l'NFT specificato dall'account del chiamante. Il chiamante di questo metodo deve avere un account. Impossibile masterizzare un token a meno che il file di specifica del token non includa il comportamento burnable. Se nella sezione roles del file di specifica non viene specificata alcuna proprietà burner_role_name, il proprietario del token può masterizzare il token. Se nella sezione roles è specificata una proprietà burner_role_name, l'utente ha assegnato il ruolo di masterizzatore che è anche il creatore (minter) del token può masterizzare il token. Il metodo burn fa parte del pacchetto ERC721Token, al quale si accede tramite il ricevitore della struttura Ctx. 
Ctx.Token.Burn(tokenAsset interface{}) (interface{}, error)
Parametri:
  • tokenAsset: il riferimento all'asset token su cui eseguire le operazioni.
Restituisce:
  • In caso di operazione riuscita, una promessa con un messaggio di operazione riuscita che include i dettagli dell'account. In caso di errore, un oggetto non nullo con un messaggio di errore.
Esempio:

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

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