ERC-721 脚手架 Go NFT 项目

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

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

有关与 NFT 不直接相关的支架项目和方法的信息,请参阅支架式 Go 链代码项目

型号

透明持久性功能(Transparent Persistence Capability,简称 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 - 当前组织中用户的成员服务提供者 (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 是当前网络组织中用户的成员服务提供者 (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 - 当前组织中用户的成员服务提供者 (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 - 当前组织中用户的成员服务提供者 (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 - 要搜索的角色的名称。
返回:
  • 成功后,将生成 JSON 帐户 ID 数组。
返回值示例:
{
    "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 - 当前组织中用户的成员服务提供者 (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
此方法创建(薄荷)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> - mint 的标记资产。有关令牌资产属性的更多信息,请参见输入规范文件。
返回:
  • 成功时,包含以下属性的 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 属性,则指定燃烧者角色的用户(也是令牌的矿工(创建者)可以刻录令牌。
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 属性,则指定燃烧者角色的用户(也是令牌的矿工(创建者)或所有者)可以刻录令牌。
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- 当前网络组织中用户的成员服务提供者 (Membership 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)
参数:
  • 对所需类型的标记结构数据的引用
返回:
  • 成功时,将显示包含令牌详细信息的 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",
}
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 通过连接成员服务提供者 ID (orgId) 和用户名或电子邮件 ID (userId),然后创建 SHA-256 散列来形成。
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
返回:
  • 成功时,新客户对象。出错时,包含错误消息的非零对象
示例:

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- 当前网络组织中用户的成员服务提供者 (Membership 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 - 用户账户的当前状态。
  • 出错时,包含错误消息的非零对象。
示例:
{
  "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 总数。
  • 出错时,包含错误消息的非零对象。
示例:
{
    "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 是通过创建串联成员服务供应商 ID (orgId) 和用户名或电子邮件 ID (userId) 的 SHA-256 散列形成的。
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 是通过创建串联成员服务供应商 ID (orgId) 和用户名或电子邮件 ID (userId) 的 SHA-256 散列形成的。
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}
GetAccountsByRole
此方法返回指定角色的所有帐户 ID 的列表。
Ctx.ERC721Role.GetAccountsByRole(roleName string) (interface{}, error)
参数:
  • roleName: string - 要搜索的角色的名称。
返回:
  • 成功后,将生成 JSON 帐户 ID 数组。出错时,包含错误消息的非零错误对象。
示例:

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

标记行为管理 - Mintable Behavior

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 属性,则指定燃烧者角色的用户(也是令牌的矿工(创建者)可以刻录令牌。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"}