Projeto Scaffolded Go NFT para ERC-721

O Blockchain App Builder pega a entrada do seu arquivo de especificação NFT e gera um projeto de chaincode totalmente funcional.

O projeto gera automaticamente classes e funções de ciclo de vida NFT, incluindo métodos CRUD e não CRUD. Validação de argumentos, marshalling/unmarshalling e capacidade de persistência transparente são suportados automaticamente.

Para obter informações sobre o projeto e os métodos do andaime que não estão diretamente relacionados aos NFTs, consulte Projeto do Chaincode do andaime Go.

Reference:

• Modelo
• Controladora
  • Métodos NFT Gerados Automaticamente
  • Métodos Personalizados
• Métodos do NFT SDK

Modelo

O Recurso de Persistência Transparente, ou ORM simplificado, é capturado na 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"`
}

Controlador

Há apenas um controlador principal.

type Controller struct {
    Ctx trxcontext.TrxContext
}

Você pode criar qualquer número de classes, funções ou arquivos, mas apenas os métodos que são definidos dentro da classe de controlador principal são invocáveis. Os outros métodos estão ocultos.

Você pode usar os métodos SDK de token para criar métodos personalizados para seu aplicativo de negócios.

Métodos NFT Gerados Automaticamente

O Blockchain App Builder gera automaticamente métodos para suportar ciclos de vida de NFTs e NFTs. Você pode usar esses métodos para inicializar NFTs, gerenciar funções e contas e concluir outras tarefas do ciclo de vida de NFT sem qualquer codificação adicional.

O Blockchain App Builder gera automaticamente métodos para suportar ciclos de vida de NFTs e NFTs. Você pode usar esses métodos para inicializar NFTs, gerenciar funções e contas e concluir outras tarefas do ciclo de vida de NFT sem qualquer codificação adicional. Os métodos da Controladora devem ser públicos para serem chamados. Os nomes dos métodos públicos começam com um caractere maiúsculo. Os nomes dos métodos que começam com um caractere minúsculo são privados.

• Gerenciamento de Controle de Acesso
• Gerenciamento de Configuração de Token
• Gerenciamento de Contas
• Gerenciamento de Atribuições
• Gerenciamento do Histórico de Transações
• Gerenciamento de Comportamento de Token
  • Comportamento Mínimo
  • Comportamento Transferível
  • Comportamento Queimável

Métodos para Gerenciamento de Controle de Acesso

AddTokenAdmin

Este método adiciona um usuário como um Token Admin do chaincode. Este método pode ser chamado somente por um Token Admin do chaincode.

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

Parâmetros:

• orgId string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de sucesso, uma mensagem que inclui detalhes do usuário que foi adicionado como um Token Admin do chaincode.

Exemplo de valor de retorno:

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

RemoveTokenAdmin

Este método remove um usuário como um Token Admin do chaincode. Este método pode ser chamado somente por um Token Admin do chaincode. Você não pode usar esse método para remover a si mesmo como um 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)
}

Parâmetros:

• orgId string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de êxito, uma mensagem que inclui detalhes do usuário que foi removido como Token Admin do chaincode.

Exemplo de valor de retorno:

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

IsTokenAdmin

Esse método retornará o valor booliano true se o chamador da função for Token Admin; caso contrário, ele retornará false. Um Token Admin pode chamar essa função em qualquer outro usuário na rede blockchain. Outros usuários só podem chamar esse método em suas próprias contas.

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

Parâmetros:

• orgId string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• O método retornará true se o chamador for Token Admin; caso contrário, retornará false.

Exemplo de valor de retorno:

{"result":true}

GetAllTokenAdmins

Esse método retorna uma lista de todos os usuários que são um Token Admin do chaincode. Este método pode ser chamado somente pelo Token Admin do chaincode.

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

Parâmetros:

• nenhuma

Retorna:

• Em caso de sucesso, uma lista JSON de administradores que inclui objetos OrgId e UserId.

Exemplo de valor de retorno:

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

Métodos para Gerenciamento de Configuração de Token

Init

Esse método é chamado quando o chaincode é instanciado. Cada Token Admin é identificado pelas informações UserId e OrgId no parâmetro adminList. O UserId é o nome do usuário ou o ID do e-mail do proprietário da instância ou do usuário que está conectado à instância. O OrgId é o ID do provedor de serviços de associação (MSP) do usuário na organização de rede atual. O parâmetro adminList é obrigatório na primeira vez que você implanta o chaincode. Se você estiver atualizando o chaincode, passe uma lista vazia ([]). Qualquer outra informação no parâmetro adminList é ignorada durante os upgrades.

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
}

Parâmetros:

• adminList array – Um array de informações {OrgId, UserId} que especifica a lista de administradores de token. O array adminList é um parâmetro obrigatório.

GetAllTokens

Esse método retorna todos os ativos de token salvos no banco de dados de estado. Este método pode ser chamado somente por um Token Admin do chaincode. Esse método usa consultas ricas em SQL de BD Berkeley e só pode ser chamado quando conectado à rede remota do 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()
}

Parâmetros:

• nenhuma

Retorna:

• Uma lista de todos os ativos de token no formato JSON.

Exemplo de valor de retorno:

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

Esse método retorna todos os ativos de token pertencentes a um usuário especificado. Esse método usa consultas ricas em SQL de BD Berkeley e só pode ser chamado quando conectado à rede remota do Oracle Blockchain Platform. Esse método só pode ser chamado por um Token Admin do chaincode ou pelo proprietário da conta.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Uma lista de ativos de token no formato JSON.

Exemplo de valor de retorno:

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

Esse método retornará um objeto de token se o token estiver presente no banco de dados de estado. Esse método só pode ser chamado por um Token Admin do chaincode ou do proprietário do 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
}

Parâmetros:

• tokenId: string – O ID do token a ser obtido.

Retorna:

• O ativo de token no formato JSON.

Exemplo de valor de retorno:

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

Este método retorna o histórico de um ID de token especificado. Esse método só pode ser chamado quando conectado à rede remota do Oracle Blockchain Platform. Qualquer um pode chamar esse método.

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

Parâmetros:

• tokenId: string – O ID do token.

Exemplo de valor de retorno:

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

Este é um método de utilitário que retorna uma instância do token para um ID de token especificado. Esse método é usado por muitos dos métodos gerados automaticamente para extrair objetos de token. Você pode chamar esse método conforme necessário nos métodos personalizados. Quando você criar um ativo ou uma classe tokenizada, atualize o caso de alternância com a classe Token correspondente para retornar o objeto de token correto. O comando ochain sync no Blockchain App Builder cria automaticamente um caso de alternância quando um ativo tokenizado é criado no arquivo de especificação. Como esse método é privado, ele não é diretamente invocável e só pode ser chamado de outros métodos.

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

Parâmetros:

• tokenId: string – O ID do token.

OwnerOf

Este método retorna o ID da conta do proprietário do ID do token especificado. Qualquer um pode chamar esse método.

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

Parâmetros:

• tokenId: string – O ID do token.

Retorna:

• Um objeto JSON do ID da conta do proprietário.

Exemplo de valor de retorno:

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}

Name

Esse método retorna o nome da classe do token. Qualquer um pode chamar esse método.

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

Parâmetros:

• nenhuma

Retorna:

• Um objeto JSON do nome do token.

Exemplo de valor de retorno:

{"TokenName": "paintingnft"}

Symbol

Esse método retorna o símbolo da classe do token. Qualquer um pode chamar esse método.

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

Parâmetros:

• nenhuma

Retorna:

• Um objeto JSON do símbolo de token.

Exemplo de valor de retorno:

{"Symbol": "PNT"}

TokenURI

Esse método retorna o URI de um token especificado. Qualquer um pode chamar esse método.

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

Parâmetros:

• tokenId: string – O ID do token.

Retorna:

• Em caso de sucesso, um objeto JSON do URI do token.

Exemplo de valor de retorno:

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

TotalSupply

Este método retorna o número total de tokens cunhados. Este método pode ser chamado somente por um Token Admin do chaincode.

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

Parâmetros:

• nenhuma

Retorna:

• Com êxito, um objeto JSON da contagem de tokens.

Exemplo de valor de retorno:

{"TotalSupply": 3}

TotalNetSupply

Este método retorna o número total de tokens cunhados menos o número de tokens gravados. Este método pode ser chamado somente por um Token Admin do chaincode.

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

Parâmetros:

• nenhuma

Retorna:

• Com êxito, um objeto JSON da contagem de tokens.

Exemplo de valor de retorno:

{"TotalNetSupply": 2}

Métodos para Gerenciamento de Contas

CreateAccount

Esse método cria uma conta para um usuário e token especificados. Uma conta deve ser criada para qualquer usuário que terá tokens a qualquer momento. As contas rastreiam o número de NFTs que um usuário tem. Os usuários devem ter contas na rede para concluir operações relacionadas a token. Você pode criar apenas uma conta NFT por usuário.

Um ID de conta é um conjunto alfanumérico de caracteres, prefixado com oaccount~ e seguido por um hash SHA-256 do ID do provedor de serviços de associação (OrgId) do usuário na organização de rede atual, o nome de usuário ou o ID de e-mail (UserId) do proprietário da instância ou do usuário que está conectado à instância e a string constante nft. Este método pode ser chamado somente pelo Token Admin do chaincode.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.
• tokenType: string – O único tipo de token suportado é nonfungible.

Retorna:

• Com êxito, um objeto JSON da conta que foi criado.

Exemplo de valor de retorno:

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

BalanceOf

Este método retorna o número total de NFTs que um usuário especificado mantém. Esse método só pode ser chamado por um Token Admin do chaincode ou pelo proprietário da conta.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Um objeto JSON da contagem de NFT atual.

Exemplo de valor de retorno:

{"totalNfts": 0}

GetAllAccounts

Esse método retorna uma lista de todas as contas. Este método pode ser chamado somente por um Token Admin do chaincode. Esse método usa consultas ricas em SQL de BD Berkeley e só pode ser chamado quando conectado à rede remota do 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()
}

Parâmetros:

• nenhuma

Retorna:

• Com sucesso, um array JSON de todas as contas.

Exemplo de valor de retorno:

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

Este método retorna detalhes da conta de um usuário especificado. Esse método só pode ser chamado por um Token Admin do chaincode ou pelo Account Owner da conta.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de sucesso, um objeto de conta JSON que inclui as seguintes propriedades:
• AccountId – O ID da conta de usuário.
• UserId – O nome do usuário ou o ID do e-mail do usuário.
• OrgId – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• TokenType – O tipo de token que a conta mantém.
• NoOfNfts – O número total de NFTs detidos pela conta.
• BapAccountVersion – Um parâmetro de objeto de conta para uso interno.
• Status – O status atual da conta do usuário.

Exemplo de valor de retorno:

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

GetUserByAccountId

Este método retorna os detalhes do usuário de uma conta especificada. Esse método pode ser chamado por qualquer usuário.

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

Parâmetros:

• accountId: string – O ID da conta.

Retorna:

• Em caso de sucesso, um objeto JSON dos detalhes do usuário (OrgId e UserId).

Exemplo de valor de retorno:

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

GetAccountHistory

Este método retorna o histórico da conta de um usuário especificado. Esse método só pode ser chamado por um Token Admin do chaincode ou pelo proprietário da conta.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de sucesso, uma lista de objetos.

Exemplo de valor de retorno:

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

Métodos para Gerenciamento de Atribuições

AddRole

Este método adiciona uma atribuição a um usuário especificado. Este método pode ser chamado somente por um Token Admin do chaincode.

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

Parâmetros:

• userRole: string – O nome da atribuição a ser adicionada ao usuário especificado. Os comportamentos mintable e burnable correspondem às propriedades minter_role_name e burner_role_name do arquivo de especificação.
• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de êxito, uma mensagem com detalhes do usuário.

Exemplo de valor de retorno:

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

RemoveRole

Este método remove uma atribuição de um usuário especificado. Este método pode ser chamado somente por um Token Admin do chaincode.

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

Parâmetros:

• userRole: string – O nome da atribuição a ser removida do usuário especificado. Os comportamentos mintable e burnable correspondem às propriedades minter_role_name e burner_role_name do arquivo de especificação.
• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de êxito, uma mensagem com detalhes do usuário.

Exemplo de valor de retorno:

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

GetAccountsByRole

Esse método retorna uma lista de todos os IDs de contas para uma função especificada. Este método pode ser chamado somente por um Token Admin do chaincode.

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

Parâmetros:

• userRole: string – O nome da atribuição a ser pesquisada.

Retorna:

• Com êxito, um array JSON de IDs de conta.

Exemplo de valor de retorno:

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

GetUsersByRole

Esse método retorna uma lista de todos os usuários de uma atribuição especificada. Este método pode ser chamado somente por um Token Admin do chaincode.

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

Parâmetros:

• userRole: string – O nome da atribuição a ser pesquisada.

Retorna:

• Em caso de sucesso, um array JSON dos objetos do usuário (orgId e userId).

Exemplo de valor de retorno:

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

IsInRole

Esse método retorna um valor Booliano para indicar se um usuário tem uma atribuição especificada. Esse método só pode ser chamado por um Token Admin do chaincode ou pelo Account Owner da conta.

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
}

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.
• userRole: string – O nome da atribuição a ser pesquisada.

Retorna:

• Em caso de sucesso, uma string JSON do resultado booliano.

Exemplo de valor de retorno:

{"result":"true"}

Métodos para Gerenciamento do Histórico de Transações

GetAccountTransactionHistory

Este método retorna o histórico de transações da conta para um usuário especificado. Esse método pode ser chamado pelo Token Admin do chaincode ou pelo proprietário da conta.

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
}

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de sucesso, uma lista de objetos.

Exemplo de valor de retorno:

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

Esse método retorna o histórico de transações da conta de um usuário especificado, filtrado por PageSize, Bookmark, StartTime e EndTime. Esse método só pode ser chamado quando conectado à rede remota do Oracle Blockchain Platform. Esse método só pode ser chamado por um Token Admin do chaincode ou pelo proprietário da conta.

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
}

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.
• filters: string – Um parâmetro opcional. Se estiver vazio, todos os registros serão retornados. A propriedade PageSize determina o número de registros a serem retornados. Se PageSize for 0, o tamanho padrão da página será 20. A propriedade Bookmark determina o índice inicial dos registros a serem retornados. Para obter mais informações, consulte a documentação do Hyperledger Fabric. As propriedades StartTime e EndTime devem ser especificadas no formato RFC-3339.

Retorna:

• Em caso de sucesso, uma lista de objetos.

Exemplo de valor de retorno:

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

Este método retorna o histórico de transações de um ID de transação especificado. Esse método só pode ser chamado por um Token Admin do chaincode ou pelo proprietário da conta.

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

Parâmetros:

• transactionId: string – O ID do ativo da transação.

Retorna:

• Em caso de sucesso, uma lista de objetos.

Exemplo de valor de retorno:

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

Este método exclui transações anteriores a um timestamp especificado no banco de dados de estado. Este método pode ser chamado somente pelo Token Admin do chaincode.

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

Parâmetros:

• timestamp: Date – Um timestamp. Todas as transações antes do carimbo de data/hora serão excluídas.

Retorna:

• Em caso de sucesso, uma lista de objetos.

Exemplo de valor de retorno:

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

Métodos para Gerenciamento do Comportamento de Token - Comportamento Mínimo

Create<Token Name>Token

Este método cria (mints) um NFT. O ativo e as propriedades associadas são salvos no banco de dados de estado. O chamador desta transação deve ter uma conta de token. O chamador desta transação se torna o proprietário do NFT. Se o arquivo de especificação de token incluir a seção roles para behaviors e a propriedade minter_role_name para roles, o chamador da transação deverá ter a atribuição de minter. Caso contrário, qualquer chamador pode cunhar NFTs.

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

Parâmetros:

• tokenAsset: <Token Class> – O ativo de token a ser cunhado. Para obter mais informações sobre as propriedades do ativo de token, consulte o arquivo de especificação de entrada.

Retorna:

• Em caso de sucesso, um objeto de ativo de token JSON que inclui as seguintes propriedades:
• Behavior – Uma descrição de todos os comportamentos do token.
• CreatedBy – O ID da conta do usuário que chamou a transação para gerar o token.
• CreationDate – O carimbo de data e hora da transação.
• IsBurned – Um valor booliano que indica se o NFT identificado por tokenId foi gravado.
• Mintable – Uma descrição das propriedades do comportamento mintable. A propriedade max_mint_quantity especifica o número máximo de NFTs dessa classe de token que pode ser criada.
• Owner – O ID da conta do proprietário atual do token. Durante o processo de cunhagem, o chamador desse método se torna o proprietário do token.
• Symbol – O símbolo do token.
• TokenDesc – A descrição do token.
• TokenMetadata – Informações JSON que descrevem o token.
• TokenName – O nome do token.
• TokenStandard – O padrão do token.
• TokenType – O tipo de token mantido por esta conta.
• TokenUnit – A unidade do token.
• TokenUri – O URI do token.

Exemplo de valor de retorno:

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

Este método atualiza as propriedades do token. Esse método só pode ser chamado pelo usuário que é o proprietário ou criador do token. Após a criação de um ativo de token, somente o proprietário do token poderá atualizar as propriedades personalizadas do token. Se o usuário for proprietário do token e criador de um token, ele também poderá atualizar a propriedade TokenDesc. Os metadados do token não podem ser atualizados. Você deve passar todas as propriedades de token para esse método, mesmo que queira atualizar apenas determinadas propriedades.

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

Parâmetros:

• tokenAsset: <Token Class> – O ativo de token a ser atualizado. Para obter mais informações sobre as propriedades do ativo de token, consulte o arquivo de especificação de entrada.

Retorna:

• Em caso de sucesso, um objeto de ativo de token JSON atualizado

Exemplo de valor de retorno:

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

Métodos para Gerenciamento do Comportamento de Token - Comportamento Transferível

SafeTransferFrom

Este método transfere a propriedade do NFT especificado do chamador para outra conta. Este método inclui as seguintes validações:

• O token existe e não é queimado.
• A conta do remetente e a conta do recebedor existem e não são a mesma conta.
• A conta do remetente possui o token.
• O chamador da função é o remetente.

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

Parâmetros:

• fromOrgId: string – O ID do prestador de serviço de associação (MSP) do remetente na organização atual.
• fromUserId: string – O nome do usuário ou o ID do e-mail do remetente.
• toOrgId: string – O ID do prestador de serviço de associação (MSP) do destinatário na organização atual.
• toUserId: string – O nome do usuário ou o ID do e-mail do destinatário.
• tokenId: string – O ID do token a ser transferido.
• data: string – Informações adicionais opcionais a serem armazenadas no registro de transação.

Retorna:

• Em caso de êxito, uma mensagem com os detalhes da conta do remetente e do destinatário.

Exemplo de valor de retorno:

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

Este método transfere a propriedade do NFT especificado de uma conta de remetente para uma conta de destinatário. É responsabilidade do chamador passar os parâmetros corretos. Esse método pode ser chamado por qualquer usuário, não apenas pelo proprietário do token. Este método inclui as seguintes validações:

• O token existe e não é queimado.
• A conta do remetente e a conta do recebedor existem e não são a mesma conta.
• A conta do remetente possui o 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())
}

Parâmetros:

• fromOrgId: string – O ID do prestador de serviço de associação (MSP) do remetente na organização atual.
• fromUserId: string – O nome do usuário ou o ID do e-mail do remetente.
• toOrgId: string – O ID do prestador de serviço de associação (MSP) do destinatário na organização atual.
• toUserId: string – O nome do usuário ou o ID do e-mail do destinatário.
• tokenId: string – O ID do token a ser transferido.

Retorna:

• Em caso de êxito, uma mensagem com os detalhes da conta do remetente e do destinatário.

Exemplo de valor de retorno:

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

Métodos para Gerenciamento do Comportamento de Token - Comportamento Queimável

Burn

Este método desativa ou queima o NFT especificado da conta do chamador. O chamador desse método deve ter uma conta. Um token não pode ser gravado, a menos que o arquivo de especificação do token inclua o comportamento burnable. Se nenhuma propriedade burner_role_name for especificada na seção roles do arquivo de especificação, o proprietário do token poderá gravar o token. Se uma propriedade burner_role_name for especificada na seção roles, o usuário designado à atribuição de gravador que também é o mineiro (criador) do token poderá gravar o 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())
}

Parâmetros:

• tokenId: string – O ID do token a ser gravado.

Retorna:

• Em caso de êxito, uma mensagem com os detalhes da conta.

Exemplo de valor de retorno:

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

BurnNFT

Esse método desativa ou queima o NFT especificado da conta do chamador e retorna um objeto de token e um histórico de token. O chamador desse método deve ter uma conta. Um token não pode ser gravado, a menos que o arquivo de especificação do token inclua o comportamento burnable. Se nenhuma propriedade burner_role_name for especificada na seção roles do arquivo de especificação, o proprietário do token poderá gravar o token. Se uma propriedade burner_role_name for especificada na seção roles, o usuário designado à atribuição de gravador que também é o mineiro (criador) ou proprietário do token poderá gravar o 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
}

Parâmetros:

• tokenId: string – O ID do token a ser gravado.

Retorna:

• Com êxito, um objeto de token que inclui informações de histórico de token.

Exemplo de valor de retorno:

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

Métodos Personalizados

Você pode usar os métodos SDK de token para criar métodos personalizados para seu aplicativo de negócios.

O exemplo a seguir mostra como usar métodos SDK de token em métodos personalizados. Quando o método Sell é chamado, ele publica um token à venda por um preço especificado.

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
}

Métodos do NFT SDK

• Gerenciamento de Controle de Acesso
• Gerenciamento de Configuração de Token
• Gerenciamento de Contas
• Gerenciamento de Atribuições
• Gerenciamento do Histórico de Transações
• Gerenciamento de Comportamento de Token
  • Comportamento Mínimo
  • Comportamento Transferível
  • Comportamento Queimável

Métodos para Gerenciamento de Controle de Acesso

O NFT SDK fornece uma função de controle de acesso. Alguns métodos só podem ser chamados por um Token Admin ou Account Owner do token. Você pode usar esse recurso para garantir que as operações sejam executadas apenas pelos usuários desejados. Qualquer acesso não autorizado resulta em erro. Para usar a função de controle de acesso, importe a classe Authorization do módulo ../lib/auth.

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

CheckAuthorization

Use esse método para adicionar uma verificação de controle de acesso a uma operação. A maioria dos métodos gerados automaticamente inclui o controle de acesso. Determinados métodos de token só podem ser executados por um ERC721Admin ou pelo Account Owner do token ou pelo MultipleAccountOwner para usuários com várias contas. O método CheckAuthorization faz parte do pacote erc721Auth, que você acessa por meio da estrutura Ctx (receptor). O mapeamento do controle de acesso é descrito no arquivo oChainUtil.go, conforme mostrado no texto a seguir. Você pode modificar o controle de acesso editando o arquivo oChainUtil.go. Para usar seu próprio controle de acesso ou desativar o controle de acesso, remova o código de controle de acesso dos métodos de controlador gerados automaticamente e métodos personalizados.

  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)

Parâmetros:

• funcName: string – O valor de mapa entre os receptores e os métodos, conforme descrito no arquivo oChainUtil.go.
• ...args – Um argumento de variável em que args[0] usa a constante 'TOKEN' e args[1] usa o parâmetro accountId para adicionar uma verificação de controle de acesso para um AccountOwner. Para adicionar uma verificação de controle de acesso para um MultipleAccountOwner, args[1] usa o parâmetro orgId e args[2] usa o parâmetro userId. Para adicionar uma verificação de controle de acesso para um TokenOwner, args[1] usa o parâmetro tokenId.

Retorna:

• Uma resposta booleana e, se necessário, um erro.

Exemplos de:

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

Admin acesso

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

AccountOwner acesso

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

MultipleAccountOwner acesso

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

TokenOwner acesso

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

IsUserTokenAdmin

Esse método retornará um mapa com o valor booliano true se o chamador da função for Token Admin. Caso contrário, o método retornará false.

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

Parâmetros:

• orgId – O ID do provedor de serviços de associação (MSP) do usuário na organização de rede atual.
• userId – O nome do usuário ou o ID do e-mail do usuário.

Retorna:

• Uma resposta booleana.

Exemplo:

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

{"result":true}

AddAdmin

Esse método adiciona um usuário como Token Admin do chaincode do token.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de sucesso, uma mensagem que lista os detalhes do usuário adicionado como Token Admin do chaincode de token. Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

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

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

RemoveAdmin

Esse método remove um usuário como Token Admin do chaincode do token.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de sucesso, uma mensagem que lista os detalhes do usuário removidos como Token Admin do chaincode do token. Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

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

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

GetAllAdmins

Esse método retorna uma lista de todos os usuários Token Admin.

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

Parâmetros:

• nenhuma

Retorna:

• Em caso de sucesso, uma lista de todos os usuários Token Admin. Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Admin.GetAllAdmins()

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

GetAllAdminUsers

Esse método retorna uma lista de todos os usuários Token Admin.

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

Parâmetros:

• nenhuma

Retorna:

• Em caso de sucesso, uma lista de todos os usuários Token Admin no formato map[string]interface{}. Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Admin.GetAllAdminUsers()

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

Métodos para Gerenciamento de Configuração de Token

CreateToken

Este método cria um token e salva suas propriedades no banco de dados de estado. Esse método só pode ser chamado por usuários com a atribuição de minter.

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

Parâmetros:

• Um argumento de variável em que args[0] contém uma referência ao token struct do tipo necessário.

Retorna:

• Em caso de sucesso, um interface[] com detalhes do token. Em caso de erro, um objeto não nulo com uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.CreateToken(&tokenAsset)

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

GetTokenUri

Esse método retorna o URI do token para um token especificado.

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

Parâmetros:

• tokenId: string – O ID do token.

Retorna:

• Em caso de sucesso, ele retorna um mapa do novo URI do token no tipo de dados da string. Em caso de erro, um objeto não nulo com uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.GetTokenURI(tokenId)

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

TokenUri

Esse método retorna o URI do token para um token especificado.

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

Parâmetros:

• tokenId: string – O ID do token.

Retorna:

• Em caso de sucesso, ele retorna um mapa do novo URI do token no tipo de dados da string. Em caso de erro, um objeto não nulo com uma mensagem de erro.

Exemplo de valor de retorno:

t.Ctx.ERC721Token.TokenURI(tokenId)

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

Symbol

Esse método retorna o símbolo da classe do token.

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

Parâmetros:

• nenhuma

Retorna:

• Em caso de sucesso, um mapa do símbolo no tipo de dados da string. Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}

Name

Esse método retorna o nome da classe do token.

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

Parâmetros:

• nenhuma

Retorna:

• Com êxito, um mapa do nome do token no tipo de dados da string. Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.Name()

{"TokenName": "paintingnft"}

OwnerOf

Este método retorna o ID da conta do proprietário de um token especificado.

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

Parâmetros:

• tokenId: string – O ID do token.

Retorna:

• Em caso de êxito, um mapa do ID da conta do proprietário no tipo de dados da string. Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.OwnerOf(tokenId)

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}

TotalSupply

Este método retorna o número total de NFTs cunhados.

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

Parâmetros:

• tokenId: string – O ID do token.

Retorna:

• Em caso de sucesso, um mapa do suprimento total de tokens no tipo de dados de número. Em caso de erro, uma rejeição com uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}

GetAllTokens

Esse método retorna todos os ativos de token salvos no banco de dados de estado. Esse método usa consultas ricas em SQL de BD Berkeley e só pode ser chamado quando conectado à rede remota do Oracle Blockchain Platform.

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

Parâmetros:

• nenhuma

Retorna:

• No sucesso, um mapa de todos os ativos de token. Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

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

Este método retorna todos os tokens pertencentes a um ID de conta especificado. Esse método usa consultas ricas em SQL de BD Berkeley e só pode ser chamado quando conectado à rede remota do Oracle Blockchain Platform.

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

Parâmetros:

• accountId: string – O ID da conta.

Retorna:

• Com êxito, um mapa de ativos de token para a conta especificada. Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.GetAllTokensByUser(accountId)

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

Get

Esse método retornará o objeto de token especificado se ele estiver presente no banco de dados de estado.

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

Parâmetros:

• tokenId: string – O ID do token.
• result – Um argumento de variável, em que o primeiro argumento result[0] é uma referência a um objeto Token vazio do tipo correto, que conterá os dados do token após uma chamada bem-sucedida do método.

Retorna:

• Com êxito, um mapa com os dados do ativo de token. Além disso, se result[0] for informado, os dados serão designados a result[0]. Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

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

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

UpdateToken

Este método atualiza as propriedades do token. Esse método só pode ser chamado pelo proprietário ou criador do token. Após a criação de um ativo de token, somente o proprietário do token poderá atualizar as propriedades personalizadas do token. Se o usuário for proprietário do token e criador de um token, ele também poderá atualizar a propriedade TokenDesc. Os metadados do token não podem ser atualizados. Você deve passar todas as propriedades de token para esse método, mesmo que queira atualizar apenas determinadas propriedades.

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

Parâmetros:

• Uma referência aos dados de estrutura de token do tipo necessário

Retorna:

• Em caso de sucesso, uma mensagem de promessa com detalhes do token. Em caso de erro, uma rejeição com uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.UpdateToken(&asset)

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

History

Este método retorna o histórico do token especificado.

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

Parâmetros:

• tokenId: string – O ID do token.

Retorna:

• No sucesso, uma série de mapas. Em caso de erro, uma rejeição com uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.History(tokenId)

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

GetNewCtx

Esse método retorna um novo objeto TrxContext. A estrutura trxcontext contém referências a todas as bibliotecas SDK. Acesse os métodos sdk usando somente esse objeto. O objeto trxcontext mantém a exclusividade mútua de stubs de transação nas bibliotecas SDK quando transações simultâneas estão em execução.

GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext

Parâmetros:

• stub – O stub de transação.

Retorna:

• Uma estrutura trxcontext.

Exemplo:

trxcontext.GetNewCtx(stub)

trxcontext object.

Métodos para Gerenciamento de Conta

GenerateAccountId

Esse método retorna um ID de conta, que é formado pela concatenação do ID do provedor de serviços de associação (orgId) e do nome de usuário ou ID de e-mail (userId) e, em seguida, pela criação de um hash SHA-256.

Ctx.ERC721Account.GenerateAccountId(orgId string, userId string) (string, error)

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Com êxito, o ID da conta gerado. Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

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

oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507

CreateAccount

Este método cria uma conta para um usuário especificado. Uma conta deve ser criada para qualquer usuário que terá tokens a qualquer momento. As contas rastreiam o número de NFTs que um usuário tem. Os usuários devem ter contas na rede para concluir operações relacionadas a token. Você pode criar apenas uma conta NFT por usuário.

Um ID de conta é um conjunto alfanumérico de caracteres, prefixado com oaccount~ e seguido por um hash SHA-256 do ID do provedor de serviços de associação (org_id) do usuário na organização de rede atual, o nome de usuário ou o ID de e-mail (userId) do proprietário da instância ou do usuário que está conectado à instância e a string constante nft.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.
• tokenType: string – O único tipo de token suportado é nonfungible.

Retorna:

• Com êxito, o novo objeto da conta. Em caso de erro, um objeto não nulo contendo uma mensagem de erro

Exemplo:

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

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

GetAllAccounts

Esse método retorna uma lista de todas as contas. Esse método usa consultas ricas em SQL de BD Berkeley e só pode ser chamado quando conectado à rede remota do Oracle Blockchain Platform.

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

Parâmetros:

• nenhuma

Retorna:

• Um array JSON de todas as contas.

Exemplo:

t.Ctx.ERC721Account.GetAllAccounts()

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

History

Esse método retorna uma matriz dos detalhes do histórico da conta de uma conta especificada.

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

Parâmetros:

• accountId: string – O ID da conta.

Retorna:

• Em caso de sucesso, um array map[string]interface{} que contém os detalhes do histórico da conta especificada. Os dados da conta são mostrados sob a chave value no mapa. Em caso de erro, um objeto de erro não nulo contendo uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Account.History(accountId)

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

GetUserByAccountId

Este método retorna os detalhes do usuário de uma conta especificada.

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

Parâmetros:

• accountId: string – O ID da conta.

Retorna:

• Em caso de sucesso, um objeto JSON que inclui detalhes do usuário nas seguintes propriedades:
  • OrgId – O ID do provedor de serviços de associação (MSP) do usuário na organização de rede atual.
  • UserId – O nome do usuário ou o ID do e-mail do usuário.
• Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

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

GetAccountWithStatusByUser

Este método retorna detalhes da conta de um usuário especificado, incluindo o status da conta. Esse método só pode ser chamado por um Token Admin do chaincode ou pelo Account Owner da conta.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de sucesso, um objeto de conta JSON que inclui as seguintes propriedades:
• AccountId – O ID da conta de usuário.
• UserId – O nome do usuário ou o ID do e-mail do usuário.
• OrgId – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• TokenType – O tipo de token que a conta mantém.
• NoOfNfts – O número total de NFTs detidos pela conta.
• BapAccountVersion – Um parâmetro de objeto de conta para uso interno.
• Status – O status atual da conta do usuário.
• Em caso de erro, um objeto não nulo que contém uma mensagem de erro.

Exemplo:

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

GetAccountByUser

Este método retorna detalhes da conta de um usuário especificado. Esse método só pode ser chamado por um Token Admin do chaincode ou pelo Account Owner da conta.

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

Parâmetros:

• orgId: string – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• userId: string – O nome de usuário ou o ID de e-mail do usuário.

Retorna:

• Em caso de sucesso, um objeto de conta JSON que inclui as seguintes propriedades:
• AccountId – O ID da conta de usuário.
• UserId – O nome do usuário ou o ID do e-mail do usuário.
• OrgId – O ID do prestador de serviço de associação (MSP) do usuário na organização atual.
• TokenType – O tipo de token que a conta mantém.
• NoOfNfts – O número total de NFTs detidos pela conta.
• Em caso de erro, um objeto não nulo que contém uma mensagem de erro.

Exemplo:

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

BalanceOf

Este método retorna o número total de NFTs que o usuário especificado mantém.

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

Parâmetros:

• accountId: string – O ID da conta do usuário.

Retorna:

• Em caso de sucesso, uma interface com uma mensagem e o número total de NFTs. Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Account.BalanceOf(accountId)

{"TotalNfts": 0}

Métodos para Gerenciamento de Atribuições

AddRoleMember

Este método adiciona uma atribuição a um usuário especificado.

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

Parâmetros:

• role: string – O nome da atribuição a ser adicionada ao usuário especificado. Os comportamentos mintable e burnable correspondem às propriedades minter_role_name e burner_role_name do arquivo de especificação.
• accountId: number – O ID da conta na qual operar.

Retorna:

• Se bem-sucedido, um mapa com uma mensagem de sucesso. Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

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

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

RemoveRoleMember

Esse método remove uma atribuição de um usuário e token especificados. Um ID de conta é formado pela criação de um hash SHA-256 do ID do provedor de serviços de associação concatenado (orgId) e do nome de usuário ou ID de e-mail (userId).

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

Parâmetros:

• role: string – O nome da atribuição a ser removida do usuário especificado. Os comportamentos mintable e burnable correspondem às propriedades minter_role_name e burner_role_name do arquivo de especificação.
• accountId: number – O ID da conta na qual operar.

Retorna:

• Se bem-sucedido, um mapa com uma mensagem de sucesso. Em caso de erro, um objeto não nulo contendo uma mensagem de erro.

Exemplo:

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

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

IsInRole

Esse método retorna um valor Booliano para indicar se um usuário e token têm uma atribuição especificada. Um ID de conta é formado pela criação de um hash SHA-256 do ID do provedor de serviços de associação concatenado (orgId) e do nome de usuário ou ID de e-mail (userId).

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

Parâmetros:

• role: string – O nome da atribuição a ser verificada para o usuário especificado. Os comportamentos mintable e burnable correspondem às propriedades minter_role_name e burner_role_name do arquivo de especificação.
• accountId: number – O ID da conta na qual operar.

Retorna:

• Em caso de êxito, um valor Booliano que será verdadeiro se a função estiver presente para o ID da conta especificado, caso contrário, será falso. Em caso de erro, um objeto não nulo contendo uma mensagem de erro

Exemplo:

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

{"result": false}

GetAccountsByRole

Esse método retorna uma lista de todos os IDs de contas para uma função especificada.

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

Parâmetros:

• roleName: string – O nome da atribuição a ser pesquisada.

Retorna:

• Com êxito, um array JSON de IDs de conta. Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Role.GetAccountsByRole(userRole)

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

GetUsersByRole

Esse método retorna uma lista de todos os usuários de uma atribuição especificada.

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

Parâmetros:

• roleName: string – O nome da atribuição a ser pesquisada.

Retorna:

• Em caso de sucesso, um array JSON de objetos do usuário. Cada objeto contém o ID usuário e o ID organização. Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Role.GetUsersByRole(userRole)

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

Métodos para Gerenciamento do Histórico de Transações

GetAccountTransactionHistory

Esse método retorna uma matriz dos detalhes do histórico de transações de uma conta especificada.

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

Parâmetros:

• accountId: string – O ID da conta.

Retorna:

• Com êxito, um array de objetos de transação de conta no formato JSON:
  • TransactionId – O ID da transação.
  • TransactedAccount – A conta com a qual a transação ocorreu.
  • TransactionType – O tipo de transação.
  • Timestamp – O horário da transação.
  • Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

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

Esse método retorna o histórico de transações da conta de um usuário especificado, filtrado por PageSize, Bookmark, startTime e endTime. Esse método só pode ser chamado quando conectado à rede remota do Oracle Blockchain Platform.

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

Parâmetros:

• accountId: string – ID da conta.
• filters: string – Um parâmetro opcional. Se estiver vazio, todos os registros serão retornados. A propriedade PageSize determina o número de registros a serem retornados. Se PageSize for 0, o tamanho padrão da página será 20. A propriedade Bookmark determina o índice inicial dos registros a serem retornados. Para obter mais informações, consulte a documentação do Hyperledger Fabric. As propriedades StartTime e EndTime devem ser especificadas no formato RFC-3339.

Retorna:

• Com êxito, um array de objetos de transação de conta no formato JSON:
  • TransactionId – O ID da transação.
  • TransactedAccount – A conta com a qual a transação ocorreu.
  • TransactionType – O tipo de transação.
  • Timestamp – O horário da transação.
  • Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

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

Esse método retorna o histórico de um ativo Transaction.

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

Parâmetros:

• trxId: string – O ID do ativo da transação.

Retorna:

• Em caso de sucesso, uma matriz de mapas de ativos de transação. Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

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

Este método exclui transações anteriores a uma data especificada do banco de dados de estado.

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

Parâmetros:

• referenceTime: string – As transações anteriores à hora especificada serão excluídas.

Retorna:

• Em caso de êxito, uma matriz de IDs de transação excluídos e uma mensagem de êxito. Em caso de erro, um objeto de erro não nulo que contém uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)

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

Gerenciamento do Comportamento do Token - Comportamento Mínimo

GetMaxMintQuantity

Este método retorna a quantidade mínima máxima de um token. Se o comportamento max_mint_quantity não estiver configurado no arquivo de especificação, o valor padrão será 0 e um número infinito de tokens poderá ser cunhado.

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

Parâmetros:

• id – O ID do token no qual operar.

Retorna:

• Em caso de sucesso, a quantidade mínima máxima do token, no tipo de dados de número. Em caso de erro, um objeto não nulo com uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.GetMaxMintQuantity(tokenId);

20000

GetTotalMintedTokens

Este método retorna o número líquido total de tokens disponíveis no sistema para o token especificado. O número líquido de tokens disponíveis é o número total de tokens cunhados menos o número de tokens queimados.

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

Parâmetros:

• nenhuma

Retorna:

• Em caso de sucesso, um mapa do total de tokens cunhados, no tipo de dados de número e uma mensagem de sucesso. Em caso de erro, um objeto não nulo com uma mensagem de erro.

Exemplo:

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

Gerenciamento de Comportamento de Token - Comportamento Transferível

SafeTransferFrom

Este método transfere a propriedade do NFT especificado do chamador para outra conta. Este método inclui as seguintes validações:

• O token existe e não é queimado.
• A conta do remetente e a conta do recebedor existem e não são a mesma conta.
• A conta do remetente possui o token.
• O chamador da função é o remetente.

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

Parâmetros:

• fromAccountId: string – O ID da conta do remetente na organização atual.
• toAccountId: string – O ID da conta do destinatário na organização atual.
• tokenAsset – A referência ao ativo de token no qual operar.
• data: string – Informações adicionais opcionais a serem armazenadas na transação.

Retorna:

• Em caso de êxito, uma promessa com uma mensagem de êxito que inclui detalhes da conta. Em caso de erro, um objeto não nulo com uma mensagem de erro.

Exemplo:

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

Este método transfere a propriedade do NFT especificado de uma conta de remetente para uma conta de destinatário. É responsabilidade do chamador passar os parâmetros corretos. Esse método pode ser chamado por qualquer usuário, não apenas pelo proprietário do token. Este método inclui as seguintes validações:

• O token existe e não é queimado.
• A conta do remetente e a conta do recebedor existem e não são a mesma conta.
• A conta do remetente possui o token.

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

Parâmetros:

• fromAccountId: string – O ID da conta do remetente na organização atual.
• toAccountId: string – O ID da conta do destinatário na organização atual.
• tokenAsset – A referência ao ativo de token no qual operar.

Retorna:

• Em caso de êxito, uma promessa com uma mensagem de êxito que inclui detalhes da conta. Os IDs de conta têm o prefixo oaccount~. Em caso de erro, um objeto não nulo com uma mensagem de erro.

\Por exemplo:

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

Gerenciamento de comportamento de token - Comportamento gravável

Burn

Este método desativa ou queima o NFT especificado da conta do chamador. O chamador desse método deve ter uma conta. Um token não pode ser gravado, a menos que o arquivo de especificação do token inclua o comportamento burnable. Se nenhuma propriedade burner_role_name for especificada na seção roles do arquivo de especificação, o proprietário do token poderá gravar o token. Se uma propriedade burner_role_name for especificada na seção roles, o usuário designado à atribuição de gravador que também é o mineiro (criador) do token poderá gravar o token. O método burn faz parte do pacote ERC721Token, que você acessa por meio do receptor da estrutura Ctx.

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

Parâmetros:

• tokenAsset – A referência ao ativo de token no qual operar.

Retorna:

• Em caso de êxito, uma promessa com uma mensagem de êxito que inclui detalhes da conta. Em caso de erro, um objeto não nulo com uma mensagem de erro.

Exemplo:

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

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