Progetto NFT Go impalcato per ERC-721

Blockchain App Builder prende l'input dal tuo 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 scaffolded e sui metodi non direttamente correlati a NFT, vedere Progetto codice catena go scaffolded.

Di riferimento:

• Modello
• Controller
  • Metodi NFT generati automaticamente
  • Metodi personalizzati
• Metodi SDK NFT

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

Controller

C'è solo un controller principale.

type Controller struct {
    Ctx trxcontext.TrxContext
}

È possibile creare un numero qualsiasi di classi, funzioni o file, ma solo i metodi definiti nella classe controller principale sono richiamabili. 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 NFT e cicli di vita NFT. È possibile utilizzare questi metodi per inizializzare NFT, gestire ruoli e account e completare altre attività del ciclo di vita NFT senza alcuna codifica aggiuntiva.

Blockchain App Builder genera automaticamente metodi per supportare NFT e cicli di vita NFT. È possibile utilizzare questi metodi per inizializzare NFT, gestire ruoli e account e completare altre attività del ciclo di vita NFT senza alcuna codifica aggiuntiva. I metodi 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.

• Gestione del controllo dell'accesso
• Gestione configurazione token
• Gestione account
• Gestione ruoli
• Gestione cronologia transazioni
• Gestione comportamento token
  • Comportamento minimo
  • Comportamento trasferibile
  • Comportamento masterizzabile

Metodi per la gestione del controllo degli accessi

AddTokenAdmin

Questo metodo aggiunge un utente come Token Admin del codice concatenato. Questo metodo può essere chiamato 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 MSP (Membership Service Provider) 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 chiamato 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 MSP (Membership Service Provider) 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 è 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 MSP (Membership Service Provider) 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 è 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 chiamato 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:

• Una volta completata la procedura, 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 token

Init

Questo metodo viene richiamato quando viene creata un'istanza del codice concatenato. Ogni Token Admin è identificato dalle informazioni UserId e OrgId nel parametro adminList. UserId è il nome utente o l'ID e-mail del proprietario dell'istanza o dell'utente che ha eseguito il login all'istanza. OrgId è l'ID MSP (Membership Service Provider) dell'utente nell'organizzazione di rete corrente. Il parametro adminList è obbligatorio alla prima distribuzione del codice concatenato. Se si sta aggiornando il codice concatenato, passare un elenco vuoto ([]). 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: array di informazioni {OrgId, UserId} che specifica la lista di 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 chiamato solo da un Token Admin del codice concatenato. Questo metodo utilizza query avanzate SQL DB Berkeley 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 avanzate SQL DB Berkeley 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 dell'account.

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 MSP (Membership Service Provider) dell'utente nell'organizzazione corrente.
• userId: string: il nome utente o l'ID e-mail dell'utente.

Restituisce:

• Lista di asset di 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 chiamato solo quando si è connessi 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 chiamare questo metodo in base alle esigenze dai metodi personalizzati. Quando si crea un asset o una classe tokenizzata, aggiornare lo switch case con la classe Token corrispondente per restituire l'oggetto token corretto. Il comando ochain sync in Blockchain App Builder crea automaticamente uno switch case 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 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 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:

• Una volta completato, un oggetto JSON dell'URI del 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 chiamato 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:

• Al completamento dell'operazione, un oggetto JSON del conteggio 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 chiamato 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:

• Al completamento dell'operazione, un oggetto JSON del conteggio 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 NFT di cui dispone un utente. Gli utenti devono disporre di account nella rete per completare le operazioni correlate al token. È possibile creare un solo account 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, il nome utente o l'ID e-mail (UserId) del proprietario dell'istanza o dell'utente che ha eseguito il login all'istanza e la stringa costante nft. Questo metodo può essere chiamato 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 MSP (Membership Service Provider) 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 NFT detenuti da un utente specificato. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal proprietario dell'account.

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 MSP (Membership Service Provider) 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 chiamato solo da un Token Admin del codice concatenato. Questo metodo utilizza query avanzate SQL DB Berkeley 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:

• Al successo, 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 del conto per un utente specificato. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal 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 MSP (Membership Service Provider) 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 seguenti proprietà:
• AccountId: l'ID dell'account utente.
• UserId: il nome utente o l'ID e-mail dell'utente.
• OrgId - L'ID MSP (Membership Service Provider) dell'utente nell'organizzazione corrente.
• TokenType: il tipo di token che contiene l'account.
• NoOfNfts – Il numero totale di NFT detenuti dal conto.
• BapAccountVersion: parametro dell'oggetto account 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 del conto per un utente specificato. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal proprietario dell'account.

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 MSP (Membership Service Provider) dell'utente nell'organizzazione corrente.
• userId: string: il nome utente o l'ID e-mail dell'utente.

Restituisce:

• In caso di operazione riuscita, un elenco 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 gestione ruoli

AddRole

Questo metodo aggiunge un ruolo a un utente specificato. Questo metodo può essere chiamato 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 MSP (Membership Service Provider) 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 chiamato 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 MSP (Membership Service Provider) 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 chiamato 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:

• Una volta completato, 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 chiamato 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 chiamato solo da un Token Admin del codice concatenato o dal 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 MSP (Membership Service Provider) 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 gestione cronologia transazioni

GetAccountTransactionHistory

Questo metodo restituisce la cronologia delle transazioni del 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 MSP (Membership Service Provider) dell'utente nell'organizzazione corrente.
• userId: string: il nome utente o l'ID e-mail dell'utente.

Restituisce:

• In caso di operazione riuscita, un elenco 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 del conto per un utente specificato, filtrata in base a PageSize, Bookmark, StartTime e EndTime. Questo metodo può essere chiamato 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 dell'account.

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 MSP (Membership Service Provider) 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 di pagina predefinita è 20. La proprietà Bookmark determina l'indice iniziale dei record da restituire. Per ulteriori informazioni, consultare la documentazione di Hyperledger Fabric. Le proprietà StartTime e EndTime devono essere specificate nel formato RFC-3339.

Restituisce:

• In caso di operazione riuscita, un elenco 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 dell'account.

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 operazione riuscita, un elenco 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 precedenti a un indicatore orario specificato nel database di stato. Questo metodo può essere chiamato 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: data e ora. Tutte le transazioni prima dell'indicatore orario verranno eliminate.

Restituisce:

• In caso di operazione riuscita, un elenco 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 - Comportamento minimo

Create<Token Name>Token

Questo metodo crea (mints) un NFT. L'asset e le proprietà associate vengono salvate nel database di stato. Il chiamante di questa transazione deve avere un account token. Il chiamante di questa transazione diventa il proprietario di 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 avere il ruolo minore. Altrimenti, 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>: l'asset token da zecca. Per ulteriori informazioni sulle proprietà dell'asset token, vedere il file delle specifiche 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 token.
• CreatedBy: l'ID account dell'utente che ha richiamato la transazione per coniare il token.
• CreationDate – La data e l'ora della transazione.
• IsBurned: valore booleano che indica se l'NFT identificato da tokenId viene bruciato.
• Mintable: descrizione delle proprietà del funzionamento estraibile. 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 del token 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 - comportamento trasferibile

SafeTransferFrom

Questo metodo trasferisce la proprietà dell'NFT specificato dal chiamante a un altro conto. Questo metodo include le convalide riportate di seguito.

• Il token esiste e non viene masterizzato.
• Il conto mittente e il conto ricevente esistono e non sono lo stesso conto.
• 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 MSP (Membership Service Provider) del mittente nell'organizzazione corrente.
• fromUserId: string – Il nome utente o l'ID e-mail del mittente.
• toOrgId: string - L'ID MSP (Membership Service Provider) 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 successo, un messaggio con i dettagli del conto mittente e 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'NFT specificato 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 convalide riportate di seguito.

• Il token esiste e non viene masterizzato.
• Il conto mittente e il conto ricevente esistono e non sono lo stesso conto.
• 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 MSP (Membership Service Provider) del mittente nell'organizzazione corrente.
• fromUserId: string – Il nome utente o l'ID e-mail del mittente.
• toOrgId: string - L'ID MSP (Membership Service Provider) 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 successo, un messaggio con i dettagli del conto mittente e 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 - comportamento masterizzabile

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 non viene specificata alcuna proprietà burner_role_name nella sezione roles del file di specifica, 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 più piccolo (creatore) del token in grado di 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 successo, 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 la cronologia dei 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 non viene specificata alcuna proprietà burner_role_name nella sezione roles del file di specifica, 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 minore (creatore) o il proprietario del token in grado di 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 dei 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 seguente mostra come utilizzare i metodi SDK token nei metodi personalizzati. Quando viene chiamato il metodo Sell, viene pubblicato un token per la vendita a 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

• Gestione del controllo dell'accesso
• Gestione configurazione token
• Gestione account
• Gestione ruoli
• Gestione cronologia transazioni
• Gestione comportamento token
  • Comportamento minimo
  • Comportamento trasferibile
  • Comportamento masterizzabile

Metodi per la gestione del controllo degli accessi

L'SDK NFT fornisce una funzione di controllo dell'accesso. Alcuni metodi possono essere richiamati solo da un Token Admin o Account Owner del token. È possibile utilizzare questa funzione per garantire che le operazioni vengano eseguite solo dagli utenti destinatari. Qualsiasi accesso non autorizzato comporta un errore. Per utilizzare la funzione di controllo dell'accesso, importare la classe Authorization dal modulo ../lib/auth.

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

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 MSP (Membership Service Provider) 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 MSP (Membership Service Provider) 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)"}

IsUserTokenAdmin

Questo metodo restituisce una mappa con il valore booleano true se il chiamante della funzione è un Token Admin. Altrimenti, il metodo restituisce false.

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

Parametri:

• orgId: l'ID MSP (Membership Service Provider) dell'utente nell'organizzazione di rete corrente.
• userId: il nome utente o l'ID e-mail dell'utente.

Restituisce:

• Una risposta booleana.

Esempio:

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

{"result":true}

GetAllAdmins

Questo metodo restituisce un elenco di tutti gli utenti Token Admin.

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

Parametri:

• nessuno

Restituisce:

• In caso di operazione riuscita, 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"
        }
    ]
}

CheckAuthorization

Utilizzare questo metodo per aggiungere un controllo di accesso a un'operazione. La maggior parte dei metodi generati automaticamente include il controllo dell'accesso. Alcuni metodi di token possono essere eseguiti solo da un ERC721Admin o dal Account Owner del token o dal 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 mostrato nel testo seguente. È possibile modificare il controllo dell'accesso modificando il file oChainUtil.go. Per utilizzare il proprio controllo dell'accesso o disabilitare il controllo dell'accesso, rimuovere il codice di controllo dell'accesso dai metodi del controller generati automaticamente e dai metodi personalizzati.

  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 descritti nel file oChainUtil.go.
• ...args: argomento di variabile in cui args[0] accetta la costante 'TOKEN' e args[1] utilizza 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 controllo TokenOwner, args[1] accetta il parametro tokenId.

Restituisce:

• Una risposta booleana e, se necessario, un errore.

Esempi:

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

accesso Admin

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

Accesso a AccountOwner

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

Accesso a MultipleAccountOwner

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

Accesso a TokenOwner

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

Metodi per la gestione della configurazione token

CreateToken

Questo metodo crea un token e ne salva le proprietà nel database di stato. Questo metodo può essere chiamato solo dagli utenti con il ruolo minore.

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

Parametri:

• Argomento di variabile in cui args[0] contiene un riferimento al token struct del tipo richiesto.

Restituisce:

• Una volta completato, 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"
}

GetAllTokens

Questo metodo restituisce tutti gli asset token salvati nel database di stato. Questo metodo utilizza query avanzate SQL DB Berkeley 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 successo, 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 avanzate SQL DB Berkeley 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",
        }
        }
    }
]

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:

• Al completamento, 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"}

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:

• Al 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": ""
        }
    }
]

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: argomento di variabile, in cui il primo argomento result[0] è un riferimento a un oggetto Token vuoto del 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"
}

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

Name

Questo metodo restituisce il nome della classe 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"}

Symbol

Questo metodo restituisce il simbolo della classe 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"}

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:

• Al completamento, 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"}

TotalSupply

Questo metodo restituisce il numero totale di NFT coniati.

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 numerico. In caso di errore, un rifiuto con un messaggio di errore.

Esempio:

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}

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 del token 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 della struttura del token del tipo richiesto

Restituisce:

• In caso di operazione riuscita, un messaggio promessa con dettagli 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",
}

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 di transazione nelle librerie SDK quando sono in esecuzione transazioni concorrenti.

GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext

Parametri:

• stub: 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 MSP (Membership Service Provider) 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 NFT di cui dispone un utente. Gli utenti devono disporre di account nella rete per completare le operazioni correlate al token. È possibile creare un solo account 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, il nome utente o l'ID e-mail (userId) del proprietario dell'istanza o dell'utente che ha eseguito il login all'istanza e la stringa costante nft.

Ctx.ERC721Account.CreateAccount(orgId string, userId string, tokenType string) (ERC721Account, error)

Parametri:

• orgId: string - L'ID MSP (Membership Service Provider) 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 account. In caso di errore, un oggetto non nullo 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
}

BalanceOf

Questo metodo restituisce il numero totale di NFT bloccati dall'utente specificato.

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

Parametri:

• accountId: string: l'ID account dell'utente.

Restituisce:

• Al 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}

GetAllAccounts

Questo metodo restituisce un elenco di tutti i conti. Questo metodo utilizza query avanzate SQL DB Berkeley e può essere richiamato solo quando si è connessi alla rete remota di Oracle Blockchain Platform.

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

Parametri:

• nessuno

Restituisce:

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

GetAccountByUser

Questo metodo restituisce i dettagli del conto per un utente specificato. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal Account Owner dell'account.

Ctx.ERC721Account.GetAccountByUser(orgId, userId) (ERC721Account, error)

Parametri:

• orgId: string - L'ID MSP (Membership Service Provider) 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 seguenti proprietà:
• AccountId: l'ID dell'account utente.
• UserId: il nome utente o l'ID e-mail dell'utente.
• OrgId - L'ID MSP (Membership Service Provider) dell'utente nell'organizzazione corrente.
• TokenType: il tipo di token che contiene l'account.
• 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
}

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 MSP (Membership Service Provider) 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"
}

History

Questo metodo restituisce un array dei dettagli della cronologia 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 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"
        }
    }
]

GetAccountWithStatusByUser

Questo metodo restituisce i dettagli del conto per un utente specificato, incluso lo stato del conto. Questo metodo può essere chiamato solo da un Token Admin del codice concatenato o dal Account Owner dell'account.

Ctx.ERC721Account.GetAccountWithStatusByUser(orgId, userId) (interface{}, error)

Parametri:

• orgId: string - L'ID MSP (Membership Service Provider) 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 seguenti proprietà:
• AccountId: l'ID dell'account utente.
• UserId: il nome utente o l'ID e-mail dell'utente.
• OrgId - L'ID MSP (Membership Service Provider) dell'utente nell'organizzazione corrente.
• TokenType: il tipo di token che contiene l'account.
• NoOfNfts – Il numero totale di NFT detenuti dal conto.
• BapAccountVersion: parametro dell'oggetto account 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"
}

Metodi per gestione 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 operare.

Restituisce:

• 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 da un token specificati. Un ID account è formato dalla 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 operare.

Restituisce:

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

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:

• Una volta completato, 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"
        }
    ]
}

IsInRole

Questo metodo restituisce un valore booleano per indicare se un utente e un token hanno un ruolo specificato. Un ID account è formato dalla 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 operare.

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 non nullo contenente un messaggio di errore

Esempio:

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

{"result": false}

Metodi per gestione cronologia 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 account in formato JSON:
  • TransactionId: l'ID della transazione.
  • TransactedAccount – Il conto con cui è avvenuta la transazione.
  • TransactionType: tipo di transazione.
  • Timestamp – Il tempo 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 del conto per un utente specificato, filtrata in base a PageSize, Bookmark, startTime e endTime. Questo metodo può essere chiamato solo quando si è connessi alla rete remota di Oracle Blockchain Platform.

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

Parametri:

• accountId: string – 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 di pagina predefinita è 20. La proprietà Bookmark determina l'indice iniziale dei record da restituire. Per ulteriori informazioni, consultare la documentazione di Hyperledger Fabric. Le proprietà StartTime e EndTime devono essere specificate nel formato RFC-3339.

Restituisce:

• In caso di operazione riuscita, un array di oggetti transazione account in formato JSON:
  • TransactionId: l'ID della transazione.
  • TransactedAccount – Il conto con cui è avvenuta la transazione.
  • TransactionType: tipo di transazione.
  • Timestamp – Il tempo 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 dell'asset transazione.

Restituisce:

• Al successo, una serie di mappe di asset di 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 le transazioni che risalgono a una data precedente a quella specificata dal database di stato.

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 comportamento token - comportamento di importanza minore

GetMaxMintQuantity

Questo metodo restituisce la quantità massima estraibile di un token. Se il funzionamento di max_mint_quantity non è configurato nel file di specifica, il valore predefinito è 0 e è possibile coniare 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à massima estraibile 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 successo, una mappa dei token coniati totali, nel tipo di dati numerici e un messaggio di successo. In caso di errore, un oggetto non nullo con un messaggio di errore.

Esempio:

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

Gestione comportamento token - comportamento trasferibile

SafeTransferFrom

Questo metodo trasferisce la proprietà dell'NFT specificato dal chiamante a un altro conto. Questo metodo include le convalide riportate di seguito.

• Il token esiste e non viene masterizzato.
• Il conto mittente e il conto ricevente esistono e non sono lo stesso conto.
• 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 destinatario nell'organizzazione corrente.
• tokenAsset: il riferimento all'asset token su cui eseguire l'operazione.
• data: string: informazioni aggiuntive facoltative da memorizzare nella transazione.

Restituisce:

• In caso di successo, una promessa con un messaggio di successo 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'NFT specificato 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 convalide riportate di seguito.

• Il token esiste e non viene masterizzato.
• Il conto mittente e il conto ricevente esistono e non sono lo stesso conto.
• 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 destinatario nell'organizzazione corrente.
• tokenAsset: il riferimento all'asset token su cui eseguire l'operazione.

Restituisce:

• In caso di successo, una promessa con un messaggio di successo 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.

\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 comportamento token - comportamento masterizzabile

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 non viene specificata alcuna proprietà burner_role_name nella sezione roles del file di specifica, 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 più piccolo (creatore) del token in grado di 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 l'operazione.

Restituisce:

• In caso di successo, una promessa con un messaggio di successo 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"}