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

Metodi Go per blocco NFT ERC-721

Blockchain App Builder genera automaticamente metodi che è possibile utilizzare per bloccare i token non fungibili che utilizzano lo standard ERC-721 esteso.

Un token bloccato non può essere masterizzato o trasferito ad altri utenti. Vengono conservate tutte le altre proprietà, ad esempio lo stato, il proprietario e la cronologia del token. È possibile utilizzare la funzionalità di blocco NFT quando si trasferisce un token su un'altra rete blockchain, come Ethereum o Polygon.

Prima di poter bloccare gli NFT, è necessario assegnare il ruolo di vault manager a un utente. Il gestore del vault è un tipo speciale di ruolo, un ruolo TokenSys. I ruoli TokenSys sono diversi dai ruoli basati sugli asset, ad esempio masterizzatore, minter e notaio, nonché dai ruoli amministrativi quali Token Admin e Org Admin. Attualmente Blockchain App Builder supporta il ruolo vault TokenSys. Il singolo utente che dispone del ruolo vault per un codice concatenato è il gestore vault del codice concatenato e può gestire NFT bloccati.

Il flusso tipico per l'utilizzo della funzionalità di blocco NFT segue questi passaggi.
  • Creare un token non fungibile con il funzionamento bloccabile.
  • Utilizzare il metodo AddTokenSysRole per assegnare il ruolo vault a un utente, il gestore vault.
  • Chiamare il metodo LockNFT per bloccare un token non fungibile specificato dall'ID token.

TokenSys Metodi di gestione dei ruoli

AddTokenSysRole
Questo metodo aggiunge un ruolo TokenSys a un utente specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
func (t *Controller) AddTokenSysRole(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.AddTokenSysRole", "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.AddTokenSysRoleMember(role, accountId)
}
Parametri:
  • role: string: il nome del ruolo TokenSys da assegnare all'utente.
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un messaggio contenente i dettagli rilevanti dell'operazione.
Esempio di valore restituito:
{
    "msg": "Successfully added role 'vault' to Account Id: oaccount~bf07f584a94be44781e49d9101bfaf58c6fbbe77a4dfebdb83c874c2caf03eba (Org-Id: Org1MSP, User-Id: user1)"
}
IsInTokenSysRole
Questo metodo restituisce un valore booleano per indicare se un utente dispone di un ruolo TokenSys specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
func (t *Controller) IsInTokenSysRole(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.IsInTokenSysRole", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
    }
    return t.Ctx.ERC721Token.IsInTokenSysRoleMember(role, accountId)
}
Parametri:
  • role: string: il nome del ruolo TokenSys da controllare.
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un messaggio contenente i dettagli rilevanti dell'operazione.
Esempio di valore restituito:
{
    "result": true,
    "msg": "Account Id oaccount~bf07f584a94be44781e49d9101bfaf58c6fbbe77a4dfebdb83c874c2caf03eba (Org-Id: Org1MSP, User-Id: user1) has vault role"
}
RemoveTokenSysRole
Questo metodo rimuove un ruolo TokenSys da un utente specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
func (t *Controller) RemoveTokenSysRole(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.RemoveTokenSysRole", "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.RemoveTokenSysRoleMember(role, accountId)
}
Parametri:
  • role: string: il nome del ruolo TokenSys da rimuovere.
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente.
Restituisce:
  • In caso di operazione riuscita, un messaggio contenente i dettagli rilevanti dell'operazione.
Esempio di valore restituito:
{
    "msg": "Successfully removed role 'vault' from Account Id: oaccount~bf07f584a94be44781e49d9101bfaf58c6fbbe77a4dfebdb83c874c2caf03eba (Org-Id: Org1MSP, User-Id: user1)"
}
TransferTokenSysRole
Questo metodo trasferisce un ruolo TokenSys da un utente a un altro utente. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
func (t *Controller) TransferTokenSysRole(role string, fromOrgId string, fromUserId string, toOrgId string, toUserId string) (interface{}, error) {
    auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.TransferTokenSysRole", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
    }
    fromAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(fromOrgId, fromUserId)
    if err != nil {
        return nil, fmt.Errorf("error in TransferTokenSysRole. Error: %s", err)
    }
    toAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(toOrgId, toUserId)
    if err != nil {
        return nil, fmt.Errorf("error in TransferTokenSysRole. Error: %s", err)
    }
    return t.Ctx.ERC721Token.TransferTokenSysRole(role, fromAccountId, toAccountId)
}
Parametri:
  • role: string: il nome del ruolo TokenSys da trasferire.
  • fromOrgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente da cui trasferire il ruolo TokenSys.
  • fromUserId: string: il nome utente o l'ID e-mail dell'utente da cui trasferire il ruolo TokenSys.
  • toOrgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente a cui trasferire il ruolo TokenSys.
  • toUserId: string: il nome utente o l'ID e-mail dell'utente a cui trasferire il ruolo TokenSys.
Restituisce:
  • In caso di operazione riuscita, un messaggio contenente i dettagli rilevanti dell'operazione.
Esempio di valore restituito:
{
    "msg": "Successfully transfered role 'vault' from Account Id: ouaccount~f4e311528f03fffa7810753d643f66289ff6c9080fcf839902f28a1d3aff1789 (Org-Id: Org1MSP, User-Id: user1) to Account Id: ouaccount~ae5be2ae8f98d6d32f5d02b43877d987114e7937c7bacbc30390dcce09996a19 (Org-Id: Org1MSP, User-Id: user2)"
}
GetAccountsByTokenSysRole
Questo metodo restituisce un elenco di tutti gli ID account per un ruolo TokenSys specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
func (t *Controller) GetAccountsByTokenSysRole(role string) (interface{}, error) {
    auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetAccountsByTokenSysRole", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
    }
    return t.Ctx.ERC721Token.GetAccountsByTokenSysRole(role)
}
Parametri:
  • role: string: il nome del ruolo TokenSys.
Restituisce:
  • In caso di operazione riuscita, un messaggio contenente i dettagli rilevanti dell'operazione.
Esempio di valore restituito:
{
    "accountIds": [
        "oaccount~bf07f584a94be44781e49d9101bfaf58c6fbbe77a4dfebdb83c874c2caf03eba"
    ]
}
GetUsersByTokenSysRole
Questo metodo restituisce le informazioni utente per tutti gli utenti con un ruolo TokenSys specificato. Questo metodo può essere richiamato solo da un Token Admin del codice concatenato. 
func (t *Controller) GetUsersByTokenSysRole(role string) (interface{}, error) {
    auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetUsersByTokenSysRole", "TOKEN")
    if err != nil && !auth {
        return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
    }
    return t.Ctx.ERC721Token.GetUsersByTokenSysRole(role)
}
Parametri:
  • role: string: il nome del ruolo TokenSys.
Restituisce:
  • In caso di operazione riuscita, un messaggio contenente i dettagli rilevanti dell'operazione.
Esempio di valore restituito:
{
   "Users":[
      {
         "accountId":"oaccount~bf07f584a94be44781e49d9101bfaf58c6fbbe77a4dfebdb83c874c2caf03eba",
         "orgId":"Org1MSP",
         "userId":"user1"
      }
   ]
}

Metodi di blocco NFT

LockNFT
Questo metodo blocca un token non fungibile specificato. Per bloccare un token, deve esistere un utente con il ruolo TokenSys vault che funge da gestore del vault. Questo metodo può essere chiamato solo dal proprietario del token. 
func (t *Controller) LockNFT(tokenId string) (interface{}, error) {
    return t.Ctx.ERC721Token.LockNFT(tokenId)
}
Parametri:
  • tokenID: string: l'ID del token da bloccare.
Restituisce:
  • In caso di operazione riuscita, una rappresentazione JSON dell'oggetto token.
Esempio di valore restituito:
{
   "AssetType":"otoken",
   "Behavior":[
      "indivisible",
      "singleton",
      "mintable",
      "transferable",
      "lockable",
      "burnable",
      "roles"
   ],
   "CreatedBy":"oaccount~208e3345ac84b4849f0d2648b2f2f018019886a1230f99304ebff1b6a7733463",
   "CreationDate":"2023-10-20T12:39:50Z",
   "IsBurned":false,
   "IsLocked":true,
   "Mintable":{
      "Max_mint_quantity":20000
   },
   "On_sale_flag":false,
   "Owner":"oaccount~208e3345ac84b4849f0d2648b2f2f018019886a1230f99304ebff1b6a7733463",
   "Price":120,
   "Roles":{
      "minter_role_name":"minter"
   },
   "Symbol":"ART",
   "TokenDesc":"",
   "TokenId":"token1",
   "TokenMetadata":{
      "Description":"",
      "Image":"",
      "Painter_name":"",
      "Painting_name":""
   },
   "TokenName":"artcollection",
   "TokenStandard":"erc721+",
   "TokenType":"nonfungible",
   "TokenUnit":"whole",
   "TokenUri":"token1.example.com"
}
IsNFTLocked
Questo metodo restituisce un valore booleano per indicare se un token specificato è bloccato. Questo metodo può essere richiamato solo dal proprietario del token, dal gestore del vault (l'utente con il ruolo TokenSys vault) o da un Token Admin del codice concatenato. 
func (t *Controller) IsNFTLocked(tokenId string) (interface{}, error) {
    auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.IsNFTLocked", "TOKEN", map[string]string{"tokenId": tokenId})
    if err != nil && !auth {
        isCallerTokenSysRoleHolder, error := t.Ctx.ERC721Token.IsCallerTokenSysRoleHolder(constants.Vault)
        if error != nil {
            return nil, error
        }
        if !isCallerTokenSysRoleHolder {
            return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
        }
    }
    return t.Ctx.ERC721Token.IsNFTLocked(tokenId)
}
Parametri:
  • tokenID: string: l'ID del token.
Restituisce:
  • In caso di operazione riuscita, un messaggio contenente i dettagli rilevanti dell'operazione.
Esempio di valore restituito:
{
   "isNFTLocked":true
}
GetAllLockedNFTs
Questo metodo restituisce un elenco di tutti i token non fungibili bloccati. Questo metodo può essere chiamato solo dal gestore del vault (l'utente con il ruolo TokenSys vault) o da un Token Admin del codice concatenato. 
func (t *Controller) GetAllLockedNFTs() (interface{}, error) {
    auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetAllLockedNFTs", "TOKEN")
    if err != nil && !auth {
        isCallerTokenSysRoleHolder, error := t.Ctx.ERC721Token.IsCallerTokenSysRoleHolder(constants.Vault)
        if error != nil {
            return nil, error
        }
        if !isCallerTokenSysRoleHolder {
            return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
        }
    }
    return t.Ctx.ERC721Token.GetAllLockedNFTs()
}
Parametri:
  • Nessuno.
Restituisce:
  • In caso di operazione riuscita, un array di oggetti token non fungibili bloccati.
Esempio di valore restituito:
[
   {
      "key":"token1",
      "valueJson":{
         "AssetType":"otoken",
         "Behavior":[
            "indivisible",
            "singleton",
            "mintable",
            "transferable",
            "lockable",
            "burnable",
            "roles"
         ],
         "CreatedBy":"oaccount~208e3345ac84b4849f0d2648b2f2f018019886a1230f99304ebff1b6a7733463",
         "CreationDate":"2023-10-20T12:39:50Z",
         "IsBurned":false,
         "IsLocked":true,
         "Mintable":{
            "Max_mint_quantity":20000
         },
         "On_sale_flag":false,
         "Owner":"oaccount~208e3345ac84b4849f0d2648b2f2f018019886a1230f99304ebff1b6a7733463",
         "Price":120,
         "Roles":{
            "minter_role_name":"minter"
         },
         "Symbol":"ART",
         "TokenDesc":"",
         "TokenId":"token1",
         "TokenMetadata":{
            "Description":"",
            "Image":"",
            "Painter_name":"",
            "Painting_name":""
         },
         "TokenName":"artcollection",
         "TokenStandard":"erc721+",
         "TokenType":"nonfungible",
         "TokenUnit":"whole",
         "TokenUri":"token1.example.com"
      }
   }
]
GetAllLockedNFTsByOrg
Questo metodo restituisce un elenco di tutti i token non fungibili bloccati per un'organizzazione specificata e, facoltativamente, per un utente specificato. Questo metodo può essere chiamato solo dal gestore del vault (l'utente con il ruolo TokenSys vault) o da un Token Admin del codice concatenato. 
func (t *Controller) GetLockedNFTsByOrg(orgId string, userId ...string) (interface{}, error) {
    auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.GetLockedNFTsByOrg", "TOKEN")
    if err != nil && !auth {
        isCallerTokenSysRoleHolder, error := t.Ctx.ERC721Token.IsCallerTokenSysRoleHolder(constants.Vault)
        if error != nil {
            return nil, error
        }
        if !isCallerTokenSysRoleHolder {
            return nil, fmt.Errorf("error in authorizing the caller  %s", err.Error())
        }
    }
    return t.Ctx.ERC721Token.GetLockedNFTsByOrg(orgId, userId...)
}
Parametri:
  • orgId: string: l'ID del provider di servizi di appartenenza (MSP) dell'utente nell'organizzazione corrente.
  • userId: string: il nome utente o l'ID e-mail dell'utente (facoltativo).
Restituisce:
  • In caso di operazione riuscita, un array di oggetti token non fungibili bloccati.
Esempio di valore restituito:
[
   {
      "key":"token1",
      "valueJson":{
         "AssetType":"otoken",
         "Behavior":[
            "indivisible",
            "singleton",
            "mintable",
            "transferable",
            "lockable",
            "burnable",
            "roles"
         ],
         "CreatedBy":"oaccount~208e3345ac84b4849f0d2648b2f2f018019886a1230f99304ebff1b6a7733463",
         "CreationDate":"2023-10-20T12:39:50Z",
         "IsBurned":false,
         "IsLocked":true,
         "Mintable":{
            "Max_mint_quantity":20000
         },
         "On_sale_flag":false,
         "Owner":"oaccount~208e3345ac84b4849f0d2648b2f2f018019886a1230f99304ebff1b6a7733463",
         "Price":120,
         "Roles":{
            "minter_role_name":"minter"
         },
         "Symbol":"ART",
         "TokenDesc":"",
         "TokenId":"token1",
         "TokenMetadata":{
            "Description":"",
            "Image":"",
            "Painter_name":"",
            "Painting_name":""
         },
         "TokenName":"artcollection",
         "TokenStandard":"erc721+",
         "TokenType":"nonfungible",
         "TokenUnit":"whole",
         "TokenUri":"token1.example.com"
      }
   }
]