1. Uso de Oracle Blockchain Platform
  2. Creación de códigos de cadenas con el creador de aplicaciones de blockchain de poco código
  3. Soporte de tokenización mediante el creador de aplicaciones de blockchain
  4. ERC-721
  5. Proyecto Go NFT de andamios para ERC-721

Proyecto Go NFT de andamios para ERC-721

Blockchain App Builder toma la entrada de su archivo de especificación NFT y genera un proyecto de código de cadenas de andamios totalmente funcional.

El proyecto genera automáticamente clases y funciones de ciclo de vida de NFT, incluidos los métodos CRUD y no CRUD. La validación de argumentos, la canalización/anulación de canalización y la capacidad de persistencia transparente se admiten automáticamente.

Para obtener información sobre el proyecto andamio y los métodos que no están directamente relacionados con NFT, consulte Scaffolded Go Chaincode Project.

Referencia:

Modelo

La capacidad de persistencia transparente, o ORM simplificado, se captura en la clase 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

Solo hay un controlador principal.

type Controller struct {
    Ctx trxcontext.TrxContext
}

Puede crear cualquier número de clases, funciones o archivos, pero solo se pueden invocar los métodos definidos en la clase de controlador principal. Los otros métodos están ocultos.

Puede utilizar los métodos de SDK de token para escribir métodos personalizados para la aplicación de negocio.

Métodos NFT generados automáticamente

Blockchain App Builder genera automáticamente métodos para soportar los ciclos de vida de NFT y NFT. Puede utilizar estos métodos para inicializar NFT, gestionar roles y cuentas y completar otras tareas del ciclo de vida de NFT sin necesidad de codificación adicional.

Blockchain App Builder genera automáticamente métodos para soportar los ciclos de vida de NFT y NFT. Puede utilizar estos métodos para inicializar NFT, gestionar roles y cuentas y completar otras tareas del ciclo de vida de NFT sin necesidad de codificación adicional. Los métodos de controlador deben ser públicos para poder ser invocables. Los nombres de métodos públicos comienzan con un carácter en mayúscula. Los nombres de método que comienzan con un carácter en minúscula son privados.

Métodos para la gestión del control de acceso

AddTokenAdmin
Este método agrega un usuario como Token Admin del código de cadenas. Este método solo puede ser llamado por un Token Admin del código de cadena. 
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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Cuando se realiza correctamente, un mensaje que incluye detalles del usuario que se ha agregado como Token Admin del código de cadena.
Ejemplo de valor de retorno:
{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveTokenAdmin
Este método elimina un usuario como Token Admin del código de cadenas. Este método solo puede ser llamado por un Token Admin del código de cadena. No puede utilizar este método para eliminarse a sí mismo como 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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Cuando se realiza correctamente, un mensaje que incluye detalles del usuario que se ha eliminado como Token Admin del código de cadena.
Ejemplo de valor de retorno:
{"msg":"Successfully removed Admin (OrgId Org1MSP UserId user1)"}
IsTokenAdmin
Este método devuelve el valor booleano true si el emisor de llamada de la función es Token Admin; de lo contrario, devuelve false. Un Token Admin puede llamar a esta función en cualquier otro usuario de la red de blockchain. Otros usuarios pueden llamar a este método solo en sus propias cuentas. 
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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • El método devuelve true si el emisor de llamada es Token Admin; de lo contrario, devuelve false.
Ejemplo de valor de retorno:
{"result":true}
GetAllTokenAdmins
Este método devuelve una lista de todos los usuarios que son Token Admin del código de cadenas. Este método solo puede ser llamado por el Token Admin del código de cadena. 
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:
  • ninguno
Devuelve:
  • Cuando se realiza correctamente, una lista JSON de administradores que incluye objetos OrgId y UserId.
Ejemplo de valor de retorno:
{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}

Métodos para la gestión de configuración de token

Init
Este método se llama cuando se crea una instancia del código de cadena. Cada Token Admin se identifica mediante la información UserId y OrgId en el parámetro adminList. UserId es el nombre de usuario o el ID de correo electrónico del propietario de la instancia o del usuario que está conectado a la instancia. OrgId es el ID de proveedor de servicios de miembros (MSP) del usuario en la organización de red actual. El parámetro adminList es obligatorio la primera vez que despliegue el código de cadena. Si va a actualizar el código de cadenas, pase una lista vacía ([]). Cualquier otra información del parámetro adminList se ignora durante las actualizaciones. 
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: matriz de información {OrgId, UserId} que especifica la lista de administradores de tokens. La matriz adminList es un parámetro obligatorio.
GetAllTokens
Este método devuelve todos los activos de token que se guardan en la base de datos de estado. Este método solo puede ser llamado por un Token Admin del código de cadena. Este método utiliza consultas enriquecidas de SQL de base de datos de Berkeley y solo se puede llamar cuando se conecta a la red remota de 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:
  • ninguno
Devuelve:
  • Lista de todos los activos de token en formato JSON.
Ejemplo 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
Este método devuelve todos los activos de token que son propiedad de un usuario especificado. Este método utiliza consultas enriquecidas de SQL de base de datos de Berkeley y solo se puede llamar cuando se conecta a la red remota de Oracle Blockchain Platform. Este método solo puede ser llamado por un Token Admin del código de cadenas o por el propietario de la cuenta. 
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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Lista de activos de token en formato JSON.
Ejemplo 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
Este método devuelve un objeto de token si el token está presente en la base de datos de estado. Este método solo puede ser llamado por un Token Admin del código de cadena o el propietario del token. 
func (t *Controller) GetTokenById(tokenId string) (interface{}, error) {
      auth, err := t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.Get", "TOKEN", map[string]string{"tokenId": tokenId})
      if err != nil && !auth {
            return nil, fmt.Errorf("error in authorizing the caller %s", err.Error())
      }
      tokenAsset, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      return tokenAsset.Interface(), nil
}
Parámetros:
  • tokenId: string: ID del token que se va a obtener.
Devuelve:
  • Activo de token en formato JSON.
Ejemplo 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 devuelve el historial de un ID de token especificado. Este método solo se puede llamar cuando está conectado a la red remota de Oracle Blockchain Platform. Cualquiera puede llamar a este 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: ID del token.
Ejemplo 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
Se trata de un método de utilidad que devuelve una instancia del token para un ID de token especificado. Muchos de los métodos generados automáticamente utilizan este método para recuperar objetos de token. Puede llamar a este método según sea necesario desde sus métodos personalizados. Al crear un activo o una clase con token, actualice el caso de cambio con la clase Token correspondiente para devolver el objeto de token correcto. El comando ochain sync del creador de aplicaciones de blockchain crea automáticamente un caso de cambio cuando se crea un activo tokenizado en el archivo de especificación. Debido a que este método es privado, no es directamente invocable y solo se puede llamar desde otros 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: ID del token.
OwnerOf
Este método devuelve el ID de cuenta del propietario del ID de token especificado. Cualquiera puede llamar a este método.
func (t *Controller) Ownerof(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.OwnerOf(tokenId)
}
Parámetros:
  • tokenId: string: ID del token.
Devuelve:
  • Objeto JSON del ID de cuenta del propietario.
Ejemplo de valor de retorno:
{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
Name
Este método devuelve el nombre de la clase de token. Cualquiera puede llamar a este método.
func (t *Controller) Name() (interface{}, error) {
      return t.Ctx.ERC721Token.Name()
}
Parámetros:
  • ninguno
Devuelve:
  • Objeto JSON del nombre de token.
Ejemplo de valor de retorno:
{"TokenName": "paintingnft"}
Symbol
Este método devuelve el símbolo de la clase de token. Cualquiera puede llamar a este método.
func (t *Controller) Symbol() (interface{}, error) {
      return t.Ctx.ERC721Token.Symbol()
}
Parámetros:
  • ninguno
Devuelve:
  • Objeto JSON del símbolo de token.
Ejemplo de valor de retorno:
{"Symbol": "PNT"}
TokenURI
Este método devuelve el URI de un token especificado. Cualquiera puede llamar a este método.
func (t *Controller) TokenURI(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.TokenURI(tokenId)
}
Parámetros:
  • tokenId: string: ID del token.
Devuelve:
  • Si se realiza correctamente, un objeto JSON del URI de token.
Ejemplo de valor de retorno:
{"TokenURI": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
TotalSupply
Este método devuelve el número total de tokens acuñados. Este método solo puede ser llamado por un Token Admin del código de cadena. 
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:
  • ninguno
Devuelve:
  • Si se realiza correctamente, un objeto JSON del recuento de tokens.
Ejemplo de valor de retorno:
{"TotalSupply": 3}
TotalNetSupply
Este método devuelve el número total de tokens minados menos el número de tokens quemados. Este método solo puede ser llamado por un Token Admin del código de cadena. 
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:
  • ninguno
Devuelve:
  • Si se realiza correctamente, un objeto JSON del recuento de tokens.
Ejemplo de valor de retorno:
{"TotalNetSupply": 2}

Métodos para la gestión de cuentas

CreateAccount
Este método crea una cuenta para un usuario y token especificados. Se debe crear una cuenta para cualquier usuario que tenga tokens en cualquier momento. Las cuentas realizan un seguimiento del número de NFT que tiene un usuario. Los usuarios deben tener cuentas en la red para completar las operaciones relacionadas con el token. Solo puede crear una cuenta de NFT por usuario.

Un ID de cuenta es un juego alfanumérico de caracteres, con el prefijo oaccount~ y seguido de un hash SHA-256 del ID de proveedor de servicios de miembros (OrgId) del usuario en la organización de red actual, el nombre de usuario o el ID de correo electrónico (UserId) del propietario de la instancia o del usuario que está conectado a la instancia y la cadena constante nft. Este método solo puede ser llamado por el Token Admin del código de cadena. 

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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
  • tokenType: string: el único tipo de token soportado es nonfungible.
Devuelve:
  • Cuando se realiza correctamente, un objeto JSON de la cuenta que se ha creado.
Ejemplo de valor de retorno:
{
    "AssetType": "oaccount",
    "BapAccountVersion" : 0,
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
BalanceOf
Este método devuelve el número total de transacciones de financiación de valores que tiene un usuario especificado. Este método solo puede ser llamado por un Token Admin del código de cadenas o por el propietario de la cuenta. 
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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Objeto JSON del recuento de NFT actual.
Ejemplo de valor de retorno:
{"totalNfts": 0}
GetAllAccounts
Este método devuelve una lista de todas las cuentas. Este método solo puede ser llamado por un Token Admin del código de cadena. Este método utiliza consultas enriquecidas de SQL de base de datos de Berkeley y solo se puede llamar cuando se conecta a la red remota de 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:
  • ninguno
Devuelve:
  • Si se realiza correctamente, una matriz JSON de todas las cuentas.
Ejemplo 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 devuelve los detalles de cuenta de un usuario especificado. Este método solo puede ser llamado por un Token Admin del código de cadena o el Account Owner de la cuenta. 
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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Si se realiza correctamente, un objeto de cuenta JSON que incluye las siguientes propiedades:
  • AccountId: ID de la cuenta de usuario.
  • UserId: nombre de usuario o identificador de correo electrónico del usuario.
  • OrgId: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • TokenType: tipo de token que contiene la cuenta.
  • NoOfNfts: número total de operaciones de financiación de valores de la cuenta.
  • BapAccountVersion: parámetro de objeto de cuenta para uso interno.
  • Status: estado actual de la cuenta de usuario.
Ejemplo 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 devuelve los detalles de usuario de una cuenta especificada. Cualquier usuario puede llamar a este método.
func (t *Controller) GetUserByAccountId(accountId string) (interface{}, error) {
      return t.Ctx.ERC721Account.GetUserByAccountById(accountId)
}
Parámetros:
  • accountId: string: ID de la cuenta.
Devuelve:
  • Cuando se realiza correctamente, un objeto JSON de los detalles del usuario (OrgId y UserId).
Ejemplo de valor de retorno:
{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
GetAccountHistory
Este método devuelve el historial de cuentas de un usuario especificado. Este método solo puede ser llamado por un Token Admin del código de cadenas o por el propietario de la cuenta. 
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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • En caso de éxito, una lista de objetos.
Ejemplo 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 la gestión de roles

AddRole
Este método agrega un rol a un usuario especificado. Este método solo puede ser llamado por un Token Admin del código de cadena. 
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: nombre del rol que se va a agregar al usuario especificado. Los comportamientos mintable y burnable corresponden a las propiedades minter_role_name y burner_role_name del archivo de especificación.
  • orgId: string: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Cuando se realiza correctamente, se muestra un mensaje con los detalles del usuario.
Ejemplo de valor de retorno:
{"msg": "Successfully added role minter to oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin)"}
RemoveRole
Este método elimina un rol de un usuario especificado. Este método solo puede ser llamado por un Token Admin del código de cadena. 
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: nombre del rol que se va a eliminar del usuario especificado. Los comportamientos mintable y burnable corresponden a las propiedades minter_role_name y burner_role_name del archivo de especificación.
  • orgId: string: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Cuando se realiza correctamente, se muestra un mensaje con los detalles del usuario.
Ejemplo de valor de retorno:
{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}
GetAccountsByRole
Este método devuelve una lista de todos los ID de cuenta para un rol especificado. Este método solo puede ser llamado por un Token Admin del código de cadena. 
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: nombre del rol que se va a buscar.
Devuelve:
  • Si se realiza correctamente, una matriz JSON de ID de cuenta.
Ejemplo de valor de retorno:
{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
Este método devuelve una lista de todos los usuarios para un rol especificado. Este método solo puede ser llamado por un Token Admin del código de cadena. 
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: nombre del rol que se va a buscar.
Devuelve:
  • Cuando se realiza correctamente, una matriz JSON de los objetos de usuario (orgId y userId).
Ejemplo de valor de retorno:
{
    "Users": [
        {
            "OrgId": "Org1MSP",
            "UserId": "admin"
        }
    ]
}
IsInRole
Este método devuelve un valor booleano para indicar si un usuario tiene un rol especificado. Este método solo puede ser llamado por un Token Admin del código de cadena o el Account Owner de la cuenta. 
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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
  • userRole: string: nombre del rol que se va a buscar.
Devuelve:
  • Si se realiza correctamente, una cadena JSON del resultado booleano.
Ejemplo de valor de retorno:
{"result":"true"}

Métodos para la gestión del historial de transacciones

GetAccountTransactionHistory
Este método devuelve el historial de transacciones de la cuenta para un usuario especificado. El Token Admin del código de cadenas o el propietario de la cuenta pueden llamar a este método. 
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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • En caso de éxito, una lista de objetos.
Ejemplo 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
Este método devuelve el historial de transacciones de cuentas para un usuario especificado, filtrado por PageSize, Bookmark, StartTime y EndTime. Este método solo se puede llamar cuando está conectado a la red remota de Oracle Blockchain Platform. Este método solo puede ser llamado por un Token Admin del código de cadenas o por el propietario de la cuenta. 
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: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
  • filters: string: parámetro opcional. Si está vacío, se devuelven todos los registros. La propiedad PageSize determina el número de registros que se devolverán. Si PageSize es 0, el tamaño de página por defecto es 20. La propiedad Bookmark determina el índice inicial de los registros que se van a devolver. Para obtener más información, consulte la documentación de Hyperledger Fabric. Las propiedades StartTime y EndTime se deben especificar en formato RFC-3339.
Devuelve:
  • En caso de éxito, una lista de objetos.
Ejemplo 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 devuelve el historial de transacciones para un ID de transacción especificado. Este método solo puede ser llamado por un Token Admin del código de cadenas o por el propietario de la cuenta. 
func (t *Controller) GetTransactionById(transactionId string) (interface{}, error) {
      return t.Ctx.ERC721Transaction.GetTransactionById(transactionId)
}
Parámetros:
  • transactionId: string: ID del activo de transacción.
Devuelve:
  • En caso de éxito, una lista de objetos.
Ejemplo 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 suprime las transacciones anteriores a un registro de hora especificado en la base de datos de estado. Este método solo puede ser llamado por el Token Admin del código de cadena. 
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: registro de hora. Se suprimirán todas las transacciones anteriores al registro de hora.
Devuelve:
  • En caso de éxito, una lista de objetos.
Ejemplo de valor de retorno:
{
    "Transactions": [
        "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7"
    ],
    "msg": "Successfuly deleted transaction older than date:2022-04-06T08:17:53Z"
}

Métodos para la gestión del comportamiento de los tokens: comportamiento de Mintable

Create<Token Name>Token
Este método crea (mintiza) una NFT. El activo y las propiedades asociadas se guardan en la base de datos de estado. El emisor de esta transacción debe tener una cuenta de token. El emisor de esta transacción se convierte en el propietario de la NFT. Si el archivo de especificación de token incluye la sección roles para behaviors y la propiedad minter_role_name para roles, el emisor de la llamada de la transacción debe tener el rol minter. De lo contrario, cualquier emisor de llamada puede acuñar NFT. 
func (t *Controller) Create<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
      return t.Ctx.ERC721Token.CreateToken(&tokenAsset)
}
Parámetros:
  • tokenAsset: <Token Class>: activo de token que se va a importar. Para obtener más información sobre las propiedades del activo de token, consulte el archivo de especificación de entrada.
Devuelve:
  • Cuando se realiza correctamente, un objeto de activo de token JSON que incluye las siguientes propiedades:
  • Behavior: descripción de todos los comportamientos de token.
  • CreatedBy: ID de cuenta del usuario que ha llamado a la transacción para acuñar el token.
  • CreationDate: registro de hora de la transacción.
  • IsBurned: valor booleano que indica si se ha quemado la NFT identificada por tokenId.
  • Mintable: descripción de las propiedades del comportamiento de mintable. La propiedad max_mint_quantity especifica el número máximo de NFT de esta clase de token que se puede crear.
  • Owner: ID de cuenta del propietario actual del token. Durante el proceso de acuñación, el emisor de la llamada de este método se convierte en el propietario del token.
  • Symbol: símbolo del token.
  • TokenDesc: descripción del token.
  • TokenMetadata: información de JSON que describe el token.
  • TokenName: nombre del token.
  • TokenStandard: estándar del token.
  • TokenType: tipo de token que tiene esta cuenta.
  • TokenUnit: unidad del token.
  • TokenUri: URI del token.
Ejemplo 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 actualiza las propiedades del token. Este método solo puede ser llamado por el usuario que es el propietario o creador del token. Después de crear un activo de token, solo el propietario del token puede actualizar las propiedades personalizadas del token. Si el usuario es propietario del token y creador de un token, también puede actualizar la propiedad TokenDesc. No se pueden actualizar los metadatos de token. Debe transferir todas las propiedades de token a este método, incluso si desea actualizar solo determinadas propiedades. 
func (t *Controller) Update<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
      return t.Ctx.ERC721Token.UpdateToken(&tokenAsset)
}
Parámetros:
  • tokenAsset: <Token Class>: activo de token que se va a actualizar. Para obtener más información sobre las propiedades del activo de token, consulte el archivo de especificación de entrada.
Devuelve:
  • Cuando se realiza correctamente, se actualiza un objeto de activo de token JSON
Ejemplo 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 la gestión del comportamiento de los tokens: comportamiento transferible

SafeTransferFrom
Este método transfiere la propiedad de la NFT especificada del emisor de la llamada a otra cuenta. Este método incluye las siguientes validaciones:
  • El token existe y no se ha quemado.
  • La cuenta del remitente y la cuenta del receptor existen y no son la misma cuenta.
  • La cuenta del remitente es propietaria del token.
  • El emisor de la llamada de la función es el remitente.
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: ID del proveedor de servicios de miembros (MSP) del remitente en la organización actual.
  • fromUserId: string: nombre de usuario o ID de correo electrónico del remitente.
  • toOrgId: string: ID del proveedor de servicios de miembros (MSP) del receptor en la organización actual.
  • toUserId: string: nombre de usuario o ID de correo electrónico del receptor.
  • tokenId: string: ID del token que se va a transferir.
  • data: string: información adicional opcional que se almacena en el registro de transacción.
Devuelve:
  • En caso de éxito, un mensaje con los detalles de la cuenta del remitente y del receptor.
Ejemplo 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 transfiere la propiedad de la NFT especificada de una cuenta de remitente a una cuenta de receptor. Es responsabilidad de la persona que llama pasar los parámetros correctos. Cualquier usuario puede llamar a este método, no solo al propietario del token. Este método incluye las siguientes validaciones:
  • El token existe y no se ha quemado.
  • La cuenta del remitente y la cuenta del receptor existen y no son la misma cuenta.
  • La cuenta del remitente es propietaria del token.
func (t *Controller) TransferFrom(fromOrgId string, fromUserId string, toOrgId string, toUserId string, tokenId string) (interface{}, error) {
      tokenAssetValue, err := t.getTokenObject(tokenId)
      if err != nil {
            return nil, err
      }
      fromAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(fromOrgId, fromUserId)
      if err != nil {
            return nil, err
      }
      toAccountId, err := t.Ctx.ERC721Account.GenerateAccountId(toOrgId, toUserId)
      if err != nil {
            return nil, err
      }
      return t.Ctx.ERC721Token.TransferFrom(fromAccountId, toAccountId, tokenAssetValue.Interface())
}
Parámetros:
  • fromOrgId: string: ID del proveedor de servicios de miembros (MSP) del remitente en la organización actual.
  • fromUserId: string: nombre de usuario o ID de correo electrónico del remitente.
  • toOrgId: string: ID del proveedor de servicios de miembros (MSP) del receptor en la organización actual.
  • toUserId: string: nombre de usuario o ID de correo electrónico del receptor.
  • tokenId: string: ID del token que se va a transferir.
Devuelve:
  • En caso de éxito, un mensaje con los detalles de la cuenta del remitente y del receptor.
Ejemplo 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 la gestión del comportamiento de los tokens: comportamiento que se puede quemar

Burn
Este método desactiva o quema la NFT especificada de la cuenta del emisor de la llamada. El emisor de la llamada de este método debe tener una cuenta. Un token no se puede quemar a menos que el archivo de especificación de token incluya el comportamiento burnable. Si no se especifica ninguna propiedad burner_role_name en la sección roles del archivo de especificación, el propietario del token puede grabar el token. Si se especifica una propiedad burner_role_name en la sección roles, el usuario asignado al rol de quemador que también es el minter (creador) del token puede grabar el 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: ID del token que se va a quemar.
Devuelve:
  • Si se realiza correctamente, aparecerá un mensaje con los detalles de la cuenta.
Ejemplo de valor de retorno:
{"msg": "Successfully burned NFT token: 'monalisa' from Account-Id: oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (Org-Id: Org1MSP, User-Id: admin"}
BurnNFT
Este método desactiva o graba la NFT especificada de la cuenta del emisor de la llamada y devuelve un objeto de token y un historial de tokens. El emisor de la llamada de este método debe tener una cuenta. Un token no se puede quemar a menos que el archivo de especificación de token incluya el comportamiento burnable. Si no se especifica ninguna propiedad burner_role_name en la sección roles del archivo de especificación, el propietario del token puede grabar el token. Si se especifica una propiedad burner_role_name en la sección roles, el usuario asignado al rol de quemador que también es el minter (creador) o el propietario del token puede grabar el 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: ID del token que se va a quemar.
Devuelve:
  • Cuando se realiza correctamente, un objeto de token que incluye información del historial de tokens.
Ejemplo 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

Puede utilizar los métodos de SDK de token para escribir métodos personalizados para la aplicación de negocio.

En el siguiente ejemplo se muestra cómo utilizar métodos de SDK de token en métodos personalizados. Cuando se llama al método Sell, publica un token para la venta por un precio 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 de SDK de NFT

Métodos para la gestión del control de acceso

El SDK de NFT proporciona una función de control de acceso. Algunos métodos solo pueden ser llamados por un Token Admin o Account Owner del token. Puede utilizar esta función para asegurarse de que las operaciones solo las realizan los usuarios deseados. Cualquier acceso no autorizado genera un error. Para utilizar la función de control de acceso, importe la clase Authorization del módulo ../lib/auth.
import { ERC721Authorization } from '../lib/erc721-auth';
CheckAuthorization
Utilice este método para agregar una comprobación de control de acceso a una operación. La mayoría de los métodos generados automáticamente incluyen el control de acceso. Algunos métodos de token solo pueden ser ejecutados por ERC721Admin o Account Owner del token o por MultipleAccountOwner para usuarios con varias cuentas. El método CheckAuthorization forma parte del paquete erc721Auth, al que se accede a través de la estructura Ctx (receptor). La asignación de control de acceso se describe en el archivo oChainUtil.go, como se muestra en el siguiente texto. Puede modificar el control de acceso editando el archivo oChainUtil.go. Para utilizar su propio control de acceso o para desactivar el control de acceso, elimine el código de control de acceso de los métodos de controlador generados automáticamente y los 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: valor de asignación entre los receptores y los métodos, como se describe en el archivo oChainUtil.go.
  • ...args: argumento de variable donde args[0] toma la constante 'TOKEN' y args[1] toma el parámetro accountId para agregar una comprobación de control de acceso para un AccountOwner. Para agregar una comprobación de control de acceso para MultipleAccountOwner, args[1] toma el parámetro orgId y args[2] toma el parámetro userId. Para agregar una comprobación de control de acceso para TokenOwner, args[1] toma el parámetro tokenId.
Devuelve:
  • Una respuesta booleana y, si es necesario, un error.
Ejemplos:
t.Ctx.ERC721Auth.CheckAuthorization(<parameters>)

acceso Admin 

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

Acceso AccountOwner 

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

Acceso MultipleAccountOwner 

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

Acceso TokenOwner 

t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.Get", "TOKEN", tokenId)
IsUserTokenAdmin
Este método devuelve una asignación con el valor booleano true si el emisor de llamada de la función es Token Admin. De lo contrario, el método devuelve false. 
Ctx.ERC721Auth.IsUserTokenAdmin(orgId string, userId string)  (interface{}, error)
Parámetros:
  • orgId: ID del proveedor de servicios de miembros (MSP) del usuario en la organización de red actual.
  • userId: nombre de usuario o identificador de correo electrónico del usuario.
Devuelve:
  • Una respuesta booleana.
Por ejemplo:

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

{"result":true}
AddAdmin
Este método agrega un usuario como Token Admin del código de cadena de token. 
Ctx.ERC721Admin.AddAdmin(orgId string, userId string) (interface{}, error)
Parámetros:
  • orgId: string: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Cuando se realiza correctamente, un mensaje que muestra los detalles del usuario agregado como Token Admin del código de cadena de token. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

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

{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveAdmin
Este método elimina un usuario como Token Admin del código de cadena de token. 
Ctx.ERC721Admin.RemoveAdmin(orgId string, userId string) (interface{}, error)
Parámetros:
  • orgId: string: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • En caso de éxito, un mensaje que muestra los detalles del usuario eliminado como Token Admin del código de cadena de token. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

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

{"msg":"Successfuly removed Admin (OrgId Org1MSP UserId user1)"}
GetAllAdmins
Este método devuelve una lista de todos los usuarios Token Admin. 
Ctx.ERC721Admin.GetAllAdmins() (Admin[], error)
Parámetros:
  • ninguno
Devuelve:
  • Si se realiza correctamente, una lista de todos los usuarios de Token Admin. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Admin.GetAllAdmins()

{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}
GetAllAdminUsers
Este método devuelve una lista de todos los usuarios Token Admin. 
Ctx.ERC721Admin.GetAllAdminUsers() (interface{}, error)
Parámetros:
  • ninguno
Devuelve:
  • Si se realiza correctamente, una lista de todos los usuarios Token Admin en formato map[string]interface{}. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Admin.GetAllAdminUsers()

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

Métodos para la gestión de configuración de token

CreateToken
Este método crea un token y guarda sus propiedades en la base de datos de estado. Sólo los usuarios con el rol minter pueden llamar a este método.
Ctx.ERC721Token.CreateToken(args ...interface{})
Parámetros:
  • Argumento de variable donde args[0] contiene una referencia al token struct del tipo necesario.
Devuelve:
  • Si se realiza correctamente, interface[] con detalles de token. Por error, un objeto no nulo con un mensaje de error.
Por ejemplo:

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
Este método devuelve el URI de token para un token especificado.
Ctx.ERC721Token.GetTokenURI(tokenId string) (interface{}, error)
Parámetros:
  • tokenId: string: ID del token.
Devuelve:
  • Si se realiza correctamente, devuelve una asignación del nuevo URI de token en el tipo de dato de cadena. Por error, un objeto no nulo con un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Token.GetTokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
TokenUri
Este método devuelve el URI de token para un token especificado.
Ctx.ERC721Token.TokenURI(tokenId string) (interface{}, error)
Parámetros:
  • tokenId: string: ID del token.
Devuelve:
  • Si se realiza correctamente, devuelve una asignación del nuevo URI de token en el tipo de dato de cadena. Por error, un objeto no nulo con un mensaje de error.
Ejemplo de valor de retorno:

t.Ctx.ERC721Token.TokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
Symbol
Este método devuelve el símbolo de la clase de token.
Ctx.ERC721Token.Symbol() (interface{}, error)
Parámetros:
  • ninguno
Devuelve:
  • En caso de éxito, una asignación del símbolo en el tipo de dato de cadena. Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}
Name
Este método devuelve el nombre de la clase de token.
Ctx.ERC721Token.Name() (interface{}, error)
Parámetros:
  • ninguno
Devuelve:
  • Si se realiza correctamente, una asignación del nombre del token en el tipo de dato de cadena. Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Token.Name()

{"TokenName": "paintingnft"}
OwnerOf
Este método devuelve el ID de cuenta del propietario de un token especificado.
Ctx.ERC721Token.OwnerOf(tokenId string) (interface{}, error)
Parámetros:
  • tokenId: string: ID del token.
Devuelve:
  • Si se realiza correctamente, una asignación del ID de cuenta del propietario en el tipo de datos de cadena. Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Token.OwnerOf(tokenId)

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
TotalSupply
Este método devuelve el número total de NFT acuñadas.
Ctx.ERC721Token.TotalSupply() (map[string]interface{}, error)
Parámetros:
  • tokenId: string: ID del token.
Devuelve:
  • En caso de éxito, una asignación del suministro total de tokens en el tipo de dato de número. En caso de error, un rechazo con un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}
GetAllTokens
Este método devuelve todos los activos de token que se guardan en la base de datos de estado. Este método utiliza consultas enriquecidas de SQL de base de datos de Berkeley y solo se puede llamar cuando se conecta a la red remota de Oracle Blockchain Platform.
Ctx.ERC721Token.GetAllTokens()  (interface{}, error)
Parámetros:
  • ninguno
Devuelve:
  • En caso de éxito, una asignación de todos los activos de token. Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

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 devuelve todos los tokens que son propiedad de un ID de cuenta especificado. Este método utiliza consultas enriquecidas de SQL de base de datos de Berkeley y solo se puede llamar cuando se conecta a la red remota de Oracle Blockchain Platform.
Ctx.ERC721Token.GetAllTokensByUser(accountId string) (interface{}, error)
Parámetros:
  • accountId: string: ID de la cuenta.
Devuelve:
  • Si se realiza correctamente, una asignación de activos de token para la cuenta especificada. Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

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
Este método devuelve el objeto de token especificado si está presente en la base de datos de estado.
Ctx.Get(Id string, result ...interface{}) (interface{}, error)
Parámetros:
  • tokenId: string: ID del token.
  • result: argumento de variable, donde el primer argumento result[0] es una referencia a un objeto Token vacío del tipo correcto, que contendrá los datos de token después de una llamada correcta del método.
Devuelve:
  • Si se realiza correctamente, una asignación con los datos del activo de token. Además, si se transfiere result[0], los datos se asignan a result[0]. Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

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 actualiza las propiedades del token. Este método solo puede ser llamado por el propietario o creador del token. Después de crear un activo de token, solo el propietario del token puede actualizar las propiedades personalizadas del token. Si el usuario es propietario del token y creador de un token, también puede actualizar la propiedad TokenDesc. No se pueden actualizar los metadatos de token. Debe transferir todas las propiedades de token a este método, incluso si desea actualizar solo determinadas propiedades. 
Ctx.ERC721Token.UpdateToken(asset interface{}) (interface{}, error)
Parámetros:
  • Referencia a los datos de estructura de token del tipo necesario
Devuelve:
  • En caso de éxito, un mensaje de promesa con detalles de token. En caso de error, un rechazo con un mensaje de error.
Por ejemplo:

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 devuelve el historial para el token especificado.
Ctx.ERC721Token.History(tokenId: string)  (interface{}, error)
Parámetros:
  • tokenId: string: ID del token.
Devuelve:
  • En cuanto al éxito, una serie de mapas. En caso de error, un rechazo con un mensaje de error.
Por ejemplo:

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
Este método devuelve un nuevo objeto TrxContext. La estructura trxcontext contiene referencias a todas las bibliotecas de SDK. Acceda a los métodos sdk utilizando solo este objeto. El objeto trxcontext mantiene la exclusividad mutua de los stubs de transacción en las bibliotecas SDK cuando se ejecutan transacciones simultáneas. 
GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext
Parámetros:
  • stub: stub de transacción.
Devuelve:
  • Una estructura trxcontext.
Por ejemplo:

trxcontext.GetNewCtx(stub)

trxcontext object.

Métodos para la gestión de cuentas

GenerateAccountId
Este método devuelve un ID de cuenta, formado por la concatenación del ID de proveedor de servicios de miembros (orgId) y el nombre de usuario o ID de correo electrónico (userId) y, a continuación, la creación de un hash SHA-256. 
Ctx.ERC721Account.GenerateAccountId(orgId string, userId string) (string, error)
Parámetros:
  • orgId: string: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Si se realiza correctamente, el ID de cuenta generado. Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

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

oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507
CreateAccount
Este método crea una cuenta para un usuario especificado. Se debe crear una cuenta para cualquier usuario que tenga tokens en cualquier momento. Las cuentas realizan un seguimiento del número de NFT que tiene un usuario. Los usuarios deben tener cuentas en la red para completar las operaciones relacionadas con el token. Solo puede crear una cuenta de NFT por usuario.

Un ID de cuenta es un juego alfanumérico de caracteres, con el prefijo oaccount~ y seguido de un hash SHA-256 del ID de proveedor de servicios de miembros (org_id) del usuario en la organización de red actual, el nombre de usuario o el ID de correo electrónico (userId) del propietario de la instancia o del usuario que está conectado a la instancia y la cadena constante nft. 

Ctx.ERC721Account.CreateAccount(orgId string, userId string, tokenType string) (ERC721Account, error)
Parámetros:
  • orgId: string: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
  • tokenType: string: el único tipo de token soportado es nonfungible.
Devuelve:
  • Cuando se realiza correctamente, el nuevo objeto de cuenta. Por error, un objeto no nulo que contiene un mensaje de error
Por ejemplo:

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

{
    "AssetType": "oaccount",
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "BapAccountVersion" : 0,
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
GetAllAccounts
Este método devuelve una lista de todas las cuentas. Este método utiliza consultas enriquecidas de SQL de base de datos de Berkeley y solo se puede llamar cuando se conecta a la red remota de Oracle Blockchain Platform.
Ctx.ERC721Account.GetAllAccounts() (interface{}, error)
Parámetros:
  • ninguno
Devuelve:
  • Matriz JSON de todas las cuentas.
Por ejemplo:

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
Este método devuelve una matriz de los detalles del historial de cuentas para una cuenta especificada.
Ctx.ERC721Account.History(accountId string) (interface{}, error)
Parámetros:
  • accountId: string: ID de la cuenta.
Devuelve:
  • Una vez realizada correctamente, una matriz map[string]interface{} que contiene los detalles del historial de cuentas para la cuenta especificada. Los datos de la cuenta se muestran en la clave value del mapa. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

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 devuelve los detalles de usuario de una cuenta especificada.
Ctx.ERC721Account.GetUserByAccountId(accountId string) (interface{}, error)
Parámetros:
  • accountId: string: ID de la cuenta.
Devuelve:
  • Cuando se realiza correctamente, un objeto JSON que incluye detalles de usuario en las siguientes propiedades:
    • OrgId: ID del proveedor de servicios de miembros (MSP) del usuario en la organización de red actual.
    • UserId: nombre de usuario o identificador de correo electrónico del usuario.
  • Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
GetAccountWithStatusByUser
Este método devuelve los detalles de la cuenta de un usuario especificado, incluido el estado de la cuenta. Este método solo puede ser llamado por un Token Admin del código de cadena o el Account Owner de la cuenta. 
Ctx.ERC721Account.GetAccountWithStatusByUser(orgId, userId) (interface{}, error)
Parámetros:
  • orgId: string: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Si se realiza correctamente, un objeto de cuenta JSON que incluye las siguientes propiedades:
  • AccountId: ID de la cuenta de usuario.
  • UserId: nombre de usuario o identificador de correo electrónico del usuario.
  • OrgId: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • TokenType: tipo de token que contiene la cuenta.
  • NoOfNfts: número total de operaciones de financiación de valores de la cuenta.
  • BapAccountVersion: parámetro de objeto de cuenta para uso interno.
  • Status: estado actual de la cuenta de usuario.
  • Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:
{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}
GetAccountByUser
Este método devuelve los detalles de cuenta de un usuario especificado. Este método solo puede ser llamado por un Token Admin del código de cadena o el Account Owner de la cuenta. 
Ctx.ERC721Account.GetAccountByUser(orgId, userId) (ERC721Account, error)
Parámetros:
  • orgId: string: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • userId: string: nombre de usuario o ID de correo electrónico del usuario.
Devuelve:
  • Si se realiza correctamente, un objeto de cuenta JSON que incluye las siguientes propiedades:
  • AccountId: ID de la cuenta de usuario.
  • UserId: nombre de usuario o identificador de correo electrónico del usuario.
  • OrgId: ID del proveedor de servicios de miembros (MSP) del usuario en la organización actual.
  • TokenType: tipo de token que contiene la cuenta.
  • NoOfNfts: número total de operaciones de financiación de valores de la cuenta.
  • Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:
{
    "AssetType": "oaccount",
    "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "BapAccountVersion" : 0,
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
BalanceOf
Este método devuelve el número total de transacciones de financiación de valores que tiene el usuario especificado.
Ctx.ERC721Account.BalanceOf(accountId string) (interface{}, error)
Parámetros:
  • accountId: string: ID de cuenta del usuario.
Devuelve:
  • En caso de éxito, una interfaz con un mensaje y el número total de NFT. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Account.BalanceOf(accountId)

{"TotalNfts": 0}

Métodos para la gestión de roles

AddRoleMember
Este método agrega un rol a un usuario especificado.
Ctx.ERC721Token.AddRoleMember(role string, accountId string) (interface{}, error)
Parámetros:
  • role: string: nombre del rol que se va a agregar al usuario especificado. Los comportamientos mintable y burnable corresponden a las propiedades minter_role_name y burner_role_name del archivo de especificación.
  • accountId: number: ID de la cuenta en la que se va a operar.
Devuelve:
  • En caso de ejecución correcta, una asignación con un mensaje de ejecución correcta. Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

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

{"msg": "Successfully added role minter to oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin)"}
RemoveRoleMember
Este método elimina un rol de un usuario y token especificados. Un ID de cuenta se forma mediante la creación de un hash SHA-256 del ID de proveedor de servicios de miembros concatenado (orgId) y el nombre de usuario o ID de correo electrónico (userId). 
Ctx.Token.RemoveRoleMember(role string, accountId string) (interface{}, error)
Parámetros:
  • role: string: nombre del rol que se va a eliminar del usuario especificado. Los comportamientos mintable y burnable corresponden a las propiedades minter_role_name y burner_role_name del archivo de especificación.
  • accountId: number: ID de la cuenta en la que se va a operar.
Devuelve:
  • En caso de ejecución correcta, una asignación con un mensaje de ejecución correcta. Por error, un objeto no nulo que contiene un mensaje de error.
Por ejemplo:

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

{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}
IsInRole
Este método devuelve un valor booleano para indicar si un usuario y un token tienen un rol especificado. Un ID de cuenta se forma mediante la creación de un hash SHA-256 del ID de proveedor de servicios de miembros concatenado (orgId) y el nombre de usuario o ID de correo electrónico (userId). 
Ctx.ERC721Token.IsInRole(role string, accountId string) (bool, error)
Parámetros:
  • role: string: nombre del rol que se va a comprobar para el usuario especificado. Los comportamientos mintable y burnable corresponden a las propiedades minter_role_name y burner_role_name del archivo de especificación.
  • accountId: number: ID de la cuenta en la que se va a operar.
Devuelve:
  • Cuando se realiza correctamente, un valor booleano que es true si el rol está presente para el ID de cuenta especificado; de lo contrario, false. Por error, un objeto no nulo que contiene un mensaje de error
Por ejemplo:

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

{"result": false}
GetAccountsByRole
Este método devuelve una lista de todos los ID de cuenta para un rol especificado.
Ctx.ERC721Role.GetAccountsByRole(roleName string) (interface{}, error)
Parámetros:
  • roleName: string: nombre del rol que se va a buscar.
Devuelve:
  • Si se realiza correctamente, una matriz JSON de ID de cuenta. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Role.GetAccountsByRole(userRole)

{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
Este método devuelve una lista de todos los usuarios para un rol especificado.
Ctx.ERC721Role.GetUsersByRole(roleName string) (interface{}, error)
Parámetros:
  • roleName: string: nombre del rol que se va a buscar.
Devuelve:
  • Cuando se realiza correctamente, una matriz JSON de objetos de usuario. Cada objeto contiene el ID de usuario y el ID de organización. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Role.GetUsersByRole(userRole)

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

Métodos para la gestión del historial de transacciones

GetAccountTransactionHistory
Este método devuelve una matriz de los detalles del historial de transacciones para una cuenta especificada.
Ctx.ERC721Account.GetAccountTransactionHistory(accountId string) (interface{}, error)
Parámetros:
  • accountId: string: ID de la cuenta.
Devuelve:
  • Si se realiza correctamente, una matriz de objetos de transacción de cuenta en formato JSON:
    • TransactionId: ID de la transacción.
    • TransactedAccount: cuenta con la que se ha realizado la transacción.
    • TransactionType: tipo de transacción.
    • Timestamp: hora de la transacción.
    • Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

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
Este método devuelve el historial de transacciones de cuentas para un usuario especificado, filtrado por PageSize, Bookmark, startTime y endTime. Este método solo se puede llamar cuando está conectado a la red remota de Oracle Blockchain Platform. 
Ctx.ERC721Account.GetAccountTransactionHistoryWithFilters(accountId string, filters ...erc721Account.AccountHistoryFilters)
Parámetros:
  • accountId: string: ID de la cuenta.
  • filters: string: parámetro opcional. Si está vacío, se devuelven todos los registros. La propiedad PageSize determina el número de registros que se devolverán. Si PageSize es 0, el tamaño de página por defecto es 20. La propiedad Bookmark determina el índice inicial de los registros que se van a devolver. Para obtener más información, consulte la documentación de Hyperledger Fabric. Las propiedades StartTime y EndTime se deben especificar en formato RFC-3339.
Devuelve:
  • Si se realiza correctamente, una matriz de objetos de transacción de cuenta en formato JSON:
    • TransactionId: ID de la transacción.
    • TransactedAccount: cuenta con la que se ha realizado la transacción.
    • TransactionType: tipo de transacción.
    • Timestamp: hora de la transacción.
    • Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

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
Este método devuelve el historial de un activo Transaction. 
Ctx.ERC721Transaction.GetTransactionById(trxId string) (interface{}, error)
Parámetros:
  • trxId: string: ID del activo de transacción.
Devuelve:
  • En caso de éxito, una matriz de asignaciones de activos de transacción. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

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 suprime las transacciones anteriores a una fecha especificada de la base de datos de estado.
func (t *Controller) DeleteHistoricalTransactions(referenceTime string) (interface{}, error)
Parámetros:
  • referenceTime: string: se suprimirán las transacciones anteriores a la hora especificada.
Devuelve:
  • En caso de éxito, una matriz de los ID de transacción suprimidos y un mensaje de éxito. Por error, un objeto de error no nulo que contiene un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)

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

Gestión del comportamiento de los tokens: comportamiento de Mintable

GetMaxMintQuantity
Este método devuelve la cantidad máxima mínima de un token. Si el comportamiento max_mint_quantity no está configurado en el archivo de especificación, el valor por defecto es 0 y se puede minar un número infinito de tokens. 
Ctx.ERC721Token.GetMaxMintQuantity(id string) (float64, error)
Parámetros:
  • id: ID del token en el que se va a operar.
Devuelve:
  • Si se realiza correctamente, la cantidad máxima mínima del token, en el tipo de dato numérico. Por error, un objeto no nulo con un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Token.GetMaxMintQuantity(tokenId);

20000
GetTotalMintedTokens
Este método devuelve el número neto total de tokens disponibles en el sistema para el token especificado. El número neto de tokens disponibles es el número total de tokens minados menos el número de tokens quemados.
Ctx.ERC721Token.GetTotalMintedTokens() (map[string]interface{}, error)
Parámetros:
  • ninguno
Devuelve:
  • En caso de éxito, una asignación del total de tokens acuñados, en el tipo de dato de número y un mensaje de éxito. Por error, un objeto no nulo con un mensaje de error.
Por ejemplo:

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

Gestión del comportamiento de los tokens: comportamiento transferible

SafeTransferFrom
Este método transfiere la propiedad de la NFT especificada del emisor de la llamada a otra cuenta. Este método incluye las siguientes validaciones:
  • El token existe y no se ha quemado.
  • La cuenta del remitente y la cuenta del receptor existen y no son la misma cuenta.
  • La cuenta del remitente es propietaria del token.
  • El emisor de la llamada de la función es el remitente.
Ctx.ERC721Token.SafeTransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}, data ...string) (interface{}, error)
Parámetros:
  • fromAccountId: string: ID de cuenta del remitente en la organización actual.
  • toAccountId: string: ID de cuenta del receptor en la organización actual.
  • tokenAsset: referencia al activo de token en el que se va a operar.
  • data: string: información adicional opcional que se almacena en la transacción.
Devuelve:
  • En caso de éxito, una promesa con un mensaje de éxito que incluye los detalles de la cuenta. Por error, un objeto no nulo con un mensaje de error.
Por ejemplo:

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 transfiere la propiedad de la NFT especificada de una cuenta de remitente a una cuenta de receptor. Es responsabilidad de la persona que llama pasar los parámetros correctos. Cualquier usuario puede llamar a este método, no solo al propietario del token. Este método incluye las siguientes validaciones:
  • El token existe y no se ha quemado.
  • La cuenta del remitente y la cuenta del receptor existen y no son la misma cuenta.
  • La cuenta del remitente es propietaria del token.
Ctx.ERC721Token.TransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}) (interface{}, error)
Parámetros:
  • fromAccountId: string: ID de cuenta del remitente en la organización actual.
  • toAccountId: string: ID de cuenta del receptor en la organización actual.
  • tokenAsset: referencia al activo de token en el que se va a operar.
Devuelve:
  • En caso de éxito, una promesa con un mensaje de éxito que incluye los detalles de la cuenta. Los ID de cuenta tienen el prefijo oaccount~. Por error, un objeto no nulo con un mensaje de error.
\Por ejemplo:

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

Gestión del comportamiento de los tokens: comportamiento que se puede quemar

Burn
Este método desactiva o quema la NFT especificada de la cuenta del emisor de la llamada. El emisor de la llamada de este método debe tener una cuenta. Un token no se puede quemar a menos que el archivo de especificación de token incluya el comportamiento burnable. Si no se especifica ninguna propiedad burner_role_name en la sección roles del archivo de especificación, el propietario del token puede grabar el token. Si se especifica una propiedad burner_role_name en la sección roles, el usuario asignado al rol de quemador que también es el minter (creador) del token puede grabar el token. El método burn forma parte del paquete ERC721Token, al que se accede a través del receptor de la estructura Ctx. 
Ctx.Token.Burn(tokenAsset interface{}) (interface{}, error)
Parámetros:
  • tokenAsset: referencia al activo de token en el que se va a operar.
Devuelve:
  • En caso de éxito, una promesa con un mensaje de éxito que incluye los detalles de la cuenta. Por error, un objeto no nulo con un mensaje de error.
Por ejemplo:

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

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