ERC-721 的脚手架 Go NFT 项目

Blockchain App Builder 从 NFT 规范文件中获取输入并生成一个功能齐全的脚手架链代码项目。

该项目自动生成 NFT 生命周期类和函数,包括 CRUD 和非 CRUD 方法。自动支持参数验证、编集/编集和透明持久性功能。

有关脚手架项目以及与 NFT 不直接相关的方法的信息,请参见 Scaffolded Go Chaincode Project

型号

透明持久性功能或简化的 ORM 在 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"`
}

主管

只有一个主控制器。

type Controller struct {
    Ctx trxcontext.TrxContext
}

您可以创建任意数量的类、函数或文件,但只能调用在主控制器类中定义的方法。其他方法处于隐藏状态。

您可以使用令牌 SDK 方法为业务应用程序编写定制方法。

自动生成的 NFT 方法

Blockchain App Builder 自动生成支持 NFT 和 NFT 生命周期的方法。您可以使用这些方法来初始化 NFT、管理角色和账户,以及完成其他 NFT 生命周期任务,而无需任何额外编码。

Blockchain App Builder 自动生成支持 NFT 和 NFT 生命周期的方法。您可以使用这些方法来初始化 NFT、管理角色和账户,以及完成其他 NFT 生命周期任务,而无需任何额外编码。控制器方法必须是 public 才能调用。公共方法名称以大写字符开头。以小写字符开头的方法名称是专用的。

访问控制管理方法

AddTokenAdmin
此方法将用户添加为链代码的 Token Admin。此方法只能由链代码的 Token Admin 调用。
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)
}
参数:
  • orgId string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId string —用户的用户名或电子邮件 ID。
返回:
  • 成功时,将出现一条消息,其中包含作为链代码的 Token Admin 添加的用户的详细信息。
返回值示例:
{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveTokenAdmin
此方法将用户删除为链代码的 Token Admin。此方法只能由链代码的 Token Admin 调用。不能使用此方法将自己删除为 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)
}
参数:
  • orgId string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId string —用户的用户名或电子邮件 ID。
返回:
  • 成功时,将出现一条消息,其中包含作为链代码的 Token Admin 删除的用户的详细信息。
返回值示例:
{"msg":"Successfully removed Admin (OrgId Org1MSP UserId user1)"}
IsTokenAdmin
如果函数的调用方为 Token Admin,则此方法返回布尔值 true,否则返回 falseToken Admin 可以对区块链网络中的任何其他用户调用此函数。其他用户只能在自己的账户中调用此方法。
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)
}
参数:
  • orgId string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId string —用户的用户名或电子邮件 ID。
返回:
  • 如果调用方为 Token Admin,则方法返回 true,否则返回 false
返回值示例:
{"result":true}
GetAllTokenAdmins
此方法返回链代码 Token Admin 的所有用户的列表。此方法只能由链代码的 Token Admin 调用。
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()
}
参数:
返回:
  • 成功后,将列出包含 OrgIdUserId 对象的管理员的 JSON 列表。
返回值示例:
{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}

标记配置管理方法

Init
实例化链代码时会调用此方法。每个 Token Admin 都由 adminList 参数中的 UserIdOrgId 信息标识。UserId 是实例所有者或登录到实例的用户的用户名或电子邮件 ID。OrgId 是当前网络组织中用户的成员服务提供者 (member service provider,MSP) ID。首次部署链代码时,adminList 参数是必需的。如果要升级链代码,请传递空列表 ([])。升级期间将忽略 adminList 参数中的任何其他信息。
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
}
参数:
  • adminList array- 由 {OrgId, UserId} 信息组成的数组,用于指定令牌管理员列表。adminList 数组是必需参数。
GetAllTokens
此方法返回保存在状态数据库中的所有标记资产。此方法只能由链代码的 Token Admin 调用。此方法使用 Berkeley DB SQL 丰富的查询,并且只能在连接到远程 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()
}
参数:
返回:
  • JSON 格式的所有标记资产的列表。
返回值示例:
[
    {
        "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
此方法返回指定用户拥有的所有令牌资产。此方法使用 Berkeley DB SQL 丰富的查询,并且只能在连接到远程 Oracle Blockchain Platform 网络时调用。此方法只能由链代码的 Token Admin 或账户所有者调用。
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)
}
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • JSON 格式的标记资产列表。
返回值示例:
[
    {
        "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
如果标记存在于状态数据库中,则此方法将返回标记对象。此方法只能由链代码的 Token Admin 或令牌所有者调用。
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
}
参数:
  • tokenId: string- 要获取的令牌的 ID。
返回:
  • JSON 格式的标记资产。
返回值示例:
{
    "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
此方法返回指定令牌 ID 的历史记录。只能在连接到远程 Oracle Blockchain Platform 网络时调用此方法。任何人都可以调用此方法。
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)
}
参数:
  • tokenId: string- 令牌的 ID。
返回值示例:
[
    {
        "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
这是一种实用程序方法,返回指定令牌 ID 的令牌实例。许多自动生成的方法都使用此方法来提取令牌对象。您可以根据需要从定制方法调用此方法。创建标记化资产或类时,使用相应的 Token 类更新切换用例以返回正确的标记对象。当在规范文件中创建标记化资产时,区块链应用程序构建器中的 ochain sync 命令会自动创建切换用例。因为此方法为 private,所以它不可直接调用,并且只能从其他方法调用。
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)
      }
}
参数:
  • tokenId: string- 令牌的 ID。
OwnerOf
此方法返回指定令牌 ID 所有者的帐户 ID。任何人都可以调用此方法。
func (t *Controller) Ownerof(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.OwnerOf(tokenId)
}
参数:
  • tokenId: string- 令牌的 ID。
返回:
  • 所有者账户 ID 的 JSON 对象。
返回值示例:
{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
Name
此方法返回令牌类的名称。任何人都可以调用此方法。
func (t *Controller) Name() (interface{}, error) {
      return t.Ctx.ERC721Token.Name()
}
参数:
返回:
  • 标记名称的 JSON 对象。
返回值示例:
{"TokenName": "paintingnft"}
Symbol
此方法返回令牌类的符号。任何人都可以调用此方法。
func (t *Controller) Symbol() (interface{}, error) {
      return t.Ctx.ERC721Token.Symbol()
}
参数:
返回:
  • 标记符号的 JSON 对象。
返回值示例:
{"Symbol": "PNT"}
TokenURI
此方法返回指定令牌的 URI。任何人都可以调用此方法。
func (t *Controller) TokenURI(tokenId string) (interface{}, error) {
      return t.Ctx.ERC721Token.TokenURI(tokenId)
}
参数:
  • tokenId: string- 令牌的 ID。
返回:
  • 成功后,标记 URI 的 JSON 对象。
返回值示例:
{"TokenURI": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
TotalSupply
此方法返回铸造标记的总数。此方法只能由链代码的 Token Admin 调用。
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()
}
参数:
返回:
  • 成功时,标记计数的 JSON 对象。
返回值示例:
{"TotalSupply": 3}
TotalNetSupply
此方法返回铸造标记的总数减去刻录的标记数。此方法只能由链代码的 Token Admin 调用。
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()
}
参数:
返回:
  • 成功时,标记计数的 JSON 对象。
返回值示例:
{"TotalNetSupply": 2}

账户管理方法

CreateAccount
此方法为指定的用户和令牌创建帐户。必须为在任何时候都具有令牌的任何用户创建账户。账户跟踪用户拥有的 NFT 数。用户必须在网络中有账户才能完成与令牌相关的操作。每个用户只能创建一个 NFT 账户。

帐户 ID 是字母数字字符集,前缀为 oaccount~,后跟当前网络组织中用户的成员服务提供商 ID (OrgId) 的 SHA-256 散列、实例所有者或登录实例的用户的用户名或电子邮件 ID (UserId) 以及常量字符串 nft。此方法只能由链代码的 Token Admin 调用。

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)
}
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
  • tokenType: string- 唯一支持的令牌类型是 nonfungible
返回:
  • 成功后,创建的账户的 JSON 对象。
返回值示例:
{
    "AssetType": "oaccount",
    "BapAccountVersion" : 0,
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
BalanceOf
此方法返回指定用户持有的 NFT 总数。此方法只能由链代码的 Token Admin 或账户所有者调用。
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)
}
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 当前 NFT 计数的 JSON 对象。
返回值示例:
{"totalNfts": 0}
GetAllAccounts
此方法返回所有帐户的列表。此方法只能由链代码的 Token Admin 调用。此方法使用 Berkeley DB SQL 丰富的查询,并且只能在连接到远程 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()
}
参数:
返回:
  • 成功后,将生成一个包含所有账户的 JSON 数组。
返回值示例:
[
    {
        "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
此方法返回指定用户的帐户详细信息。此方法只能由链代码的 Token Admin 或帐户的 Account Owner 调用。
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)
}
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功后,包含以下属性的 JSON 账户对象:
  • AccountId- 用户帐户的 ID。
  • UserId —用户的用户名或电子邮件 ID。
  • OrgId —当前组织中用户的成员服务提供商 (MSP) ID。
  • TokenType —账户持有的令牌类型。
  • NoOfNfts —账户持有的 NFT 总数。
  • BapAccountVersion- 供内部使用的帐户对象参数。
  • Status- 用户帐户的当前状态。
返回值示例:
{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}
GetUserByAccountId
此方法返回指定帐户的用户详细信息。所有用户都可以调用此方法。
func (t *Controller) GetUserByAccountId(accountId string) (interface{}, error) {
      return t.Ctx.ERC721Account.GetUserByAccountById(accountId)
}
参数:
  • accountId: string –帐户的 ID。
返回:
  • 成功后,用户详细信息的 JSON 对象(OrgIdUserId)。
返回值示例:
{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
GetAccountHistory
此方法返回指定用户的帐户历史记录。此方法只能由链代码的 Token Admin 或账户所有者调用。
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)
}
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功时,列出对象列表。
返回值示例:
[
    {
        "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"
        }
    }
]

角色管理方法

AddRole
此方法向指定用户添加角色。此方法只能由链代码的 Token Admin 调用。
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)
}
参数:
  • userRole: string- 要添加到指定用户的角色的名称。mintableburnable 行为对应于规范文件的 minter_role_nameburner_role_name 属性。
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功时,将显示一条包含用户详细信息的消息。
返回值示例:
{"msg": "Successfully added role minter to oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin)"}
RemoveRole
此方法将角色从指定用户中删除。此方法只能由链代码的 Token Admin 调用。
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)
}
参数:
  • userRole: string- 要从指定用户删除的角色的名称。mintableburnable 行为对应于规范文件的 minter_role_nameburner_role_name 属性。
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功时,将显示一条包含用户详细信息的消息。
返回值示例:
{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}
GetAccountsByRole
此方法返回指定角色的所有帐户 ID 的列表。此方法只能由链代码的 Token Admin 调用。
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)
}
参数:
  • userRole: string —要搜索的角色的名称。
返回:
  • 成功后,账户 ID 的 JSON 数组。
返回值示例:
{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
此方法返回指定角色的所有用户的列表。此方法只能由链代码的 Token Admin 调用。
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)
}
参数:
  • userRole: string —要搜索的角色的名称。
返回:
  • 成功后,用户对象(orgIduserId)的 JSON 数组。
返回值示例:
{
    "Users": [
        {
            "OrgId": "Org1MSP",
            "UserId": "admin"
        }
    ]
}
IsInRole
此方法返回布尔值以指示用户是否具有指定的角色。此方法只能由链代码的 Token Admin 或帐户的 Account Owner 调用。
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
}
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
  • userRole: string —要搜索的角色的名称。
返回:
  • 成功时,布尔结果的 JSON 字符串。
返回值示例:
{"result":"true"}

事务处理历史记录管理方法

GetAccountTransactionHistory
此方法返回指定用户的账户事务处理历史记录。此方法可由链代码的 Token Admin 或账户的所有者调用。
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
}
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功时,列出对象列表。
返回值示例:
[
     {
        "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
此方法返回指定用户的帐户事务处理历史记录,按 PageSizeBookmarkStartTimeEndTime 过滤。只能在连接到远程 Oracle Blockchain Platform 网络时调用此方法。此方法只能由链代码的 Token Admin 或账户所有者调用。
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
}
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
  • filters: string- 可选参数。如果为空,将返回所有记录。PageSize 属性确定要返回的记录数。如果 PageSize 为 0,则默认页面大小为 20。Bookmark 属性确定要返回的记录起始索引。有关更多信息,请参见 Hyperledger Fabric 文档。必须以 RFC-3339 格式指定 StartTimeEndTime 属性。
返回:
  • 成功时,列出对象列表。
返回值示例:
[
     {
        "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
此方法返回指定事务处理 ID 的事务处理历史记录。此方法只能由链代码的 Token Admin 或账户所有者调用。
func (t *Controller) GetTransactionById(transactionId string) (interface{}, error) {
      return t.Ctx.ERC721Transaction.GetTransactionById(transactionId)
}
参数:
  • transactionId: string —事务处理资产的 ID。
返回:
  • 成功时,列出对象列表。
返回值示例:
{
    "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
此方法删除状态数据库中早于指定时间戳的事务处理。此方法只能由链代码的 Token Admin 调用。
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)
}
参数:
  • timestamp: Date- 时间戳。将删除时间戳之前的所有事务处理。
返回:
  • 成功时,列出对象列表。
返回值示例:
{
    "Transactions": [
        "otransaction~750f68538451847f57948f7d5261dcb81570cd9e429f928a4cb7bfa76392ecf7"
    ],
    "msg": "Successfuly deleted transaction older than date:2022-04-06T08:17:53Z"
}

令牌行为管理方法 - 最小行为

Create<Token Name>Token
此方法创建 (mint) NFT。资产和关联的属性保存在状态数据库中。此事务处理的调用方必须具有令牌账户。此事务处理的调用方将成为 NFT 的所有者。如果令牌规范文件包括 behaviorsroles 部分和 rolesminter_role_name 属性,则事务处理的调用方必须具有 minter 角色。否则,任何调用方都可以 mint NFT。
func (t *Controller) Create<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
      return t.Ctx.ERC721Token.CreateToken(&tokenAsset)
}
参数:
  • tokenAsset: <Token Class> —要铸币的令牌资产。有关令牌资产属性的更多信息,请参见输入规范文件。
返回:
  • 成功时,包含以下属性的 JSON 标记资产对象:
  • Behavior- 所有令牌行为的描述。
  • CreatedBy —调用事务处理来铸造令牌的用户的账户 ID。
  • CreationDate —事务处理的时间戳。
  • IsBurned- 指示是否刻录了由 tokenId 标识的 NFT 的布尔值。
  • Mintable- 可减量行为属性的说明。max_mint_quantity 属性指定可创建的此令牌类的最大 NFT 数。
  • Owner- 令牌当前所有者的帐户 ID。在铸造过程中,此方法的调用者将成为令牌的所有者。
  • Symbol- 令牌的符号。
  • TokenDesc- 标记的说明。
  • TokenMetadata- 描述令牌的 JSON 信息。
  • TokenName- 标记的名称。
  • TokenStandard- 令牌的标准。
  • TokenType —此账户持有的令牌的类型。
  • TokenUnit- 令牌的单位。
  • TokenUri- 令牌的 URI。
返回值示例:
{
    "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
此方法更新令牌属性。此方法只能由作为令牌的所有者或创建者的用户调用。创建令牌资产后,只有令牌所有者可以更新令牌定制属性。如果用户既是令牌所有者,又是令牌的创建者,他们还可以更新 TokenDesc 属性。无法更新令牌元数据。必须将所有令牌属性传递到此方法,即使您只想更新某些属性也是如此。
func (t *Controller) Update<Token Name>Token(tokenAsset <Token Class>) (interface{}, error) {
      return t.Ctx.ERC721Token.UpdateToken(&tokenAsset)
}
参数:
  • tokenAsset: <Token Class> —要更新的令牌资产。有关令牌资产属性的更多信息,请参见输入规范文件。
返回:
  • 成功时,更新的 JSON 标记资产对象
返回值示例:
{
    "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",
}

令牌行为管理方法 - 可转移行为

SafeTransferFrom
此方法将指定 NFT 的所有权从调用方转移到其他账户。此方法包括以下验证:
  • 标记存在且未刻录。
  • 发件人账户和接收者账户存在且不是同一账户。
  • 发件人账户拥有令牌。
  • 函数的调用者是发送者。
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...)
}
参数:
  • fromOrgId: string —当前组织中发件人的成员服务提供商 (MSP) ID。
  • fromUserId: string —发件人的用户名或电子邮件 ID。
  • toOrgId: string —当前组织中接收方的成员服务提供商 (MSP) ID。
  • toUserId: string- 接收者的用户名或电子邮件 ID。
  • tokenId: string- 要传输的令牌的 ID。
  • data: string —要在事务处理记录中存储的可选附加信息。
返回:
  • 成功时,将显示包含发件人和接收者账户详细信息的消息。
返回值示例:
{"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
此方法将指定 NFT 的所有权从发件人账户转移到接收者账户。呼叫者有责任传递正确的参数。此方法可由任何用户调用,而不仅仅是令牌所有者。此方法包括以下验证:
  • 标记存在且未刻录。
  • 发件人账户和接收者账户存在且不是同一账户。
  • 发件人账户拥有令牌。
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())
}
参数:
  • fromOrgId: string —当前组织中发件人的成员服务提供商 (MSP) ID。
  • fromUserId: string —发件人的用户名或电子邮件 ID。
  • toOrgId: string —当前组织中接收方的成员服务提供商 (MSP) ID。
  • toUserId: string- 接收者的用户名或电子邮件 ID。
  • tokenId: string- 要传输的令牌的 ID。
返回:
  • 成功时,将显示包含发件人和接收者账户详细信息的消息。
返回值示例:
{"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)"}

令牌行为管理方法 - 可燃行为

Burn
此方法从调用者的帐户中停用或刻录指定的 NFT。此方法的调用者必须有一个帐户。除非令牌规范文件包含 burnable 行为,否则无法刻录令牌。如果在规范文件的 roles 部分中未指定 burner_role_name 属性,则令牌的所有者可以刻录令牌。如果在 roles 部分中指定了 burner_role_name 属性,则分配了刻录器角色(也是令牌的 minter(创建者)的用户可以刻录令牌。
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())
}
参数:
  • tokenId: string- 要刻录的标记的 ID。
返回:
  • 成功时,将显示一条包含客户详细信息的消息。
返回值示例:
{"msg": "Successfully burned NFT token: 'monalisa' from Account-Id: oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (Org-Id: Org1MSP, User-Id: admin"}
BurnNFT
此方法从调用者的帐户中停用或刻录指定的 NFT,并返回令牌对象和令牌历史记录。此方法的调用者必须有一个帐户。除非令牌规范文件包含 burnable 行为,否则无法刻录令牌。如果在规范文件的 roles 部分中未指定 burner_role_name 属性,则令牌的所有者可以刻录令牌。如果在 roles 部分中指定了 burner_role_name 属性,则分配了刻录器角色(也是令牌的 minter(创建者)或所有者)的用户可以刻录令牌。
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
}
参数:
  • tokenId: string- 要刻录的标记的 ID。
返回:
  • 成功时,包含令牌历史记录信息的令牌对象。
返回值示例:
{
    "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"
}

定制方法

您可以使用令牌 SDK 方法为业务应用程序编写定制方法。

以下示例说明如何在定制方法中使用令牌 SDK 方法。调用 Sell 方法时,它会以指定价格发布要销售的令牌。

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
}

NFT SDK 方法

访问控制管理方法

NFT SDK 提供访问控制功能。某些方法只能由令牌的 Token AdminAccount Owner 调用。您可以使用此功能来确保操作仅由目标用户执行。任何未经授权的访问都会导致错误。要使用访问控制函数,请从 ../lib/auth 模块导入 Authorization 类。
import { ERC721Authorization } from '../lib/erc721-auth';
CheckAuthorization
使用此方法可将访问控制检查添加到操作。大多数自动生成的方法包括访问控制。某些令牌方法只能由令牌的 ERC721AdminAccount Owner 运行,也可以由具有多个帐户的用户的 MultipleAccountOwner 运行。CheckAuthorization 方法是 erc721Auth 软件包的一部分,您可以通过 Ctx 结构(接收器)进行访问。访问控制映射在 oChainUtil.go 文件中进行了介绍,如以下文本所示。可以通过编辑 oChainUtil.go 文件来修改访问控制。要使用您自己的访问控制或禁用访问控制,请从自动生成的控制器方法和定制方法中删除访问控制代码。
  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)
参数:
  • funcName: string- 接收器与方法之间的映射值,如 oChainUtil.go 文件中所述。
  • ...args- 可变参数,其中 args[0] 接受常量 'TOKEN'args[1] 接受 accountId 参数来为 AccountOwner 添加访问控制检查。要为 MultipleAccountOwner 添加访问控制检查,args[1] 将接受 orgId 参数,args[2] 将接受 userId 参数。要为 TokenOwner 添加访问控制检查,args[1] 将接受 tokenId 参数。
返回:
  • 布尔值响应,如果需要,则为错误。
示例:
t.Ctx.ERC721Auth.CheckAuthorization(<parameters>)

Admin 访问

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

AccountOwner 访问

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

MultipleAccountOwner 访问

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

TokenOwner 访问

t.Ctx.ERC721Auth.CheckAuthorization("ERC721TOKEN.Get", "TOKEN", tokenId)
IsUserTokenAdmin
如果函数的调用者为 Token Admin,此方法将返回布尔值为 true 的映射。否则,方法返回 false
Ctx.ERC721Auth.IsUserTokenAdmin(orgId string, userId string)  (interface{}, error)
参数:
  • orgId- 当前网络组织中用户的成员服务提供商 (Member Service Provider,MSP) ID。
  • userId —用户的用户名或电子邮件 ID。
返回:
  • 布尔值响应。
示例:

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

{"result":true}
AddAdmin
此方法将用户添加为令牌链代码的 Token Admin
Ctx.ERC721Admin.AddAdmin(orgId string, userId string) (interface{}, error)
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功后,将出现一条消息,其中列出作为令牌链代码的 Token Admin 添加的用户的详细信息。出错时,包含错误消息的非空错误对象。
示例:

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

{"msg":"Successfully added Admin (OrgId: Org1MSP, UserId: user1)"}
RemoveAdmin
此方法将用户删除为令牌链代码的 Token Admin
Ctx.ERC721Admin.RemoveAdmin(orgId string, userId string) (interface{}, error)
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功后,将列出用户详细信息的消息作为令牌链代码的 Token Admin 删除。出错时,包含错误消息的非空错误对象。
示例:

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

{"msg":"Successfuly removed Admin (OrgId Org1MSP UserId user1)"}
GetAllAdmins
此方法返回所有 Token Admin 用户的列表。
Ctx.ERC721Admin.GetAllAdmins() (Admin[], error) 
参数:
返回:
  • 成功后,将列出所有 Token Admin 用户。出错时,包含错误消息的非空错误对象。
示例:

t.Ctx.ERC721Admin.GetAllAdmins()

{
    "admins": [
        {
            "OrgId":"Org1MSP",
            "UserId":"admin"
        }
    ]
}
GetAllAdminUsers
此方法返回所有 Token Admin 用户的列表。
Ctx.ERC721Admin.GetAllAdminUsers() (interface{}, error) 
参数:
返回:
  • 成功后,将列出 map[string]interface{} 格式的所有 Token Admin 用户。出错时,包含错误消息的非空错误对象。
示例:

t.Ctx.ERC721Admin.GetAllAdminUsers()

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

标记配置管理方法

CreateToken
此方法创建令牌并将其属性保存在状态数据库中。此方法只能由具有 minter 角色的用户调用。
Ctx.ERC721Token.CreateToken(args ...interface{})
参数:
  • 一个变量参数,其中 args[0] 包含对所需类型的标记 struct 的引用。
返回:
  • 成功时,使用包含令牌详细信息的 interface[]。出错时,非空对象将出现错误消息。
示例:

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
此方法返回指定令牌的令牌 URI。
Ctx.ERC721Token.GetTokenURI(tokenId string) (interface{}, error)
参数:
  • tokenId: string- 令牌的 ID。
返回:
  • 成功后,它将返回字符串数据类型中新标记 URI 的映射。出错时,非空对象将出现错误消息。
示例:

t.Ctx.ERC721Token.GetTokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
TokenUri
此方法返回指定令牌的令牌 URI。
Ctx.ERC721Token.TokenURI(tokenId string) (interface{}, error)
参数:
  • tokenId: string- 令牌的 ID。
返回:
  • 成功后,它将返回字符串数据类型中新标记 URI 的映射。出错时,非空对象将出现错误消息。
返回值示例:

t.Ctx.ERC721Token.TokenURI(tokenId)

{"TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg"}
Symbol
此方法返回令牌类的符号。
Ctx.ERC721Token.Symbol() (interface{}, error)
参数:
返回:
  • 成功时,将映射字符串数据类型中的符号。出错时,包含错误消息的非空对象。
示例:

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}
Name
此方法返回令牌类的名称。
Ctx.ERC721Token.Name() (interface{}, error)
参数:
返回:
  • 成功时,将映射字符串数据类型中的标记名称。出错时,包含错误消息的非空对象。
示例:

t.Ctx.ERC721Token.Name()

{"TokenName": "paintingnft"}
OwnerOf
此方法返回指定令牌所有者的帐户 ID。
Ctx.ERC721Token.OwnerOf(tokenId string) (interface{}, error)
参数:
  • tokenId: string- 令牌的 ID。
返回:
  • 成功时,将映射字符串数据类型中所有者的帐户 ID。出错时,包含错误消息的非空对象。
示例:

t.Ctx.ERC721Token.OwnerOf(tokenId)

{"Owner": "oaccount~ec32cff8635a056f3dda3da70b1d6090d61f66c6a170c4a95fd008181f729dba"}
TotalSupply
此方法返回铸造的 NFT 总数。
Ctx.ERC721Token.TotalSupply() (map[string]interface{}, error)
参数:
  • tokenId: string- 令牌的 ID。
返回:
  • 成功时,数字数据类型中标记总供应的映射。出错时,拒绝并显示错误消息。
示例:

t.Ctx.ERC721Token.TotalSupply();

{"TotalSupply": 3}
GetAllTokens
此方法返回保存在状态数据库中的所有标记资产。此方法使用 Berkeley DB SQL 丰富的查询,并且只能在连接到远程 Oracle Blockchain Platform 网络时调用。
Ctx.ERC721Token.GetAllTokens()  (interface{}, error)
参数:
返回:
  • 成功时,将映射所有令牌资产。出错时,包含错误消息的非空对象。
示例:

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
此方法返回指定帐户 ID 拥有的所有标记。此方法使用 Berkeley DB SQL 丰富的查询,并且只能在连接到远程 Oracle Blockchain Platform 网络时调用。
Ctx.ERC721Token.GetAllTokensByUser(accountId string) (interface{}, error)
参数:
  • accountId: string –帐户的 ID。
返回:
  • 成功时,指定账户的令牌资产映射。出错时,包含错误消息的非空对象。
示例:

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
如果指定的令牌对象存在于状态数据库中,则此方法将返回该对象。
Ctx.Get(Id string, result ...interface{}) (interface{}, error)
参数:
  • tokenId: string- 令牌的 ID。
  • result- 可变参数,其中第一个参数 result[0] 是对正确类型的空 Token 对象的引用,该对象在成功调用方法后将包含令牌数据。
返回:
  • 成功时,将映射标记资产数据。此外,如果传递了 result[0],则会将数据分配给 result[0]。出错时,包含错误消息的非空对象。
示例:

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
此方法更新令牌属性。此方法只能由令牌的所有者或创建者调用。创建令牌资产后,只有令牌所有者可以更新令牌定制属性。如果用户既是令牌所有者,又是令牌的创建者,他们还可以更新 TokenDesc 属性。无法更新令牌元数据。必须将所有令牌属性传递到此方法,即使您只想更新某些属性也是如此。
Ctx.ERC721Token.UpdateToken(asset interface{}) (interface{}, error)
参数:
  • 对所需类型的标记结构数据的引用
返回:
  • 成功时,将显示包含令牌详细信息的承诺消息。出错时,拒绝并显示错误消息。
示例:

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
此方法返回指定令牌的历史记录。
Ctx.ERC721Token.History(tokenId: string)  (interface{}, error)
参数:
  • tokenId: string- 令牌的 ID。
返回:
  • 在成功时,一组地图。出错时,拒绝并显示错误消息。
示例:

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
此方法返回新的 TrxContext 对象。trxcontext 结构包含对所有 SDK 库的引用。仅使用此对象访问 sdk 方法。当并发事务处理正在运行时,trxcontext 对象可维护 SDK 库中事务处理存根的互斥性。
GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext
参数:
  • stub- 事务处理存根。
返回:
  • trxcontext 结构。
示例:

trxcontext.GetNewCtx(stub)

trxcontext object.

账户管理方法

GenerateAccountId
此方法返回帐户 ID,通过连接成员服务提供商 ID (orgId) 和用户名或电子邮件 ID (userId) 并创建 SHA-256 散列来形成帐户 ID。
Ctx.ERC721Account.GenerateAccountId(orgId string, userId string) (string, error)
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功时,生成的账户 ID。出错时,包含错误消息的非空对象。
示例:

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

oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507
CreateAccount
此方法为指定的用户创建帐户。必须为在任何时候都具有令牌的任何用户创建账户。账户跟踪用户拥有的 NFT 数。用户必须在网络中有账户才能完成与令牌相关的操作。每个用户只能创建一个 NFT 账户。

帐户 ID 是字母数字字符集,前缀为 oaccount~,后跟当前网络组织中用户的成员服务提供商 ID (org_id) 的 SHA-256 散列、实例所有者或登录实例的用户的用户名或电子邮件 ID (userId) 以及常量字符串 nft

Ctx.ERC721Account.CreateAccount(orgId string, userId string, tokenType string) (ERC721Account, error)
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
  • tokenType: string- 唯一支持的令牌类型是 nonfungible
返回:
  • 成功时,新客户对象。出错时,包含错误消息的非 nil 对象
示例:

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

{
    "AssetType": "oaccount",
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "BapAccountVersion" : 0,
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
GetAllAccounts
此方法返回所有帐户的列表。此方法使用 Berkeley DB SQL 丰富的查询,并且只能在连接到远程 Oracle Blockchain Platform 网络时调用。
Ctx.ERC721Account.GetAllAccounts() (interface{}, error)
参数:
返回:
  • 所有帐户的 JSON 数组。
示例:

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
此方法返回指定帐户的帐户历史记录详细信息数组。
Ctx.ERC721Account.History(accountId string) (interface{}, error)
参数:
  • accountId: string –帐户的 ID。
返回:
  • 成功时,包含指定帐户的帐户历史记录详细信息的 map[string]interface{} 数组。帐户数据显示在映射中的 value 键下。出错时,包含错误消息的非空错误对象。
示例:

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
此方法返回指定帐户的用户详细信息。
Ctx.ERC721Account.GetUserByAccountId(accountId string) (interface{}, error)
参数:
  • accountId: string –帐户的 ID。
返回:
  • 成功后,将在以下属性中包含用户详细信息的 JSON 对象:
    • OrgId- 当前网络组织中用户的成员服务提供商 (Member Service Provider,MSP) ID。
    • UserId —用户的用户名或电子邮件 ID。
  • 出错时,包含错误消息的非空对象。
示例:

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

{
    "OrgId": "Org1MSP",
    "UserId": "admin"
}
GetAccountWithStatusByUser
此方法返回指定用户的帐户详细信息,包括帐户状态。此方法只能由链代码的 Token Admin 或帐户的 Account Owner 调用。
Ctx.ERC721Account.GetAccountWithStatusByUser(orgId, userId) (interface{}, error)
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功后,包含以下属性的 JSON 账户对象:
  • AccountId- 用户帐户的 ID。
  • UserId —用户的用户名或电子邮件 ID。
  • OrgId —当前组织中用户的成员服务提供商 (MSP) ID。
  • TokenType —账户持有的令牌类型。
  • NoOfNfts —账户持有的 NFT 总数。
  • BapAccountVersion- 供内部使用的帐户对象参数。
  • Status- 用户帐户的当前状态。
  • 出错时,包含错误消息的非 nil 对象。
示例:
{
  "AccountId": "oaccount~cc301bee057f14236a97d434909ec1084970921b008f6baab09c2a0f5f419a9a",
  "AssetType": "oaccount",
  "BapAccountVersion": 0,
  "NoOfNfts": 0,
  "OrgId": "appdev",
  "Status": "active",
  "TokenType": "nonfungible",
  "UserId": "idcqa"
}
GetAccountByUser
此方法返回指定用户的帐户详细信息。此方法只能由链代码的 Token Admin 或帐户的 Account Owner 调用。
Ctx.ERC721Account.GetAccountByUser(orgId, userId) (ERC721Account, error)
参数:
  • orgId: string —当前组织中用户的成员服务提供商 (MSP) ID。
  • userId: string —用户的用户名或电子邮件 ID。
返回:
  • 成功后,包含以下属性的 JSON 账户对象:
  • AccountId- 用户帐户的 ID。
  • UserId —用户的用户名或电子邮件 ID。
  • OrgId —当前组织中用户的成员服务提供商 (MSP) ID。
  • TokenType —账户持有的令牌类型。
  • NoOfNfts —账户持有的 NFT 总数。
  • 出错时,包含错误消息的非 nil 对象。
示例:
{
    "AssetType": "oaccount",
    "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "BapAccountVersion" : 0,
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
BalanceOf
此方法返回指定用户保留的 NFT 总数。
Ctx.ERC721Account.BalanceOf(accountId string) (interface{}, error)
参数:
  • accountId: string –用户的帐户 ID。
返回:
  • 成功时,带有消息的接口和 NFT 的总数。出错时,包含错误消息的非空错误对象。
示例:

t.Ctx.ERC721Account.BalanceOf(accountId)

{"TotalNfts": 0}

角色管理方法

AddRoleMember
此方法向指定用户添加角色。
Ctx.ERC721Token.AddRoleMember(role string, accountId string) (interface{}, error)
参数:
  • role: string —要添加到指定用户的角色的名称。mintableburnable 行为对应于规范文件的 minter_role_nameburner_role_name 属性。
  • accountId: number –要操作的帐户 ID。
返回:
  • 成功时,显示包含成功消息的映射。出错时,包含错误消息的非空对象。
示例:

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

{"msg": "Successfully added role minter to oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin)"}
RemoveRoleMember
此方法从指定用户和令牌中删除角色。通过创建串联成员服务提供者 ID (orgId) 和用户名或电子邮件 ID (userId) 的 SHA-256 散列来形成帐户 ID。
Ctx.Token.RemoveRoleMember(role string, accountId string) (interface{}, error)
参数:
  • role: string- 要从指定用户删除的角色的名称。mintableburnable 行为对应于规范文件的 minter_role_nameburner_role_name 属性。
  • accountId: number –要操作的帐户 ID。
返回:
  • 成功时,显示包含成功消息的映射。出错时,包含错误消息的非空对象。
示例:

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

{"msg": "successfully removed memberId oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d (orgId : Org1MSP, userId : admin) from role minter"}
IsInRole
此方法返回布尔值,以指示用户和令牌是否具有指定的角色。通过创建串联成员服务提供者 ID (orgId) 和用户名或电子邮件 ID (userId) 的 SHA-256 散列来形成帐户 ID。
Ctx.ERC721Token.IsInRole(role string, accountId string) (bool, error)
参数:
  • role: string- 要检查指定用户的角色的名称。mintableburnable 行为对应于规范文件的 minter_role_nameburner_role_name 属性。
  • accountId: number –要操作的帐户 ID。
返回:
  • 成功时,如果指定的账户 ID 存在角色,则布尔值为 true,否则为 false。出错时,包含错误消息的非 nil 对象
示例:

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

{"result": false}
GetAccountsByRole
此方法返回指定角色的所有帐户 ID 的列表。
Ctx.ERC721Role.GetAccountsByRole(roleName string) (interface{}, error)
参数:
  • roleName: string —要搜索的角色的名称。
返回:
  • 成功后,账户 ID 的 JSON 数组。出错时,包含错误消息的非空错误对象。
示例:

t.Ctx.ERC721Role.GetAccountsByRole(userRole)

{
    "accounts": [
        "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d"
    ]
}
GetUsersByRole
此方法返回指定角色的所有用户的列表。
Ctx.ERC721Role.GetUsersByRole(roleName string) (interface{}, error)
参数:
  • roleName: string —要搜索的角色的名称。
返回:
  • 成功后,用户对象的 JSON 数组。每个对象都包含用户 ID 和组织 ID。出错时,包含错误消息的非空错误对象。
示例:

t.Ctx.ERC721Role.GetUsersByRole(userRole)

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

事务处理历史记录管理方法

GetAccountTransactionHistory
此方法返回指定帐户的事务处理历史记录详细信息数组。
Ctx.ERC721Account.GetAccountTransactionHistory(accountId string) (interface{}, error)
参数:
  • accountId: string –帐户的 ID。
返回:
  • 成功后,使用 JSON 格式的账户事务处理对象数组:
    • TransactionId —事务处理的 ID。
    • TransactedAccount —发生事务处理的账户。
    • TransactionType –事务的类型。
    • Timestamp —事务处理的时间。
    • 出错时,包含错误消息的非空错误对象。
示例:

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
此方法返回指定用户的帐户事务处理历史记录,按 PageSizeBookmarkstartTimeendTime 过滤。只能在连接到远程 Oracle Blockchain Platform 网络时调用此方法。
Ctx.ERC721Account.GetAccountTransactionHistoryWithFilters(accountId string, filters ...erc721Account.AccountHistoryFilters)
参数:
  • accountId: string –账户的 ID。
  • filters: string- 可选参数。如果为空,将返回所有记录。PageSize 属性确定要返回的记录数。如果 PageSize 为 0,则默认页面大小为 20。Bookmark 属性确定要返回的记录起始索引。有关更多信息,请参见 Hyperledger Fabric 文档。必须以 RFC-3339 格式指定 StartTimeEndTime 属性。
返回:
  • 成功后,使用 JSON 格式的账户事务处理对象数组:
    • TransactionId —事务处理的 ID。
    • TransactedAccount —发生事务处理的账户。
    • TransactionType –事务的类型。
    • Timestamp —事务处理的时间。
    • 出错时,包含错误消息的非空错误对象。
示例:

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
此方法返回 Transaction 资产的历史记录。
Ctx.ERC721Transaction.GetTransactionById(trxId string) (interface{}, error)
参数:
  • trxId: string —事务处理资产的 ID。
返回:
  • 成功后,将生成一系列事务处理资产映射。出错时,包含错误消息的非空错误对象。
示例:

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
此方法从状态数据库中删除早于指定日期的事务处理。
func (t *Controller) DeleteHistoricalTransactions(referenceTime string) (interface{}, error)
参数:
  • referenceTime: string —将删除早于指定时间的事务处理。
返回:
  • 成功时,包含已删除事务处理 ID 的数组和成功消息。出错时,包含错误消息的非空错误对象。
示例:

t.Ctx.ERC721Transaction.DeleteHistoricalTransactions(timestamp)

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

令牌行为管理 - 最小行为

GetMaxMintQuantity
此方法返回令牌的最大可最小数量。如果未在规范文件中配置 max_mint_quantity 行为,则缺省值为 0,并且可以铸造无限数量的标记。
Ctx.ERC721Token.GetMaxMintQuantity(id string) (float64, error)
参数:
  • id- 要对其执行操作的标记的 ID。
返回:
  • 成功时,标记的最大可最小数量,以数字数据类型表示。出错时,非空对象将出现错误消息。
示例:

t.Ctx.ERC721Token.GetMaxMintQuantity(tokenId);

20000
GetTotalMintedTokens
此方法返回系统中指定令牌的可用令牌总数。可用令牌的净数量是铸造令牌总数减去烧毁令牌的数量。
Ctx.ERC721Token.GetTotalMintedTokens() (map[string]interface{}, error)
参数:
返回:
  • 成功时,将映射铸造的标记总数、数字数据类型和成功消息。出错时,非空对象将出现错误消息。
示例:

t.Ctx.ERC721Token.GetTotalMintedTokens()

{"TotalNetSupply": 5}

令牌行为管理 - 可转移行为

SafeTransferFrom
此方法将指定 NFT 的所有权从调用方转移到其他账户。此方法包括以下验证:
  • 标记存在且未刻录。
  • 发件人账户和接收者账户存在且不是同一账户。
  • 发件人账户拥有令牌。
  • 函数的调用者是发送者。
Ctx.ERC721Token.SafeTransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}, data ...string) (interface{}, error)
参数:
  • fromAccountId: string —当前组织中发件人的账户 ID。
  • toAccountId: string —当前组织中接收方的账户 ID。
  • tokenAsset —要操作的令牌资产的引用。
  • data: string —可选的要在事务处理中存储的其他信息。
返回:
  • 成功时,包含成功消息的承诺,其中包含客户详细信息。出错时,非空对象将出现错误消息。
示例:

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
此方法将指定 NFT 的所有权从发件人账户转移到接收者账户。呼叫者有责任传递正确的参数。此方法可由任何用户调用,而不仅仅是令牌所有者。此方法包括以下验证:
  • 标记存在且未刻录。
  • 发件人账户和接收者账户存在且不是同一账户。
  • 发件人账户拥有令牌。
Ctx.ERC721Token.TransferFrom(fromAccountId string, toAccountId string, tokenAsset interface{}) (interface{}, error)
参数:
  • fromAccountId: string —当前组织中发件人的账户 ID。
  • toAccountId: string —当前组织中接收方的账户 ID。
  • tokenAsset —要操作的令牌资产的引用。
返回:
  • 成功时,包含成功消息的承诺,其中包含客户详细信息。账户 ID 的前缀为 oaccount~。出错时,非空对象将出现错误消息。
\ 示例:

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

令牌行为管理 - 可燃行为

Burn
此方法从调用者的帐户中停用或刻录指定的 NFT。此方法的调用者必须有一个帐户。除非令牌规范文件包含 burnable 行为,否则无法刻录令牌。如果在规范文件的 roles 部分中未指定 burner_role_name 属性,则令牌的所有者可以刻录令牌。如果在 roles 部分中指定了 burner_role_name 属性,则分配了刻录器角色(也是令牌的 minter(创建者)的用户可以刻录令牌。burn 方法是 ERC721Token 软件包的一部分,您可以通过 Ctx 结构的接收器进行访问。
Ctx.Token.Burn(tokenAsset interface{}) (interface{}, error)
参数:
  • tokenAsset —要操作的令牌资产的引用。
返回:
  • 成功时,包含成功消息的承诺,其中包含客户详细信息。出错时,非空对象将出现错误消息。
示例:

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

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