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 生命周期任务,而无需额外编码。控制器方法必须为公共且可调用。公共方法名称以大写字符开头。以小写字符开头的方法名称是专用的。

访问控制管理的方法

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- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,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 是当前网络组织中用户的成员服务提供商 (Membership 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- 当前组织中用户的成员服务提供商 (membership service provider,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 类更新交换机用例以返回正确的标记对象。在规范文件中创建标记化资产时,Blockchain App Builder 中的 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- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,MSP) ID。
  • userId: string- 用户的用户名或电子邮件 ID。
返回:
  • 成功后,包含以下属性的 JSON 帐户对象:
  • AccountId- 用户帐户的 ID。
  • UserId- 用户的用户名或电子邮件 ID。
  • OrgId- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,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- 要搜索的角色的名称。
返回:
  • 成功后,用户对象的 JSON 数组(orgIduserId)。
返回值示例:
{
    "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- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,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 角色。否则,任何调用方都可以生成 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- 对 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';
AddAdmin
此方法将用户添加为令牌链代码的 Token Admin
Ctx.ERC721Admin.AddAdmin(orgId string, userId string) (interface{}, error)
参数:
  • orgId: string- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,MSP) ID。
  • userId: string- 用户的用户名或电子邮件 ID。
返回:
  • 成功后,将列出作为令牌链代码的 Token Admin 删除用户的详细信息的消息。出现错误时,包含错误消息的非零错误对象。
示例:

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

{"msg":"Successfuly removed Admin (OrgId Org1MSP UserId user1)"}
IsUserTokenAdmin
如果函数的调用方为 Token Admin,则此方法返回布尔值为 true 的映射。否则,该方法将返回 false
Ctx.ERC721Auth.IsUserTokenAdmin(orgId string, userId string)  (interface{}, error)
参数:
  • orgId- 当前网络组织中用户的成员服务提供商 (membership service provider,MSP) ID。
  • userId- 用户的用户名或电子邮件 ID。
返回:
  • 布尔值响应。
示例:

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

{"result":true}
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"
        }
    ]
}
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)

标记配置管理的方法

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

t.Ctx.ERC721Token.OwnerOf(tokenId)

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

t.Ctx.ERC721Token.Name()

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

t.Ctx.ERC721Token.Symbol()

{"Symbol": "PNT"}
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"}
TotalSupply
此方法返回铸造 NFT 的总数。
Ctx.ERC721Token.TotalSupply() (map[string]interface{}, error)
参数:
  • tokenId: string- 令牌的 ID。
返回:
  • 成功后,数字数据类型中令牌总供应的映射。出错时,将拒绝并显示错误消息。
示例:

t.Ctx.ERC721Token.TotalSupply();

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

t.Ctx.ERC721Token.UpdateToken(&asset)

{
    "AssetType": "otoken",
    "Behavior": [
        "indivisible",
        "singleton",
        "mintable",
        "transferable",
        "burnable",
        "roles"
    ],
    "CreatedBy": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",     
    "CreationDate": "2022-04-06T08:16:53Z",
    "IsBurned": false,   
    "Mintable": {
        "Max_mint_quantity": 20000
    },
    "NftBasePrice": 200,
    "Owner": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "Roles": {
        "burner_role_name": "burner",
        "minter_role_name": "minter"
    },
    "Symbol": "PNT",
    "TokenDesc": "Token Description",
    "TokenId": "monalisa",
    "TokenMetadata": {
        "Description": "Mona Lisa Painting",
        "Image": "monalisa.jpeg",
        "PainterName": "Leonardo_da_Vinci",
        "PaintingName": "Mona_Lisa"
    },
    "TokenName": "paintingnft",
    "TokenStandard": "erc721+",
    "TokenType": "nonfungible",
    "TokenUnit": "whole",
    "TokenUri": "https://bafybeid6pmpp62bongoip5iy2skosvyxh3gr7r2e35x3ctvawjco6ddmsq\\ .ipfs.infura-ipfs.io/?filename=MonaLisa.jpeg",
}
GetNewCtx
此方法返回一个新的 TrxContext 对象。trxcontext 结构包含对所有 SDK 库的引用。仅使用此对象访问 sdk 方法。trxcontext 对象在并发事务运行时维护 SDK 库中事务存根的互斥性。
GetNewCtx(stub shim.ChaincodeStubInterface) TrxContext
参数:
  • stub –交易存根。
返回:
  • trxcontext 结构。
示例:

trxcontext.GetNewCtx(stub)

trxcontext object.

账户管理方法

GenerateAccountId
此方法返回帐户 ID,该 ID 通过连接成员服务供应商 ID (orgId) 和用户名或电子邮件 ID (userId),然后创建 SHA-256 散列来形成。
Ctx.ERC721Account.GenerateAccountId(orgId string, userId string) (string, error)
参数:
  • orgId: string- 当前组织中用户的成员服务提供商 (membership service provider,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- 当前组织中用户的成员服务提供商 (membership service provider,MSP) ID。
  • userId: string- 用户的用户名或电子邮件 ID。
  • tokenType: string- 唯一支持的令牌类型是 nonfungible
返回:
  • 成功时,新帐户对象。出现错误时,包含错误消息的非空对象
示例:

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

{
    "AssetType": "oaccount",
    "AccountId": "oaccount~a0a60d54ba9e2ff349737d292ea10ebd9cc8f1991c11443c19d20aea299a9507",
    "UserId": "admin",
    "BapAccountVersion" : 0,
    "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}
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"
        }
    }
]
GetAccountByUser
此方法返回指定用户的帐户详细信息。此方法只能由链代码的 Token Admin 或帐户的 Account Owner 调用。
Ctx.ERC721Account.GetAccountByUser(orgId, userId) (ERC721Account, error)
参数:
  • orgId: string- 当前组织中用户的成员服务提供商 (membership service provider,MSP) ID。
  • userId: string- 用户的用户名或电子邮件 ID。
返回:
  • 成功后,包含以下属性的 JSON 帐户对象:
  • AccountId- 用户帐户的 ID。
  • UserId- 用户的用户名或电子邮件 ID。
  • OrgId- 当前组织中用户的成员服务提供商 (membership service provider,MSP) ID。
  • TokenType- 帐户保留的令牌类型。
  • NoOfNfts —账户持有的 NFT 总数。
  • 出现错误时,包含错误消息的非空对象。
示例:
{
    "AssetType": "oaccount",
    "AccountId": "oaccount~42e89f4c72dfde9502814876423c6da630d466e87436dd1aae201d347ad1288d",
    "BapAccountVersion" : 0,
    "UserId": "admin",
    "OrgId": "Org1MSP",
    "TokenType": "nonfungible",
    "NoOfNfts": 0
}
GetUserByAccountId
此方法返回指定帐户的用户详细信息。
Ctx.ERC721Account.GetUserByAccountId(accountId string) (interface{}, error)
参数:
  • accountId: string- 帐户的 ID。
返回:
  • 成功后,在以下属性中包含用户详细信息的 JSON 对象:
    • OrgId- 当前网络组织中用户的成员服务提供商 (membership service provider,MSP) ID。
    • UserId- 用户的用户名或电子邮件 ID。
  • 出现错误时,包含错误消息的非空对象。
示例:

t.Ctx.ERC721Account.GetUserByAccountById(accountId)

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

角色管理的方法

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"}
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"
        }
    ]
}
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。出现错误时,包含错误消息的非空对象
示例:

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

{"result": false}

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

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