models

Documentation

Index

• Constants
• type Accounts
• type AvataError
• type BaseParams
• type BatchCreateAccountsReq
• type BatchCreateAccountsRes
• type BatchCreateOrderReq
• type BurnMTReq
• type BurnNFTReq
• type BurnNativeNFTReq
• type CreateAccountReq
• type CreateAccountRes
• type CreateMTClassReq
• type CreateNFTClassReq
• type CreateNativeNFTClassReq
• type CreateOrderReq
• type CreateRecordReq
• type CreateUsersReq
• type CreateUsersRes
• type DataItem
• type EditMTReq
• type EditNFTReq
• type EditNativeNFTReq
• type EditUsersReq
• type Error
  • func InvalidParam(message string) Error
  • func NewAvataError(avataError AvataError) Error
  • func NewSDKError(message string) Error
• type ErrorRes
  • func (e ErrorRes) Code() string
  • func (e ErrorRes) CodeSpace() string
  • func (e ErrorRes) Error() string
  • func (e ErrorRes) Msg() string
• type IssueMTReq
• type KindRes
• type List
• type MTMsg
• type MintMTReq
• type MintNFTReq
• type MintNativeNFTReq
• type Mt
• type NFTMsg
• type NftEVM
• type NftNative
• type NftV1
• type OnCallbackResEVM
• type OnCallbackResNative
• type OnCallbackResV1
• type OperationRecord
• type OperationRecords
• type OrderRes
• type QueryAccountsHistoryReq
• type QueryAccountsHistoryRes
• type QueryAccountsReq
• type QueryAccountsRes
• type QueryContractReq
• type QueryContractRes
• type QueryDomainReq
• type QueryDomainRes
• type QueryDomainsReq
• type QueryDomainsRes
• type QueryMTBalanceReq
• type QueryMTBalanceRes
• type QueryMTClassRes
• type QueryMTClassesReq
• type QueryMTClassesRes
• type QueryMTHistoryReq
• type QueryMTHistoryRes
• type QueryMTRes
• type QueryMTsReq
• type QueryMTsRes
• type QueryNFTClassRes
• type QueryNFTClassesReq
• type QueryNFTClassesRes
• type QueryNFTHistoryReq
• type QueryNFTHistoryRes
• type QueryNFTRes
• type QueryNFTsReq
• type QueryNFTsRes
• type QueryNativeAccountsHistoryReq
• type QueryNativeAccountsHistoryRes
• type QueryNativeNFTClassRes
• type QueryNativeNFTClassesReq
• type QueryNativeNFTClassesRes
• type QueryNativeNFTHistoryReq
• type QueryNativeNFTHistoryRes
• type QueryNativeNFTRes
• type QueryNativeNFTsReq
• type QueryNativeNFTsRes
• type QueryNativeTxResultRes
• type QueryNativeTxTypesRes
• type QueryOrderRes
• type QueryOrdersReq
• type QueryOrdersRes
• type QueryResolvesReq
• type QueryResolvesRes
• type QueryReverseResolvesRes
• type QueryTxResultRes
• type QueryTxTypesRes
• type QueryUsersReq
• type QueryUsersRes
• type Record
• type RegisterDomainReq
• type Response
• type SetResolvesReq
• type SetReverseResolvesReq
• type TransferDomainReq
• type TransferMTClassReq
• type TransferMTReq
• type TransferNFClassReq
• type TransferNFTReq
• type TransferNativeNFClassReq
• type TransferNativeNFTReq
• type TxRes
• type TxType
• type UseContractReq

Constants

const (
	CreateAccount              = "/v3/account"                 // 创建链账户接口
	BatchCreateAccounts        = "/v3/accounts"                // 批量创建链账户接口
	QueryAccounts              = "/v3/accounts"                // 查询链账户接口
	QueryAccountsHistory       = "/v3/evm/accounts/history"    // 查询链账户操作记录接口
	QueryNativeAccountsHistory = "/v3/native/accounts/history" // 查询链账户在原生模块的操作记录接口

)

const (
	APIVersionV1     = "V1" // V1 版本 AVATA Open API
	APIVersionsOther = ""   // 其它版本 AVATA Open API
)

验证签名时传入的 API 版本号

const (
	Native = "native"
	EVM    = "evm"
)

区分调用不同服务模块的接口

const (
	UseContract   = "/v3/evm/contract/calls" // 调用合约
	QueryContract = "/v3/evm/contract/calls" // 查询合约
)

const (
	UnknownError = "UNKNOWN_ERROR" // 未知错误
	BadRequest   = "BAD_REQUEST"   // 参数错误
)

code

const (
	ErrDomain    = "the avata domain address is required"
	ErrAPIKey    = "the api key for the project is required"
	ErrAPISecret = "the api secret the project is required"
	ErrAmount    = "amount should be integer yuan"

	ErrParam = "%s is required"
)

Message

const (
	CreateMTClass   = "/v3/native/mt/classes"               // 创建 MT 类别
	QueryMTClasses  = "/v3/native/mt/classes"               // 查询 MT 类别
	QueryMTClass    = "/v3/native/mt/classes/%s"            // 查询 MT 类别详情
	TransferMTClass = "/v3/native/mt/class-transfers/%s/%s" // 转让 MT 类别
	IssueMT         = "/v3/native/mt/mt-issues/%s"          // 发行 MT
	MintMT          = "/v3/native/mt/mt-mints/%s/%s"        // 增发 MT
	TransferMT      = "/v3/native/mt/mt-transfers/%s/%s/%s" // 转让 MT
	EditMT          = "/v3/native/mt/mts/%s/%s/%s"          // 编辑 MT
	BurnMT          = "/v3/native/mt/mts/%s/%s/%s"          // 销毁 MT
	QueryMTs        = "/v3/native/mt/mts"                   // 查询 MT
	QueryMT         = "/v3/native/mt/mts/%s/%s"             // 查询 MT 详情
	QueryMTHistory  = "/v3/native/mt/mts/%s/%s/history"     // 查询 MT 操作记录
	QueryMTBalance  = "/v3/native/mt/mts/%s/%s/balances"    // 查询 MT 余额
)

const (
	CreateNFTClass         = "/v3/evm/nft/classes"                   // EVM 模块创建 NFT 类别
	QueryNFTClasses        = "/v3/evm/nft/classes"                   // EVM 模块查询 NFT 类别
	QueryNFTClass          = "/v3/evm/nft/classes/%s"                // EVM 模块查询 NFT 类别详情
	TransferNFTClass       = "/v3/evm/nft/class-transfers/%s/%s"     // EVM 模块转让 NFT 类别
	MintNFT                = "/v3/evm/nft/nfts/%s"                   // EVM 模块发行 NFT
	TransferNFT            = "/v3/evm/nft/nft-transfers/%s/%s/%s"    // EVM 模块转让 NFT
	EditNFT                = "/v3/evm/nft/nfts/%s/%s/%s"             // EVM 模块编辑 NFT
	BurnNFT                = "/v3/evm/nft/nfts/%s/%s/%s"             // EVM 模块销毁 NFT
	QueryNFTs              = "/v3/evm/nft/nfts"                      // EVM 模块查询 NFT
	QueryNFT               = "/v3/evm/nft/nfts/%s/%s"                // EVM 模块查询 NFT 详情
	QueryNFTHistory        = "/v3/evm/nft/nfts/%s/%s/history"        // EVM 模块查询 NFT 操作记录
	CreateNativeNFTClass   = "/v3/native/nft/classes"                // 原生模块创建 NTF 类别
	QueryNativeNFTClasses  = "/v3/native/nft/classes"                // 原生模块查询 NTF 类别
	QueryNativeNFTClass    = "/v3/native/nft/classes/%s"             // 原生模块查询 NFT 类别详情
	TransferNativeNFTClass = "/v3/native/nft/class-transfers/%s/%s"  // 原生模块转让 NFT 类别
	MintNativeNFT          = "/v3/native/nft/nfts/%s"                // 原生模块发行 NFT
	TransferNativeNFT      = "/v3/native/nft/nft-transfers/%s/%s/%s" // 原生模块转让 NFT
	EditNativeNFT          = "/v3/native/nft/nfts/%s/%s/%s"          // 原生模块编辑 NFT
	BurnNativeNFT          = "/v3/native/nft/nfts/%s/%s/%s"          // 原生模块销毁 NFT
	QueryNativeNFTs        = "/v3/native/nft/nfts"                   // 原生模块查询 NFT
	QueryNativeNFT         = "/v3/native/nft/nfts/%s/%s"             // 原生模块查询 NFT 详情
	QueryNativeNFTHistory  = "/v3/native/nft/nfts/%s/%s/history"     // 原生模块查询 NFT 操作记录
)

const (
	RegisterDomain = "/v3/evm/ns/domains"         // 注册域名
	QueryDomain    = "/v3/evm/ns/domains"         // 查询域名
	TransferDomain = "/v3/evm/ns/transfers/%s/%s" // 转让域名
	QueryDomains   = "/v3/evm/ns/domains/%s"      // 查询用户域名
)

const (
	CreateOrder      = "/v3/orders"       // 购买能量值/业务费接口
	QueryOrder       = "/v2/orders/%s"    // 查询能量值/业务费购买结果接口
	QueryOrders      = "/v3/orders"       // 查询能量值/业务费购买结果列表接口
	BatchCreateOrder = "/v3/orders/batch" // 批量购买能量值接口
)

const (
	SetResolves          = "/v3/evm/ns/resolves/%s/%s"      // 设置域名解析
	QueryResolves        = "/v3/evm/ns/resolves/%s"         // 查询域名解析
	SetReverseResolves   = "/v3/evm/ns/reverse-resolves/%s" // 设置域名反向解析
	QueryReverseResolves = "/v3/evm/ns/reverse-resolves/%s" // 查询域名反向解析
)

const (
	QueryTxResult       = "/v3/evm/tx/%s"            // EVM 模块上链交易结果查询接口
	QueryNativeTxResult = "/v3/native/tx/%s"         // 原生模块上链交易结果查询接口
	QueryTxTypes        = "/v3/evm/dict/tx_types"    // EVM 模块查询枚举值列表接口
	QueryNativeTxTypes  = "/v3/native/dict/tx_types" // 原生模块查询枚举值列表接口

)

const (
	CreateUsers = "/v3/users" // 创建钱包用户
	EditUsers   = "/v3/users" // 更新钱包用户
	QueryUsers  = "/v3/users" // 查询钱包用户信息

)

const CodeSpace = "AVATA-SDK"

const (
	CreateRecord = "/v3/native/record/records" // 数字作品存证接口
)

Types

type Accounts

type Accounts struct {
	NativeAddress string `json:"native_address"` // 原生格式地址
	HexAddress    string `json:"hex_address"`    // 以太坊格式地址
	Name          string `json:"name"`           // 链账户名称
	OperationID   string `json:"operation_id"`   // 操作 ID
	ReadOnly      int64  `json:"read_only"`      // 当钱包项目查询到链账户时，返回此字段，字段用于区分是否是当前项目进行创建的链账户 0: 当前钱包创建 1: 其他钱包创建
}

QueryAccountsRes 查询链账户正确返回值

type AvataError

type AvataError struct {
	CodeSpace string `json:"code_space"` // 命名空间
	Code      string `json:"code"`       // 错误码
	Message   string `json:"message"`    // 错误描述
}

Response Avata 错误提示信息

type BaseParams

type BaseParams struct {
	Domain    string // 域名
	APIKey    string // 项目参数 API KEY
	APISecret string // 项目参数 API SECRET
}

BaseParams 初始化 SDK 客户端参数

type BatchCreateAccountsReq

type BatchCreateAccountsReq struct {
	Count       int    `json:"count,omitempty"` // 批量创建链账户的数量
	OperationID string `json:"operation_id"`    // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串。此操作 ID 仅限在查询链账户接口中使用，用于查询创建链账户的授权状态。
}

BatchCreateAccountsReq 批量创建链账户请求参数

type BatchCreateAccountsRes

type BatchCreateAccountsRes struct {
	Data struct {
		Addresses []struct {
			NativeAddress string `json:"native_address"` // iaa 格式链账户
			HexAddress    string `json:"hex_address"`    // Hex 格式链账户
		} `json:"addresses"` // 链账户地址列表
		OperationID string `json:"operation_id"` // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串。此操作 ID 仅限在查询链账户接口中使用，用于查询创建链账户的授权状态。
	} `json:"data"`
}

BatchCreateAccountsRes 批量创建链账户正确返回值

type BatchCreateOrderReq

type BatchCreateOrderReq struct {
	List        []List `json:"list"`         // 充值信息
	OperationID string `json:"operation_id"` // 自定义订单流水号，必需且仅包含数字、下划线及英文字母大/小写
}

BatchCreateOrderReq 批量购买能量值接口请求参数

type BurnMTReq

type BurnMTReq struct {
	Amount      int    `json:"amount,omitempty"` // 销毁的数量
	OperationId string `json:"operation_id"`     // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

BurnMTReq 销毁 MT 请求参数

type BurnNFTReq

type BurnNFTReq struct {
	OperationID string `json:"operation_id"` // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

BurnNFTReq 销毁 EVM 模块 NFT 请求参数

type BurnNativeNFTReq

type BurnNativeNFTReq struct {
	OperationID string `json:"operation_id"` // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

BurnNativeNFTReq 销毁原生模块 NFT 请求参数

type CreateAccountReq

type CreateAccountReq struct {
	Name        string `json:"name,omitempty"` // 链账户名称，支持 1-20 位汉字、大小写字母及数字组成的字符串
	OperationID string `json:"operation_id"`   // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串组成。此操作 ID 仅限在查询链账户接口中使用，用于查询创建链账户的授权状态。
}

CreateAccountReq 创建链账户请求参数

type CreateAccountRes

type CreateAccountRes struct {
	Data struct {
		NativeAddress string `json:"native_address"` // iaa 格式链账户
		HexAddress    string `json:"hex_address"`    // Hex 格式链账户
	} `json:"data"`
}

CreateAccountRes 创建链账户正确返回值

type CreateMTClassReq

type CreateMTClassReq struct {
	Name        string `json:"name"`           // MT 类别名称
	Owner       string `json:"owner"`          // MT 类别权属者地址，支持任一 Avata 平台内合法链账户地址
	Data        string `json:"data,omitempty"` // 自定义链上元数据
	OperationId string `json:"operation_id"`   // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

CreateMTClassReq 创建 MT 类别请求参数

type CreateNFTClassReq

type CreateNFTClassReq struct {
	Name                 string `json:"name"`                              // NFT 类别名称
	Uri                  string `json:"uri,omitempty"`                     // 链外数据链接
	Symbol               string `json:"symbol"`                            // 标识
	Owner                string `json:"owner"`                             // NFT 类别权属者地址，拥有在该 NFT 类别中发行 NFT 的权限和转让该 NFT 类别的权限。 支持任一 Avata 平台内合法链账户地址
	EditableByOwner      int    `json:"editable_by_owner,omitempty"`       // NFT 类别权限的控制功能， 此类别下某一 NFT 的持有者可以编辑该 NFT ：1可编辑 0不可编辑
	EditableByClassOwner int    `json:"editable_by_class_owner,omitempty"` // NFT 类别权限的控制功能， 此 NFT 类别的权属者可以编辑这个类别下所有的 NFT ：1可编辑 0不可编辑
	OperationID          string `json:"operation_id"`                      // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

CreateNFTClassReq 创建 EVM 模块 NFT 类别请求参数

type CreateNativeNFTClassReq

type CreateNativeNFTClassReq struct {
	Name            string `json:"name"`                        // NFT 类别名称
	ClasID          string `json:"clas_id,omitempty"`           // NFT类别ID
	Symbol          string `json:"symbol,omitempty"`            // 标识
	Description     string `json:"description,omitempty"`       // 描述
	Uri             string `json:"uri,omitempty"`               // 链外数据链接
	UriHash         string `json:"uri_hash,omitempty"`          // 链外数据 Hash
	Data            string `json:"data,omitempty"`              // 自定义链上元数据
	EditableByOwner int    `json:"editable_by_owner,omitempty"` // NFT 拥有者是否可编辑 NFT,1可编辑，0不可编辑，默认1
	Owner           string `json:"owner"`                       // NFT 类别权属者地址，拥有在该 NFT 类别中发行 NFT 的权限和转让该 NFT 类别的权限。 支持任一 Avata 平台内合法链账户地址
	OperationID     string `json:"operation_id"`                // 操作 ID，保证幂等性；由接入方生成的唯一的、大小写敏感、不超过 64 个 ASCII 字符的字符串
}

CreateNativeNFTClassReq 创建原生模块 NFT 类别请求参数

type CreateOrderReq

type CreateOrderReq struct {
	Account     string `json:"account"`      // 链账户地址
	Amount      int    `json:"amount"`       // 购买金额 ，只能购买整数元金额；单位：分
	OrderType   int    `json:"order_type"`   // 充值类型：1 gas：能量值；2 business：业务费；Enum: 1   2
	OperationID string `json:"operation_id"` // 自定义订单流水号，必需且仅包含数字、下划线及英文字母大/小写
}

CreateOrderReq 购买能量值/业务费接口请求参数

type CreateRecordReq

type CreateRecordReq struct {
	IdentityType int    `json:"identity_type,omitempty"` // 存证主体；1:个人；2:企业
	IdentityName string `json:"identity_name,omitempty"` // 个人姓名或企业名称，规范如下：个人姓名：长度限制 1-16 个字符（UTF-8 编码），首字符不能是特殊符号；企业名称：长度限制 1-50 个字符（UTF-8 编码），首字符不能是特殊符号；未传入存证主体字段时，不支持此字段；传入存证主体字段时，此字段必填
	IdentityNum  string `json:"identity_num,omitempty"`  // 个人为身份证号码，企业为统一社会信用代码； 未传入存证主体字段时，不支持此字段；传入存证主体字段时，此字段选填
	Type         int    `json:"type"`                    // 作品类型: Enum: 1 2 3 4 5 6 7 8 9 10 11 12 13 14，具体参考接口文档
	Name         string `json:"name"`                    // 作品名称
	Description  string `json:"description"`             // 作品描述
	Hash         string `json:"hash"`                    // 作品哈希；将单个作品源文件使用单向散列函数（如 MD5，SHA 等）进行一次 Hash 计算；将多个作品源文件分别进行一次 Hash 计算，再将得到的 Hash 值进行二次 Hash 计算
	HashType     int    `json:"hash_type"`               // 作品哈希类型 1:其它； 2:SHA256；3:MD5；4:SHA256-PFV；
	OperationId  string `json:"operation_id"`            // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

CreateRecordReq 数字作品存证接口请求参数

type CreateUsersReq

type CreateUsersReq struct {
	UserType           int    `json:"user_type"`           // 用户类型， 对于创建的钱包用户的类型属性 1：个人 2：企业
	Name               string `json:"name"`                // 用户的真实姓名， 支持汉字以及大小写字母、空格
	PhoneNum           string `json:"phone_num"`           // 联系人或授权人手机号
	Region             int    `json:"region"`              // 所属 国家/地区 1：其他 2：中国大陆（默认） 3：中国香港 4：中国台湾
	CertificateType    int    `json:"certificate_type"`    // 用户证件类型 1：身份证（默认） 2：护照
	CertificateNum     string `json:"certificate_num"`     // 用户证件号码
	RegistrationRegion int    `json:"registration_region"` // 企业注册地址 1：其他 2：中国大陆（默认） 3：中国香港 4：中国台湾
	RegistrationNum    string `json:"registration_num"`    // 企业的统一社会信用代码或机构注册号
	BusinessLicense    string `json:"business_license"`    // 营业执照或认证授权人声明书
	Email              string `json:"email"`               // 企业邮箱，不支持汉字以及非规范性特殊字符。
}

type CreateUsersRes

type CreateUsersRes struct {
	Data struct {
		UserID string `json:"user_id"` // 用户唯一标识
		Did    string `json:"did"`     // 用户身份标识(预留字段)
	} `json:"data"`
}

type DataItem

type DataItem struct {
	Data []TxType `json:"data"`
}

QueryNativeTxTypesRes 原生模块查询枚举值列表接口返回值

type EditMTReq

type EditMTReq struct {
	Data        string `json:"data"`         // 自定义链上元数据
	OperationID string `json:"operation_id"` // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

EditMTReq 编辑 MT 请求参数

type EditNFTReq

type EditNFTReq struct {
	Uri         string `json:"uri"`                // 链外数据链接
	UriHash     string `json:"uri_hash,omitempty"` // 链外数据 Hash
	OperationID string `json:"operation_id"`       // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

EditNFTReq 编辑 EVM 模块 NFT 请求参数

type EditNativeNFTReq

type EditNativeNFTReq struct {
	Name        string `json:"name,omitempty"`     // NFT 名称
	Uri         string `json:"uri,omitempty"`      // 链外数据链接
	Data        string `json:"data,omitempty"`     // 自定义链上元数据
	UriHash     string `json:"uri_hash,omitempty"` // 链外数据 Hash
	OperationID string `json:"operation_id"`       // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

EditNativeNFTReq 编辑原生模块 NFT 请求参数

type EditUsersReq

type EditUsersReq struct {
	UserID   string `json:"user_id"`   // 用户唯一标识
	PhoneNum string `json:"phone_num"` // 手机号
}

type Error

type Error interface {
	Error() string
	CodeSpace() string
	Code() string
	Msg() string
}

func InvalidParam

func InvalidParam(message string) Error

func NewAvataError

func NewAvataError(avataError AvataError) Error

func NewSDKError

func NewSDKError(message string) Error

type ErrorRes

type ErrorRes struct {
	// contains filtered or unexported fields
}

ErrorRes Avata 错误提示信息

func (ErrorRes) Code

func (e ErrorRes) Code() string

func (ErrorRes) CodeSpace

func (e ErrorRes) CodeSpace() string

func (ErrorRes) Error

func (e ErrorRes) Error() string

func (ErrorRes) Msg

func (e ErrorRes) Msg() string

type IssueMTReq

type IssueMTReq struct {
	Data        string `json:"data,omitempty"`      // 自定义链上元数据
	Amount      int    `json:"amount,omitempty"`    // MT 数量，不填写数量时，默认发行数量为 1
	Recipient   string `json:"recipient,omitempty"` // MT 接收者地址，支持任一文昌链合法链账户地址，默认为 MT 类别的权属者地址
	OperationID string `json:"operation_id"`        // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

IssueMTReq 发行 MT 请求参数

type KindRes

type KindRes struct {
	Kind string `json:"kind"` // 区分服务，native / evm
}

type List

type List struct {
	Account string `json:"account"` // 链账户地址
	Amount  int    `json:"amount"`  // 购买金额 ，只能购买整数元金额；单位：分
}

BatchCreateOrderReq 批量购买能量值接口请求参数

type MTMsg

type MTMsg struct {
	ID        string `json:"id"`        // MT 类别 ID
	Name      string `json:"name"`      // MT 类别名称
	ClassID   string `json:"class_id"`  // MT 类别 ID
	Amount    string `json:"amount"`    // 发行数量
	Recipient string `json:"recipient"` // 接收者地址
	ClassName string `json:"class"`     // MT 类别名称
}

type MintMTReq

type MintMTReq struct {
	Amount      int    `json:"amount,omitempty"` // MT 数量
	Recipient   string `json:"recipient"`        // MT 接收者地址
	OperationID string `json:"operation_id"`     // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

MintMTReq 增发 MT 请求参数

type MintNFTReq

type MintNFTReq struct {
	Uri         string `json:"uri"`                // 链外数据链接
	UriHash     string `json:"uri_hash,omitempty"` // 链外数据 Hash
	Recipient   string `json:"recipient"`          // NFT 接收者地址，支持任一文昌链合法链账户地址，默认为 NFT 类别的权属者地址
	OperationID string `json:"operation_id"`       // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

MintNFTReq 发行 EVM 模块 NFT 请求参数

type MintNativeNFTReq

type MintNativeNFTReq struct {
	Name        string `json:"name,omitempty"`      // NFT 名称
	Uri         string `json:"uri,omitempty"`       // 链外数据链接
	UriHash     string `json:"uri_hash,omitempty"`  // 链外数据 Hash
	Data        string `json:"data,omitempty"`      // 自定义链上元数据
	Recipient   string `json:"recipient,omitempty"` // NFT 接收者地址，支持任一文昌链合法链账户地址，默认为 NFT 类别的权属者地址
	OperationID string `json:"operation_id"`        // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

MintNativeNFTReq 发行原生模块 NFT 请求参数

type Mt

type Mt struct {
	ClassId string `json:"class_id,omitempty"` // MT 类别 ID
	MtId    string `json:"mt_id,omitempty"`    // MT ID
}

Mt 回调返回的 MT 相关参数（不同版本通用）

type NFTMsg

type NFTMsg struct {
	ID        string `json:"id"`        // NFT 类别 ID
	URI       string `json:"uri"`       // 链外数据链接
	Name      string `json:"name"`      // NFT 类别名称
	ClassID   string `json:"class_id"`  // NFT 类别 ID
	Symbol    string `json:"symbol"`    // NFT 类别标识
	Recipient string `json:"recipient"` // 接收者地址
}

type NftEVM

type NftEVM struct {
	ClassId string `json:"class_id,omitempty"` // 类别 ID
	Id      int64  `json:"id,omitempty"`       // NFT ID
}

NftEVM V2 及以上版本回调返回的 EVM 模块 NFT 相关参数

type NftNative

type NftNative struct {
	ClassId string `json:"class_id,omitempty"` // 类别 ID
	Id      string `json:"id,omitempty"`       // NFT ID
}

NftNative V2 及以上版本回调返回的原生模块 NFT 相关参数

type NftV1

type NftV1 struct {
	ClassId string `json:"class_id,omitempty"` // 类别 ID
	NftId   string `json:"nft_id,omitempty"`   // NFT ID
}

NftV1 V1 版本回调返回的 NFT 相关参数

type OnCallbackResEVM

type OnCallbackResEVM struct {
	Kind        string `json:"kind"`                   // 区分服务，native / evm
	OperationId string `json:"operation_id"`           // 操作 ID
	Module      int32  `json:"module"`                 // 交易模块
	Operation   int32  `json:"operation"`              // 用户操作类型
	TxHash      string `json:"tx_hash,omitempty"`      // 交易哈希
	Status      int32  `json:"status"`                 // 交易状态，1 成功; 2 失败
	Message     string `json:"message,omitempty"`      // 交易失败的错误描述信息
	BlockHeight int64  `json:"block_height,omitempty"` // 交易上链的区块高度
	Timestamp   string `json:"timestamp,omitempty"`    // 交易上链时间（UTC 时间）
	Nft         NftEVM `json:"nft,omitempty"`          // 对应不同操作类型的消息体
}

OnCallbackResEVM V2 及以上版本 EVM 模块接口回调服务参数

type OnCallbackResNative

type OnCallbackResNative struct {
	Kind        string    `json:"kind"`                   // 区分服务，native / evm
	OperationId string    `json:"operation_id"`           // 操作 ID
	Module      int32     `json:"module"`                 // 交易模块
	Operation   int32     `json:"operation"`              // 用户操作类型
	TxHash      string    `json:"tx_hash,omitempty"`      // 交易哈希
	Status      int32     `json:"status"`                 // 交易状态，1 成功; 2 失败
	Message     string    `json:"message,omitempty"`      // 交易失败的错误描述信息
	BlockHeight int64     `json:"block_height,omitempty"` // 交易上链的区块高度
	Timestamp   string    `json:"timestamp,omitempty"`    // 交易上链时间（UTC 时间）
	Nft         NftNative `json:"nft,omitempty"`          // 对应不同操作类型的消息体
	Mt          Mt        `json:"mt,omitempty"`           // 对应不同操作类型的消息体
	Record      Record    `json:"record,omitempty"`       // 对应不同操作类型的消息体
}

OnCallbackResNative AVATA Open API V2 及以上版本 Native 模块接口回调服务参数

type OnCallbackResV1

type OnCallbackResV1 struct {
	OperationId string `json:"operation_id"`           // 操作 ID
	Module      string `json:"module"`                 // 交易模块
	Type        string `json:"type"`                   // 用户操作类型
	Status      int32  `json:"status"`                 // 交易状态，1 成功; 2 失败
	TxHash      string `json:"tx_hash,omitempty"`      // 交易哈希
	Message     string `json:"message,omitempty"`      // 交易失败的错误描述信息
	BlockHeight int64  `json:"block_height,omitempty"` // 交易上链的区块高度
	Timestamp   string `json:"timestamp,omitempty"`    // 交易上链时间（UTC 时间）
	Nft         string `json:"nft,omitempty"`          // 对应不同操作类型的消息体
	Mt          string `json:"mt,omitempty"`           // 对应不同操作类型的消息体
	Record      string `json:"record,omitempty"`       // 对应不同操作类型的消息体
}

OnCallbackResV1 AVATA Open API V1 版本回调服务参数

type OperationRecord

type OperationRecord struct {
	TxHash    string `json:"tx_hash"`    // 操作 Tx Hash
	Module    int64  `json:"module"`     // 功能模块；Enum: "nft" "mt"
	Operation int64  `json:"operation"`  // 操作类型；Enum: "issue_class" "transfer_class" "mint" "edit" "transfer" "burn" "issue"
	Signer    string `json:"signer"`     // Tx 签名者地址
	TimeStamp string `json:"time_stamp"` // 操作时间戳（UTC 时间）
	NFTMsg    NFTMsg `json:"nft_msg"`    // 具体参考接口文档
}

type OperationRecords

type OperationRecords struct {
	TxHash    string `json:"tx_hash"`    // 操作 Tx Hash
	Module    int64  `json:"module"`     // 功能模块；Enum: "nft" "mt"
	Operation int64  `json:"operation"`  // 操作类型；Enum: "issue_class" "transfer_class" "mint" "edit" "transfer" "burn" "issue"
	Signer    string `json:"signer"`     // Tx 签名者地址
	TimeStamp string `json:"time_stamp"` // 操作时间戳（UTC 时间）
	NFTMsg    NFTMsg `json:"nft_msg"`    // 具体参考接口文档
	MTMsg     MTMsg  `json:"mt_msg"`     // 具体参考接口文档
}

type OrderRes

type OrderRes struct {
	Data struct {
	} `json:"data"`
}

OrderRes 购买能量值/业务费接口返回值/批量购买能量值接口返回值

type QueryAccountsHistoryReq

type QueryAccountsHistoryReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 分页数据的 Key，Avata 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	Account    string `json:"account,omitempty"`     // 链账户地址
	Module     string `json:"module,omitempty"`      // 功能模块；Enum: "nft" "mt"
	Operation  string `json:"operation,omitempty"`   // 操作类型，仅 module 不为空时有效，默认为 "all"。 module = nft 时，可选：issue_class / transfer_class / mint / edit / transfer / burn； module = mt 时，可选： issue_class / transfer_class / issue / mint / edit / transfer / burn。
	TxHash     string `json:"tx_hash,omitempty"`     // Tx Hash
	StartDate  string `json:"start_date,omitempty"`  // 日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // 日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total,omitempty"` //　是否查询数据的总数量 0：不查询总数（默认）1：查询总数
}

QueryAccountsHistoryReq 查询链账户操作记录请求参数

type QueryAccountsHistoryRes

type QueryAccountsHistoryRes struct {
	Data struct {
		PrevPageKey     string            `json:"prev_page_key"`     // 上一页数据的 Key，Avata 会根据该值进行上一页数据的查询
		NextPageKey     string            `json:"next_page_key"`     // 下一页数据的 Key，Avata 会根据该值进行下一页数据的查询
		Limit           int64             `json:"limit"`             // 每页记录数
		TotalCount      int64             `json:"total_count"`       // 总记录数
		OperationRecord []OperationRecord `json:"operation_records"` // 操作记录列表
	} `json:"data"`
}

QueryAccountsHistoryRes 查询 EVM 模块链账户操作记录返回值

type QueryAccountsReq

type QueryAccountsReq struct {
	PageKey     string `json:"page_key,omitempty"`     // 分页数据的 Key，Avata 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit       string `json:"limit,omitempty"`        // 每页记录数，默认为 10，上限为 50
	Account     string `json:"account,omitempty"`      // 链账户地址
	Name        string `json:"name,omitempty"`         // 链账户名称，支持模糊查询
	OperationID string `json:"operation_id,omitempty"` // 操作 ID。此操作 ID 需要填写在请求创建链账户/批量创建链账户接口时，返回的 Operation ID。
	StartDate   string `json:"start_date,omitempty"`   // 创建日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate     string `json:"end_date,omitempty"`     // 创建日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy      string `json:"sort_by,omitempty"`      // 排序规则：DATE_ASC / DATE_DESC
	CountTotal  string `json:"count_total,omitempty"`  // 是否查询数据的总数量 0：不查询总数（默认）1：查询总数

}

QueryAccountsReq 查询链账户请求参数

type QueryAccountsRes

type QueryAccountsRes struct {
	Data struct {
		PrevPageKey string     `json:"prev_page_key"` // 上一页数据的 Key，Avata 会根据该值进行上一页数据的查询
		NextPageKey string     `json:"next_page_key"` // 下一页数据的 Key，Avata 会根据该值进行下一页数据的查询
		Limit       int64      `json:"limit"`         // 每页记录数
		TotalCount  int64      `json:"total_count"`   // 总记录数
		Accounts    []Accounts `json:"accounts"`      // 链账户列表
	} `json:"data"`
}

QueryAccountsRes 查询链账户正确返回值

type QueryContractReq

type QueryContractReq struct {
	To   string `json:"to"`   // 合约地址
	Data string `json:"data"` // ABI 编码待签名交易的 hex 字符串
}

QueryContractReq 查询合约请求参数

type QueryContractRes

type QueryContractRes struct {
	Data struct {
		Result string `json:"result"` //合约调用结果 hex 字符串
	} `json:"data"`
}

QueryContractRes 查询合约返回值

type QueryDomainReq

type QueryDomainReq struct {
	Name string `json:"name"`          // 域名关键字
	Tld  string `json:"tld,omitempty"` // 根域名
}

QueryDomainReq 查询域名请求参数

type QueryDomainRes

type QueryDomainRes struct {
	Data struct {
		Domains []struct {
			Name            string `json:"name"`                       // 一级域名
			Status          int    `json:"status"`                     // 当前域名状态
			Owner           string `json:"owner,omitempty"`            // 当前域名拥有者的链账户地址
			Expire          int    `json:"expire"`                     // 当前域名过期状态
			ExpireTimestamp int    `json:"expire_timestamp,omitempty"` // 当前域名过期时间戳
			Msg             string `json:"msg,omitempty"`              // 提示信息
		} `json:"domains"`
	} `json:"data"`
}

QueryDomainRes 查询域名返回结果

type QueryDomainsReq

type QueryDomainsReq struct {
	Name string `json:"name"`          // 域名关键字
	Tld  string `json:"tld,omitempty"` // 根域名
}

QueryDomainsReq 查询用户域名请求参数

type QueryDomainsRes

type QueryDomainsRes struct {
	Data struct {
		Domains []struct {
			Name            string `json:"name"`             // 一级域名， 如：test.wallet
			Status          int    `json:"status"`           // 当前域名状态 0：未注册； 1：已注册；
			Owner           string `json:"owner"`            // 当前域名拥有者的链账户地址
			Expire          int    `json:"expire"`           // 当前域名过期状态 0 ：未过期； 1：已过期
			ExpireTimestamp int    `json:"expire_timestamp"` // 当前域名过期时间戳
			Msg             string `json:"msg"`              // 提示信息
		} `json:"domains"`
	} `json:"data"`
}

QueryDomainsRes 查询用户域名返回值

type QueryMTBalanceReq

type QueryMTBalanceReq struct {
	PageKey    string `json:"offset,omitempty"`      // 游标，默认为 0
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	ID         string `json:"id,omitempty"`          // MT ID
	CountTotal string `json:"count_total,omitempty"` // 是否查询数据的总数量 0：不查询总数（默认） 1：查询总数
}

QueryMTBalanceReq 查询 MT 余额请求参数

type QueryMTBalanceRes

type QueryMTBalanceRes struct {
	Data struct {
		PrevPageKey string `json:"prev_page_key"` // 游标
		NextPageKey string `json:"next_page_key"` // 游标
		Limit       int    `json:"limit"`         // 每页记录数
		TotalCount  int    `json:"total_count"`   // 总记录数
		Mts         []struct {
			Id     string `json:"id,omitempty"`     // MT ID
			Amount int    `json:"amount,omitempty"` // MT 数量
		} `json:"mts"`
	} `json:"data"`
}

QueryMTBalanceRes 查询 MT 余额返回值

type QueryMTClassRes

type QueryMTClassRes struct {
	Data struct {
		Id        string `json:"id"`             // MT 类别 ID
		Name      string `json:"name"`           // MT 类别名称
		Data      string `json:"data,omitempty"` // 自定义链上元数据
		MtCount   int    `json:"mt_count"`       // MT 类别包含的 MT 总量(AVATA 平台内)
		Owner     string `json:"owner"`          // MT 类别权属者地址
		TxHash    string `json:"tx_hash"`        // 创建 MT 类别的 Tx Hash
		Timestamp string `json:"timestamp"`      // 创建 MT 类别的时间戳（UTC 时间）
	} `json:"data,omitempty"`
}

QueryMTClassRes 查询 MT 类别详情返回值

type QueryMTClassesReq

type QueryMTClassesReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 游标，默认为 0
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	ID         string `json:"id,omitempty"`          // MT 类别 ID
	Name       string `json:"name,omitempty"`        // MT 类别名称，支持模糊查询
	Owner      string `json:"owner,omitempty"`       // MT 类别权属者地址
	TxHash     string `json:"tx_hash,omitempty"`     // 创建 MT 类别的 Tx Hash
	StartDate  string `json:"start_date,omitempty"`  // MT 类别创建日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // MT 类别创建日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total,omitempty"` // 是否查询数据的总数量 0：不查询总数（默认） 1：查询总数
}

QueryMTClassesReq 查询 MT 类别请求参数

type QueryMTClassesRes

type QueryMTClassesRes struct {
	Data struct {
		PrevPageKey string `json:"prev_page_key"` // 游标
		NextPageKey string `json:"next_page_key"` // 游标
		Limit       int    `json:"limit"`         // 每页记录数
		TotalCount  int    `json:"total_count"`   // 总记录数
		Classes     []struct {
			Id        string `json:"id"`        // MT 类别 ID
			Name      string `json:"name"`      // MT 类别名称
			MtCount   int    `json:"mt_count"`  // MT 类别包含的 MT 总量(AVATA 平台内)
			Owner     string `json:"owner"`     // MT 类别权属者地址
			TxHash    string `json:"tx_hash"`   // 创建 MT 类别的 Tx Hash
			Timestamp string `json:"timestamp"` // 创建 MT 类别的时间戳（UTC 时间）
		} `json:"classes"` // 类别列表
	} `json:"data"`
}

QueryMTClassesRes 查询 MT 类别返回值

type QueryMTHistoryReq

type QueryMTHistoryReq struct {
	PageKey    string `json:"offset,omitempty"`     // 游标，默认为 0
	Limit      string `json:"limit,omitempty"`      // 每页记录数，默认为 10，上限为 50
	Signer     string `json:"signer,omitempty"`     // Tx 签名者地址
	TxHash     string `json:"tx_hash,omitempty"`    // MT 操作 Tx Hash
	Operation  string `json:"operation,omitempty"`  // 操作类型： issue(首发MT) / mint(增发MT) / edit(编辑MT) / transfer(转让MT) / burn(销毁MT)
	StartDate  string `json:"start_date,omitempty"` // MT 操作日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`   // MT 操作日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`    // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total,omitempty"`
}

QueryMTHistoryReq 查询 MT 操作记录请求参数

type QueryMTHistoryRes

type QueryMTHistoryRes struct {
	Data struct {
		PrevPageKey      string `json:"prev_page_key"` // 游标
		NextPageKey      string `json:"next_page_key"` // 游标
		Limit            int    `json:"limit"`         // 每页记录数
		TotalCount       int    `json:"total_count"`   // 总记录数
		OperationRecords []struct {
			TxHash    string `json:"tx_hash"`             // MT 操作的 Tx Hash
			Operation int    `json:"operation"`           // MT 操作类型；Enum: "issue" "mint" "edit" "transfer" "burn"
			Signer    string `json:"signer"`              // Tx 签名者地址
			Recipient string `json:"recipient,omitempty"` // MT 接收者地址
			Amount    int    `json:"amount,omitempty"`    // MT 操作数量
			Timestamp string `json:"timestamp"`           // MT 操作时间戳（UTC 时间）
		} `json:"operation_records"`
	} `json:"data,omitempty"`
}

QueryMTHistoryRes 查询 MT 操作记录返回值

type QueryMTRes

type QueryMTRes struct {
	Data struct {
		Id         string `json:"id"`          // MT ID
		ClassId    string `json:"class_id"`    // MT 类别 ID
		ClassName  string `json:"class_name"`  // MT 类别名称
		Data       string `json:"data"`        // 自定义链上元数据
		OwnerCount int    `json:"owner_count"` // MT 拥有者数量(AVATA 平台内)
		IssueData  struct {
			Issuer    string `json:"issuer"`    // 首次发行该 MT 的链账户地址
			Timestamp string `json:"timestamp"` // 首次发行该 MT 的时间戳
			Count     int    `json:"count"`     // 首次发行该 MT 的数量
			TxHash    string `json:"tx_hash"`   // 首次发行该 MT 的交易哈希
		} `json:"issue_data"`
		MtCount   int `json:"mt_count"`   // MT 流通总量(全链)
		MintTimes int `json:"mint_times"` // MT 发行次数(AVATA 平台内累计发行次数(包括首次发行和增发))
	} `json:"data"`
}

QueryMTRes 查询 MT 详情返回值

type QueryMTsReq

type QueryMTsReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 游标，默认为 0
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	ID         string `json:"id,omitempty"`          // MT ID
	ClassID    string `json:"class_id,omitempty"`    // MT 类别 ID
	Issuer     string `json:"issuer,omitempty"`      // MT 发行者地址
	TxHash     string `json:"tx_hash,omitempty"`     // 创建 MT 的 TX Hash
	StartDate  string `json:"start_date,omitempty"`  // MT 创建日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // MT 创建日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total,omitempty"` //是否查询数据的总数量 0：不查询总数（默认） 1：查询总数
}

QueryMTsReq 查询 MT 请求参数

type QueryMTsRes

type QueryMTsRes struct {
	Data struct {
		PrevPageKey string `json:"prev_page_key"` // 游标
		NextPageKey string `json:"next_page_key"` // 游标
		Limit       int    `json:"limit"`         // 每页记录数
		TotalCount  int    `json:"total_count"`   // 总记录数
		Mts         []struct {
			Id         string `json:"id"`                    // MT ID
			ClassId    string `json:"class_id"`              // MT 类别 ID
			ClassName  string `json:"class_name"`            // MT 类别名称
			Issuer     string `json:"issuer"`                // 首次发行该 MT 的链账户地址
			OwnerCount int    `json:"owner_count,omitempty"` // MT 拥有者数量(AVATA 平台内)
			Timestamp  string `json:"timestamp"`             // MT 首次发行时间戳（UTC 时间）
		} `json:"mts,omitempty"`
	} `json:"data,omitempty"`
}

QueryMTsRes 查询 MT 返回值

type QueryNFTClassRes

type QueryNFTClassRes struct {
	Data struct {
		ID                   string `json:"id"`                      // NFT 类别 ID
		Name                 string `json:"name"`                    // NFT 类别名称
		Uri                  string `json:"uri,omitempty"`           // 链外数据链接
		Symbol               string `json:"symbol"`                  // NFT 类别标识
		NftCount             int    `json:"nft_count"`               // NFT 类别包含的 NFT 总量
		Owner                string `json:"owner"`                   // NFT 类别权属者地址
		EditableByOwner      int    `json:"editable_by_owner"`       // NFT 类别权限的控制功能， 此类别下某一 NFT 的持有者可以编辑该 NFT ：1可编辑 0不可编辑
		EditableByClassOwner int    `json:"editable_by_class_owner"` // NFT 类别权限的控制功能， 此 NFT 类别的权属者可以编辑这个类别下所有的 NFT 1：可编辑 0：不可编辑（默认）
		TxHash               string `json:"tx_hash"`                 // 创建 NFT 类别的 Tx Hash
		TimeStamp            string `json:"timestamp"`               // 创建 NFT 类别的时间戳（UTC 时间）
	} `json:"data"`
}

QueryNFTClassRes 查询 EVM 模块 NFT 类别详情返回值

type QueryNFTClassesReq

type QueryNFTClassesReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 分页数据的 Key，AVATA 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	ID         string `json:"id,omitempty"`          // NFT 类别 ID
	Name       string `json:"name,omitempty"`        // NFT 类别名称，支持模糊查询
	Owner      string `json:"owner,omitempty"`       // NFT 类别权属者地址
	TxHash     string `json:"tx_hash,omitempty"`     // 创建 NFT 类别的 Tx Hash
	StartDate  string `json:"start_date,omitempty"`  // NFT 类别创建日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // NFT 类别创建日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total,omitempty"` // 是否查询数据的总数量0：不查询总数（默认）1：查询总数
}

QueryNFTClassesReq 查询 EVM 模块 NFT 类别请求参数

type QueryNFTClassesRes

type QueryNFTClassesRes struct {
	Data struct {
		PrevPageKey string `json:"prev_page_key"` // 上一页数据的 Key，AVATA 会根据该值进行上一页数据的查询
		NextPageKey string `json:"next_page_key"` // 下一页数据的 Key，AVATA 会根据该值进行下一页数据的查询
		Limit       int    `json:"limit"`         // 每页记录数
		TotalCount  int    `json:"total_count"`   // 总记录数
		Classes     []struct {
			ID        string `json:"id"`        // NFT 类别 ID
			Name      string `json:"name"`      // NFT 类别名称
			Uri       string `json:"uri"`       // 链外数据链接
			Symbol    string `json:"symbol"`    // NFT 类别标识
			Owner     string `json:"owner"`     // NFT 类别权属者地址
			TxHash    string `json:"tx_hash"`   // 创建 NFT 类别的 Tx Hash
			TimeStamp string `json:"timestamp"` // 创建 NFT 类别的时间戳（UTC 时间）
		} `json:"classes"`
	} `json:"data"`
}

QueryNFTClassesRes 查询 EVM 模块 NFT 类别返回值

type QueryNFTHistoryReq

type QueryNFTHistoryReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 分页数据的 Key，AVATA 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	Signer     string `json:"signer,omitempty"`      // Tx 签名者地址
	TxHash     string `json:"tx_hash,omitempty"`     // NFT 操作 Tx Hash
	Operation  string `json:"operation,omitempty"`   // 操作类型：mint / edit / transfer / burn
	StartDate  string `json:"start_date,omitempty"`  // NFT 操作日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // NFT 操作日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total,omitempty"` //是否查询数据的总数量0：不查询总数（默认）1：查询总数
}

QueryNFTHistoryReq 查询 EVM 模块 NFT 操作记录请求参数

type QueryNFTHistoryRes

type QueryNFTHistoryRes struct {
	Data struct {
		PrevPageKey      string `json:"prev_page_key"` // 上一页数据的 Key，AVATA 会根据该值进行上一页数据的查询
		NextPageKey      string `json:"next_page_key"` // 下一页数据的 Key，AVATA 会根据该值进行下一页数据的查询
		Limit            int    `json:"limit"`         // 每页记录数
		TotalCount       int    `json:"total_count"`   // 总记录数
		OperationRecords []struct {
			TxHash    string `json:"tx_hash,omitempty"`   // NFT 操作的 Tx Hash
			Operation int    `json:"operation,omitempty"` // NFT 操作类型；Enum: "mint" "edit" "transfer" "burn"
			Signer    string `json:"signer,omitempty"`    // Tx 签名者地址
			Recipient string `json:"recipient,omitempty"` // NFT 接收者地址
			TimeStamp string `json:"timestamp,omitempty"` // NFT 操作时间戳（UTC 时间）
		} `json:"operation_records"`
	} `json:"data"`
}

QueryNFTHistoryRes 查询 EVM 模块 NFT 操作记录返回值

type QueryNFTRes

type QueryNFTRes struct {
	Data struct {
		ID          int    `json:"id"`           // NFT ID
		ClassID     string `json:"class_id"`     // NFT 类别 ID
		ClassName   string `json:"class_name"`   // NFT 类别名称
		ClassSymbol string `json:"class_symbol"` // NFT 类别标识
		Uri         string `json:"uri"`          // 链外数据链接
		UriHash     string `json:"uri_hash"`     // 链外数据 Hash
		Owner       string `json:"owner"`        // NFT 持有者地址
		Status      int    `json:"status"`       // NFT 状态：active / burned;
		TxHash      string `json:"tx_hash"`      // NFT 发行 Tx Hash
		TimeStamp   string `json:"timestamp"`    // NFT 发行时间戳（UTC 时间）
	} `json:"data"`
}

QueryNFTRes 查询 EVM 模块 NFT 详情返回值

type QueryNFTsReq

type QueryNFTsReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 分页数据的 Key，AVATA 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	ID         string `json:"id,omitempty"`          // NFT ID
	ClassID    string `json:"class_id,omitempty"`    // NFT 类别 ID
	Owner      string `json:"owner,omitempty"`       // NFT 持有者地址
	TxHash     string `json:"tx_hash,omitempty"`     // 创建 NFT 的 Tx Hash
	Status     string `json:"status,omitempty"`      // NFT 状态 1：active 2：burned
	StartDate  string `json:"start_date,omitempty"`  // NFT 创建日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // NFT 创建日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total,omitempty"` // 是否查询数据的总数量0：不查询总数（默认）1：查询总数
}

QueryNFTsReq 查询 EVM 模块 NFT 请求参数

type QueryNFTsRes

type QueryNFTsRes struct {
	Data struct {
		PrevPageKey string `json:"prev_page_key"`         // 上一页数据的 Key，AVATA 会根据该值进行上一页数据的查询
		NextPageKey string `json:"next_page_key"`         // 下一页数据的 Key，AVATA 会根据该值进行下一页数据的查询
		Limit       int    `json:"limit"`                 // 每页记录数
		TotalCount  int    `json:"total_count,omitempty"` // 总记录数
		NFTs        []struct {
			ID          int    `json:"id"`                 // NFT ID
			ClassID     string `json:"class_id"`           // NFT 类别 ID
			ClassName   string `json:"class_name"`         // NFT 类别名称
			ClassSymbol string `json:"class_symbol"`       // NFT 类别标识
			Uri         string `json:"uri"`                // 链外数据链接
			UriHash     string `json:"uri_hash,omitempty"` // 链外数据 Hash
			Owner       string `json:"owner"`              // NFT 持有者地址
			Status      int    `json:"status"`             // NFT 状态 1：active 2：burned
			TxHash      string `json:"tx_hash"`            // NFT 发行 Tx Hash
			TimeStamp   string `json:"timestamp"`          // NFT 发行时间戳（UTC 时间）
		} `json:"nfts,omitempty"` // NFT 列表
	} `json:"data"`
}

QueryNFTsRes 查询 EVM 模块 NFT 返回值

type QueryNativeAccountsHistoryReq

type QueryNativeAccountsHistoryReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 分页数据的 Key，Avata 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	Account    string `json:"account,omitempty"`     // 链账户地址
	Module     string `json:"module,omitempty"`      // 功能模块；Enum: "nft" "mt"
	Operation  string `json:"operation,omitempty"`   // 操作类型，仅 module 不为空时有效，默认为 "all"。 module = nft 时，可选：issue_class / transfer_class / mint / edit / transfer / burn； module = mt 时，可选： issue_class / transfer_class / issue / mint / edit / transfer / burn。
	TxHash     string `json:"tx_hash,omitempty"`     // Tx Hash
	StartDate  string `json:"start_date,omitempty"`  // 日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // 日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total,omitempty"` //　是否查询数据的总数量 0：不查询总数（默认）1：查询总数
}

QueryNativeAccountsHistoryReq 查询原生模块链账户操作记录请求参数

type QueryNativeAccountsHistoryRes

type QueryNativeAccountsHistoryRes struct {
	Data struct {
		PrevPageKey      string             `json:"prev_page_key"`     // 上一页数据的 Key，Avata 会根据该值进行上一页数据的查询
		NextPageKey      string             `json:"next_page_key"`     // 下一页数据的 Key，Avata 会根据该值进行下一页数据的查询
		Limit            int64              `json:"limit"`             // 每页记录数
		TotalCount       int64              `json:"total_count"`       // 总记录数
		OperationRecords []OperationRecords `json:"operation_records"` // 操作记录列表
	} `json:"data"`
}

QueryNativeAccountsHistoryRes 查询原生模块链账户操作记录返回值

type QueryNativeNFTClassRes

type QueryNativeNFTClassRes struct {
	Data struct {
		ID              string `json:"id,omitempty"`                // NFT 类别 ID
		Name            string `json:"name,omitempty"`              // NFT 类别名称
		Symbol          string `json:"symbol,omitempty"`            // NFT 类别标识
		Description     string `json:"description,omitempty"`       // NFT 类别描述
		NftCount        int    `json:"nft_count,omitempty"`         // NFT 类别包含的 NFT 总量
		Uri             string `json:"uri,omitempty"`               // 链外数据链接
		UriHash         string `json:"uri_hash,omitempty"`          // 链外数据 Hash
		Data            string `json:"data,omitempty"`              // 自定义链上元数据
		Owner           string `json:"owner,omitempty"`             // NFT 类别权属者地址
		TxHash          string `json:"tx_hash,omitempty"`           // 创建 NFT 类别的 Tx Hash
		TimeStamp       string `json:"timestamp,omitempty"`         // 创建 NFT 类别的时间戳（UTC 时间）
		EditableByOwner int    `json:"editable_by_owner,omitempty"` // NFT 类别权限的控制功能， 此类别下某一 NFT 的持有者可以编辑该 NFT ：1可编辑 0不可编辑
	} `json:"data"`
}

QueryNativeNFTClassRes 查询原生模块 NFT 类别详情返回值

type QueryNativeNFTClassesReq

type QueryNativeNFTClassesReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 分页数据的 Key，AVATA 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	ID         string `json:"id,omitempty"`          // NFT 类别 ID
	Name       string `json:"name,omitempty"`        // NFT 类别名称，支持模糊查询
	Owner      string `json:"owner,omitempty"`       // NFT 类别权属者地址
	TxHash     string `json:"tx_hash,omitempty"`     // 创建 NFT 类别的 Tx Hash
	StartDate  string `json:"start_date,omitempty"`  // NFT 类别创建日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // NFT 类别创建日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total,omitempty"` // 是否查询数据的总数量0：不查询总数（默认）1：查询总数
}

QueryNativeNFTClassesReq 查询原生模块 NFT 类别请求参数

type QueryNativeNFTClassesRes

type QueryNativeNFTClassesRes struct {
	Data struct {
		PrevPageKey string `json:"prev_page_key"` // 上一页数据的 Key，AVATA 会根据该值进行上一页数据的查询
		NextPageKey string `json:"next_page_key"` // 下一页数据的 Key，AVATA 会根据该值进行下一页数据的查询
		Limit       int    `json:"limit"`         // 每页记录数
		TotalCount  int    `json:"total_count"`   // 总记录数
		Classes     []struct {
			ID        string `json:"id"`               // NFT 类别 ID
			Name      string `json:"name"`             // NFT 类别名称
			Symbol    string `json:"symbol,omitempty"` // NFT 类别标识
			Uri       string `json:"uri"`              // 链外数据链接
			Owner     string `json:"owner"`            // NFT 类别权属者地址
			TxHash    string `json:"tx_hash"`          // 创建 NFT 类别的 Tx Hash
			TimeStamp string `json:"timestamp"`        // 创建 NFT 类别的时间戳（UTC 时间）
		} `json:"classes"`
	} `json:"data"`
}

QueryNativeNFTClassesRes 查询原生模块 NFT 类别返回值

type QueryNativeNFTHistoryReq

type QueryNativeNFTHistoryReq struct {
	PageKey    string `json:"page_key,omitempty"`   // 分页数据的 Key，AVATA 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit      string `json:"limit,omitempty"`      // 每页记录数，默认为 10，上限为 50
	Signer     string `json:"signer,omitempty"`     // Tx 签名者地址
	TxHash     string `json:"tx_hash,omitempty"`    // NFT 操作 Tx Hash
	Operation  string `json:"operation,omitempty"`  // 操作类型：mint / edit / transfer / burn
	StartDate  string `json:"start_date,omitempty"` // NFT 操作日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`   // NFT 操作日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`    // 排序规则：DATE_ASC / DATE_DESC
	CountTotal string `json:"count_total"`          // 是否查询数据的总数量0：不查询总数（默认）1：查询总数
}

QueryNativeNFTHistoryReq 查询原生模块 NFT 操作记录请求参数

type QueryNativeNFTHistoryRes

type QueryNativeNFTHistoryRes struct {
	Data struct {
		PrevPageKey      string `json:"prev_page_key"`         // 上一页数据的 Key，AVATA 会根据该值进行上一页数据的查询
		NextPageKey      string `json:"next_page_key"`         // 下一页数据的 Key，AVATA 会根据该值进行下一页数据的查询
		Limit            int    `json:"limit"`                 // 每页记录数
		TotalCount       int    `json:"total_count,omitempty"` // 总记录数
		OperationRecords []struct {
			TxHash    string `json:"tx_hash,omitempty"`   // NFT 操作的 Tx Hash
			Operation int    `json:"operation,omitempty"` // NFT 操作类型；Enum: "mint" "edit" "transfer" "burn"
			Signer    string `json:"signer,omitempty"`    // Tx 签名者地址
			Recipient string `json:"recipient,omitempty"` // NFT 接收者地址
			TimeStamp string `json:"timestamp,omitempty"` // NFT 操作时间戳（UTC 时间）
		} `json:"operation_records,omitempty"`
	} `json:"data"`
}

QueryNativeNFTHistoryRes 查询原生模块 NFT 操作记录返回值

type QueryNativeNFTRes

type QueryNativeNFTRes struct {
	Data struct {
		ID          string `json:"id"`                     // NFT ID
		Name        string `json:"name"`                   // NFT 名称
		ClassID     string `json:"class_id"`               // NFT 类别 ID
		ClassName   string `json:"class_name"`             // NFT 类别名称
		ClassSymbol string `json:"class_symbol,omitempty"` // NFT 类别标识
		Uri         string `json:"uri,omitempty"`          // 链外数据链接
		UriHash     string `json:"uri_hash,omitempty"`     // 链外数据 Hash
		Data        string `json:"data,omitempty"`         // 自定义链上元数据
		Owner       string `json:"owner"`                  // NFT 持有者地址
		Status      int    `json:"status"`                 // NFT 状态：active / burned;
		TxHash      string `json:"tx_hash"`                // NFT 发行 Tx Hash
		TimeStamp   string `json:"timestamp"`              // NFT 发行时间戳（UTC 时间）
	} `json:"data"`
}

QueryNativeNFTRes 查询原生模块 NFT 详情返回值

type QueryNativeNFTsReq

type QueryNativeNFTsReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 分页数据的 Key， AVATA 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	ID         string `json:"id,omitempty"`          // NFT ID
	ClassID    string `json:"class_id,omitempty"`    // NFT 类别 ID
	Owner      string `json:"owner,omitempty"`       // NFT 持有者地址
	TxHash     string `json:"tx_hash,omitempty"`     // 创建 NFT 的 Tx Hash
	StartDate  string `json:"start_date,omitempty"`  // NFT 创建日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // NFT 创建日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC
	Status     string `json:"status,omitempty"`      // NFT 状态：active / burned，默认为 active
	Name       string `json:"name,omitempty"`        // NFT 名称，支持模糊查询
	CountTotal string `json:"count_total,omitempty"` // 是否查询数据的总数量0：不查询总数（默认）1：查询总数
}

QueryNativeNFTsReq 查询原生模块 NFT 请求参数

type QueryNativeNFTsRes

type QueryNativeNFTsRes struct {
	Data struct {
		PrevPageKey string `json:"prev_page_key"`         // 上一页数据的 Key，AVATA 会根据该值进行上一页数据的查询
		NextPageKey string `json:"next_page_key"`         // 下一页数据的 Key，AVATA 会根据该值进行下一页数据的查询
		Limit       int    `json:"limit"`                 // 每页记录数
		TotalCount  int    `json:"total_count,omitempty"` // 总记录数
		NFTs        []struct {
			ID          string `json:"id"`                     // NFT ID
			Name        string `json:"name,omitempty"`         // NFT 名称
			ClassID     string `json:"class_id"`               // NFT 类别 ID
			ClassName   string `json:"class_name"`             // NFT 类别名称
			ClassSymbol string `json:"class_symbol,omitempty"` // NFT 类别标识
			Uri         string `json:"uri,omitempty"`          // 链外数据链接
			Owner       string `json:"owner"`                  // NFT 持有者地址
			Status      int    `json:"status"`                 // NFT 状态：active / burned;
			TxHash      string `json:"tx_hash"`                // NFT 发行 Tx Hash
			TimeStamp   string `json:"timestamp"`              // NFT 发行时间戳（UTC 时间）
		} `json:"nfts,omitempty"` // NFT 列表
	} `json:"data"`
}

QueryNativeNFTsRes 查询原生模块 NFT 返回值

type QueryNativeTxResultRes

type QueryNativeTxResultRes struct {
	Data struct {
		Module      int    `json:"module"`       // 交易模块；Enum: 1 nft  2 ns(域名)  3 record(存证)
		Operation   int    `json:"operation"`    // 用户操作类型；Enum: 1：issue_class； 2：transfer_class； 3：mint_nft； 4：edit_nft； 5：transfer_nft； 6：burn_nft
		TxHash      string `json:"tx_hash"`      // 交易哈希
		Status      int    `json:"status"`       // 交易状态， 0 处理中； 1 成功； 2 失败； 3 未处理；Enum: 0 1 2 3
		Message     string `json:"message"`      // 交易失败的错误描述信息
		BlockHeight int    `json:"block_height"` // 交易上链的区块高度
		Timestamp   string `json:"timestamp"`    // 交易上链时间（UTC 时间）
		Nft         struct {
			ClassId string `json:"class_id"` // NFT 类别 ID
			ID      string `json:"id"`       // NFT ID
		} `json:"nft"` // 具体参考接口文档
		Mt struct {
			MtId    string `json:"mt_id"`    // MT ID
			ClassId string `json:"class_id"` // MT 类别 ID
		} `json:"mt"`
		Record struct {
			RecordId       string `json:"record_id"`       // 区块链存证 ID
			CertificateUrl string `json:"certificate_url"` // 区块链存证证书的下载链接；证书下载链接并非长期有效，请您尽快将证书文件下载至本地并妥善保管。
		} `json:"record"`
	} `json:"data"`
}

QueryNativeTxResultRes 原生模块上链交易结果查询接口返回值

type QueryNativeTxTypesRes

type QueryNativeTxTypesRes struct {
	Data DataItem `json:"data"`
}

QueryNativeTxTypesRes 原生模块查询枚举值列表接口返回值

type QueryOrderRes

type QueryOrderRes struct {
	Data struct {
		OperationID string `json:"operation_id"` // 订单流水号
		Status      int    `json:"status"`       // 订单状态：success 充值成功 / failed 充值失败 / pending 正在充值
		Message     string `json:"message"`      // 订单失败的错误描述信息
		Account     string `json:"account"`      // 链账户地址 （调用「批量购买能量值」接口不展示此字段）
		Amount      string `json:"amount"`       // 充值金额，为整数元金额；单位：分 （调用「批量购买能量值」接口不展示此字段）
		Number      string `json:"number"`       // 充值的数量，充值 gas 该值单位为 ugas，充值业务费单位为分（调用「批量购买能量值」接口不展示此字段）
		CreateTime  string `json:"create_time"`  // 创建时间（UTC 时间）
		UpdateTime  string `json:"update_time"`  // 最后操作时间（UTC 时间）
		OrderType   int    `json:"order_type"`   // 订单类型，gas / business
	} `json:"data"`
}

QueryOrderRes 查询能量值/业务费购买结果接口返回值

type QueryOrdersReq

type QueryOrdersReq struct {
	PageKey    string `json:"page_key,omitempty"`    // 分页数据的 Key，AVATA 会根据该值进行上下页的查询， 该值请从返回的数据体中获取，首页查询可以不传该参数
	Limit      string `json:"limit,omitempty"`       // 每页记录数，默认为 10，上限为 50
	Status     string `json:"status,omitempty"`      // 订单状态：success 充值成功 / failed 充值失败 / pending 正在充值
	StartDate  string `json:"start_date,omitempty"`  // 充值订单创建日期范围 - 开始，yyyy-MM-dd（UTC 时间）
	EndDate    string `json:"end_date,omitempty"`    // 充值订单创建日期范围 - 结束，yyyy-MM-dd（UTC 时间）
	SortBy     string `json:"sort_by,omitempty"`     // 排序规则：DATE_ASC / DATE_DESC，默认为 DATE_DESC
	CountTotal string `json:"count_total,omitempty"` // 是否查询数据的总数量0：不查询总数（默认）1：查询总数
}

QueryOrdersReq 查询能量值/业务费购买结果列表接口请求参数

type QueryOrdersRes

type QueryOrdersRes struct {
	Data struct {
		PrevPageKey string `json:"prev_page_key"` // 上一页数据的 Key，AVATA 会根据该值进行上一页数据的查询
		NextPageKey string `json:"next_page_key"` // 下一页数据的 Key，AVATA 会根据该值进行下一页数据的查询
		Limit       int    `json:"limit"`         // 每页记录数
		TotalCount  int    `json:"total_count"`   // 总记录数
		OrderInfos  []struct {
			OperationId string `json:"operation_id"` // 操作 ID
			Status      string `json:"status"`       // 订单状态：success 充值成功 / failed 充值失败 / pending 正在充值
			Message     string `json:"message"`      // 订单失败的错误描述信息
			Account     string `json:"account"`      // 链账户地址 （调用「批量购买能量值」接口不展示此字段）
			Amount      string `json:"amount"`       // 充值金额，为整数元金额；单位：分 （调用「批量购买能量值」接口不展示此字段）
			Number      string `json:"number"`       // 充值的数量，充值 gas 该值单位为 ugas，充值业务费单位为分（调用「批量购买能量值」接口不展示此字段）
			CreateTime  string `json:"create_time"`  // 创建时间（UTC 时间）
			UpdateTime  string `json:"update_time"`  // 最后操作时间（UTC 时间）
			OrderType   int    `json:"order_type"`   // 订单类型，gas / business
		} `json:"order_infos"`
	} `json:"data"`
}

QueryOrdersRes 查询能量值/业务费购买结果列表接口返回值

type QueryResolvesReq

type QueryResolvesReq struct {
	ResolveType string `json:"resolve_type,omitempty"` // 域名解析类型 0：全部 1：链账户 2：文本
}

QueryResolvesReq 查询域名解析请求参数

type QueryResolvesRes

type QueryResolvesRes struct {
	Data struct {
		Addrs []struct {
			BlockChain int    `json:"block_chain"` // 底层区块链 1000：天舟链  1001：天和链 1002: 神舟链
			AddrValue  string `json:"addr_value"`  // 链账户地址，默认值为当前域名 owner
		} `json:"addrs"` //链账户resolve_type为1必填
		Texts []struct {
			Key       string `json:"key"`        // 文本数据 key 可选：email、avatar、description、notice、keywords
			TextValue string `json:"text_value"` // 文本数据值
		} `json:"texts"` // 文本数据 resolve_type 为 2 必填
	} `json:"data"`
}

QueryResolvesRes 查询域名解析返回值

type QueryReverseResolvesRes

type QueryReverseResolvesRes struct {
	Data struct {
		Name string `json:"name"` // 域名
	} `json:"data"`
}

QueryReverseResolvesRes 查询域名反向解析返回值

type QueryTxResultRes

type QueryTxResultRes struct {
	Data struct {
		Module      int    `json:"module"`       // 交易模块；Enum: 1 nft  2 ns(域名)  3 record(存证) 4 合约调用；
		Operation   int    `json:"operation"`    // 用户操作类型；
		TxHash      string `json:"tx_hash"`      // 交易哈希
		Status      int    `json:"status"`       // 交易状态， 0 处理中； 1 成功； 2 失败； 3 未处理；Enum: 0 1 2 3
		Message     string `json:"message"`      // 交易失败的错误描述信息
		BlockHeight int    `json:"block_height"` // 交易上链的区块高度
		Timestamp   string `json:"timestamp"`    // 交易上链时间（UTC 时间）
		Nft         struct {
			ClassId string `json:"class_id"` // NFT 类别 ID
			ID      int    `json:"id"`       // NFT ID
		} `json:"nft"` // 具体参考接口文档
		Ns struct {
			Name    string `json:"name"`    // 域名
			Owner   string `json:"owner"`   // 域名拥有者的链账户地址
			Expires int    `json:"expires"` // 当前域名过期时间戳
			Node    string `json:"node"`    // 域名 node key
			Addr    struct {
				BlockChain int    `json:"block_chain"` // 底层区块链
				AddrValue  string `json:"addr_value"`  // 链账户地址
			} `json:"addr"`
			Text struct {
				Key       string `json:"key"`        // 文本数据 key
				TextValue string `json:"text_value"` // 文本数据值
			} `json:"text"`
			Address string `json:"addr"` // 链账户地址
		} `json:"ns"` // 具体参考接口文档

	} `json:"data"`
}

QueryTxResultRes EVM 模块上链交易结果查询接口返回值 交易状态说明： status 为 0（处理中），上链请求正在处理，请等待处理完成； status 为 1（成功），交易已上链并执行成功； status 为 2（失败），说明该交易执行失败。请在业务侧做容错处理。可以参考接口返回的 message（交易失败的错误描述信息） 对 NFT / MT / 业务接口的请求参数做适当调整后，使用「新的 Operation ID 」重新发起 NFT / MT / 业务接口请求。 status 为 3（未处理），上链请求还在等待处理，请稍等；

type QueryTxTypesRes

type QueryTxTypesRes struct {
	Data DataItem `json:"data"`
}

QueryTxTypesRes 查询枚举值列表接口返回值

type QueryUsersReq

type QueryUsersReq struct {
	UserType string `json:"user_type"` // 用户认证时，填写的用户类型。"1"：个人，"2"：企业
	Code     string `json:"code"`      // user_type为 "1" 时，请填写提交认证时对应的个人信息（身份证或护照号）user_type为 "2" 时，请填写提交认证时对应的企业信息（企业的统一社会信用代码或机构注册号）
}

type QueryUsersRes

type QueryUsersRes struct {
	Data struct {
		UserID string `json:"user_id"` // 用户认证成功时，对应生成的用户唯一标识
		Did    string `json:"did"`     // 用户身份标识（预留字段）
	} `json:"data"`
}

type Record

type Record struct {
	RecordId       string `json:"record_id"`       // 区块链存证 ID
	CertificateUrl string `json:"certificate_url"` // 区块链存证证书的下载链接；证书下载链接并非长期有效，请您尽快将证书文件下载至本地并妥善保管。
}

Record 回调返回的 Record 相关参数（不同版本通用）

type RegisterDomainReq

type RegisterDomainReq struct {
	Name        string `json:"name"`         // 一级域名名称
	Owner       string `json:"owner"`        // 域名拥有者的链账户地址
	Duration    int    `json:"duration"`     // 枚举：1,2,3,4,5
	OperationID string `json:"operation_id"` // 自定义订单流水号，必需且仅包含数字、下划线及英文字母大/小写
}

RegisterDomainReq 注册域名请求参数

type Response

type Response struct {
	AvataError AvataError `json:"error"`
}

Response Avata 错误提示信息

type SetResolvesReq

type SetResolvesReq struct {
	ResolveType int `json:"resolve_type"` // 域名解析类型 1：链账户 2：文本
	Addr        struct {
		BlockChain int    `json:"block_chain"`          // 底层区块链 1000：天舟链  1001：天和链 1002: 神舟链
		AddrValue  string `json:"addr_value,omitempty"` // 链账户地址，默认值为当前域名 owner
	} `json:"addr,omitempty"` // 链账户 resolve_type 为 1 必填
	Text struct {
		Key       string `json:"key,omitempty"` // 文本数据 key 可选：email、avatar、description、notice、keywords
		TextValue string `json:"text_value"`    // 文本数据值
	} `json:"text,omitempty"` // 文本数据 resolve_type 为 2 必填
	OperationID string `json:"operation_id"` // 操作 ID
}

SetResolvesReq 设置域名解析请求参数

type SetReverseResolvesReq

type SetReverseResolvesReq struct {
	Name        string `json:"name"`         // 域名名称
	OperationID string `json:"operation_id"` // 操作 ID
}

SetReverseResolvesReq 设置域名反向解析请求参数

type TransferDomainReq

type TransferDomainReq struct {
	Recipient   string `json:"recipient"`    // 域名接收者地址
	OperationID string `json:"operation_id"` // 自定义订单流水号，必需且仅包含数字、下划线及英文字母大/小写
}

TransferDomainReq 转让域名请求参数

type TransferMTClassReq

type TransferMTClassReq struct {
	Recipient   string `json:"recipient"`    // MT 类别接收者地址，支持任一 AVATA 内合法链账户地址
	OperationID string `json:"operation_id"` // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

TransferMTClassReq 转让 MT 类别请求参数

type TransferMTReq

type TransferMTReq struct {
	Recipient   string `json:"recipient"`        // MT 接收者地址
	Amount      int    `json:"amount,omitempty"` // 转移的数量（默认为 1 ）
	OperationID string `json:"operation_id"`     // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

TransferMTReq 转让 MT 请求参数

type TransferNFClassReq

type TransferNFClassReq struct {
	Recipient   string `json:"recipient"`    // NFT 合约接收者地址
	OperationID string `json:"operation_id"` // 保证幂等性，避免重复请求
}

TransferNFClassReq 转让 EVM 模块 NFT 类别请求参数

type TransferNFTReq

type TransferNFTReq struct {
	Recipient   string `json:"recipient"`    // NFT 接收者地址
	OperationID string `json:"operation_id"` // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

TransferNFTReq 转让 EVM 模块 NFT 请求参数

type TransferNativeNFClassReq

type TransferNativeNFClassReq struct {
	Recipient   string `json:"recipient"`    // NFT 合约接收者地址
	OperationID string `json:"operation_id"` // 保证幂等性，避免重复请求
}

TransferNativeNFClassReq 转让原生模块 NFT 类别请求参数

type TransferNativeNFTReq

type TransferNativeNFTReq struct {
	Recipient   string `json:"recipient"`    // NFT 接收者地址
	OperationID string `json:"operation_id"` // 操作 ID，保证幂等性，避免重复请求，保证对于同一操作发起的一次请求或者多次请求的结果是一致的；由接入方生成的、针对每个 Project ID 唯一的、不超过 64 个大小写字母、数字、-、下划线的字符串
}

TransferNativeNFTReq 转让原生模块 NFT 请求参数

type TxRes

type TxRes struct {
	Data struct {
	} `json:"data"`
}

TxRes 通用正确返回值(所有发起上链交易接口)

type TxType

type TxType struct {
	Module      int64  `json:"module"`      // 交易模块：请通过 查询枚举值列表 接口查看
	Operation   int64  `json:"operation"`   // 用户操作类型 请通过 查询枚举值列表 接口查看
	Code        string `json:"code"`        // 标识
	Name        string `json:"name"`        // 名称
	Description string `json:"description"` // 描述
}

QueryNativeTxTypesRes 原生模块查询枚举值列表接口返回值

type UseContractReq

type UseContractReq struct {
	From        string `json:"from"`                 // 签名交易链账户地址
	To          string `json:"to"`                   // 合约地址
	Data        string `json:"data"`                 // ABI 编码待签名交易的 hex 字符串
	GasLimit    int    `json:"gas_limit"`            // gas 使用上限大小
	Estimation  int    `json:"estimation,omitempty"` // 是否模拟执行交易，0 不模拟，1 模拟
	OperationID string `json:"operation_id"`         // 操作 ID
}

UseContractReq 调用合约请求参数