openwallet

type ABIDAI interface {
	//@require
	GetABIInfo(address string) (*ABIInfo, error)
	//@require
	SetABIInfo(address string, abi ABIInfo) error
}

type ABIInfo struct {
	Address string      `json:"address"`
	ABI     interface{} `json:"abi"`
}

type AccountOwner interface {
}

type Address struct {
	AccountID string `json:"accountID" storm:"index"` //钱包ID
	Address   string `json:"address" storm:"id"`      //地址字符串
	PublicKey string `json:"publicKey"`               //地址公钥/赎回脚本
	Alias     string `json:"alias"`                   //地址别名，可绑定用户
	Tag       string `json:"tag"`                     //标签
	Index     uint64 `json:"index"`                   //账户ID，索引位
	HDPath    string `json:"hdPath"`                  //地址公钥根路径
	WatchOnly bool   `json:"watchOnly"`               //是否观察地址，true的时候，Index，RootPath，Alias都没有。
	Symbol    string `json:"symbol"`                  //币种类别
	Balance   string `json:"balance"`                 //余额
	IsMemo    bool   `json:"isMemo"`                  //是否备注
	Memo      string `json:"memo"`                    //备注
	//CreateAt    time.Time `json:"createdAt"`//创建时间
	CreatedTime int64  `json:"createdTime"` //创建时间
	IsChange    bool   `json:"isChange"`    //是否找零地址
	ExtParam    string `json:"extParam"`    //扩展参数，用于调用智能合约，json结构

	//核心地址指针
	Core interface{}
}

type AddressCreateResult struct {
	Success bool
	Err     error
	Address *Address
}

type AddressDecoder interface {

	//PrivateKeyToWIF 私钥转WIF
	PrivateKeyToWIF(priv []byte, isTestnet bool) (string, error)
	//PublicKeyToAddress 公钥转地址
	PublicKeyToAddress(pub []byte, isTestnet bool) (string, error)
	//WIFToPrivateKey WIF转私钥
	WIFToPrivateKey(wif string, isTestnet bool) ([]byte, error)
	//RedeemScriptToAddress 多重签名赎回脚本转地址
	RedeemScriptToAddress(pubs [][]byte, required uint64, isTestnet bool) (string, error)
}

type AddressDecoderV2 interface {
	AddressDecoder

	// AddressDecode 地址解析
	AddressDecode(addr string, opts ...interface{}) ([]byte, error)
	// AddressEncode 地址编码
	AddressEncode(pub []byte, opts ...interface{}) (string, error)
	// AddressVerify 地址校验
	AddressVerify(address string, opts ...interface{}) bool
	// CustomCreateAddress 自主实现创建账户地址
	CustomCreateAddress(account *AssetsAccount, newIndex uint64) (*Address, error)
	// SupportCustomCreateAddressFunction 支持创建地址实现
	SupportCustomCreateAddressFunction() bool
}

type AddressDecoderV2Base struct {
}

type App struct {
	AppID   string `json:"appID"`
	AppName string `json:"appID"`
}

type AssetsAccount struct {
	WalletID  string   `json:"walletID"`             //钱包ID
	Alias     string   `json:"alias"`                //别名
	AccountID string   `json:"accountID" storm:"id"` //账户ID，合成地址
	Index     uint64   `json:"index"`                //账户ID，索引位
	HDPath    string   `json:"hdPath"`               //衍生路径
	PublicKey string   `json:"publicKey"`            //主公钥
	OwnerKeys []string `json:"ownerKeys"`            //公钥数组，大于1为多签
	//Owners          map[string]AccountOwner //拥有者列表, 账户公钥: 拥有者
	ContractAddress string `json:"contractAddress"` //多签合约地址
	Required        uint64 `json:"required"`        //必要签名数
	Symbol          string `json:"symbol"`          //资产币种类别
	AddressIndex    int    `json:"addressIndex"`
	Balance         string `json:"balance"`
	IsTrust         bool   `json:"isTrust"`   //是否托管密钥
	ExtParam        string `json:"extParam"`  //扩展参数，用于调用智能合约，json结构
	ModelType       uint64 `json:"modelType"` //模型类别, 1: utxo模型(BTC), 2: account模型（ETH），3: 账户别名模型(EOS)
	// contains filtered or unexported fields
}

type AssetsAdapter interface {

	//币种信息
	//@required
	SymbolInfo

	//配置
	//@required
	AssetsConfig

	//GetAddressDecodeV2 地址解析器V2
	//如果实现了AddressDecoderV2，就无需实现AddressDecoder
	//@required
	GetAddressDecoderV2() AddressDecoderV2

	//GetAddressDecode 地址解析器
	//如果实现了AddressDecoderV2，就无需实现AddressDecoder
	//@required
	GetAddressDecode() AddressDecoder

	//GetTransactionDecoder 交易单解析器
	//@required
	GetTransactionDecoder() TransactionDecoder

	//GetBlockScanner 获取区块链扫描器
	//@required
	GetBlockScanner() BlockScanner

	//GetSmartContractDecoder 获取智能合约解析器
	//@optional
	GetSmartContractDecoder() SmartContractDecoder

	//GetAssetsLogger 获取资产日志工具
	//@optional
	GetAssetsLogger() *log.OWLogger

	//GetJsonRPCEndpoint 获取全节点服务的JSON-RPC客户端
	//@optional
	GetJsonRPCEndpoint() JsonRPCEndpoint

	//GetNFTContractDecoder 获取NFT智能合约解析器
	//@optional
	GetNFTContractDecoder() NFTContractDecoder
}

type AssetsAdapterBase struct {
	SymbolInfoBase
	AssetsConfigBase
}

type AssetsConfig interface {

	//LoadExternalConfig 加载外部配置
	LoadAssetsConfig(c config.Configer) error

	//InitDefaultConfig 初始化默认配置
	InitAssetsConfig() (config.Configer, error)
}

type AssetsConfigBase struct{}

type Balance struct {
	Symbol           string
	AccountID        string
	Address          string
	ConfirmBalance   string
	UnconfirmBalance string
	Balance          string
}

type BalanceModelType uint32

type BlockHeader struct {
	Hash              string `json:"hash"`
	Confirmations     uint64 `json:"confirmations"`
	Merkleroot        string `json:"merkleroot"`
	Previousblockhash string `json:"previousblockhash"`
	Height            uint64 `json:"height" storm:"id"`
	Version           uint64 `json:"version"`
	Time              uint64 `json:"time"`
	Fork              bool   `json:"fork"`
	Symbol            string `json:"symbol"`
}

type BlockScanAddressFunc func(address string) (string, bool)

type BlockScanNotificationObject interface {

	//BlockScanNotify 新区块扫描完成通知
	//@required
	BlockScanNotify(header *BlockHeader) error

	//BlockExtractDataNotify 区块提取结果通知
	//@required
	BlockExtractDataNotify(sourceKey string, data *TxExtractData) error

	//BlockExtractSmartContractDataNotify 区块提取智能合约交易结果通知
	//@param sourceKey: 为contractID
	//@param data: 合约交易回执
	//@required
	BlockExtractSmartContractDataNotify(sourceKey string, data *SmartContractReceipt) error
}

type BlockScanNotify func(header *BlockHeader)

type BlockScanTargetFunc func(target ScanTarget) (string, bool)

type BlockScanTargetFuncV2 func(target ScanTargetParam) ScanTargetResult

type BlockScanner interface {

	//deprecated
	// SetBlockScanAddressFunc 设置区块扫描过程，查找地址过程方法
	SetBlockScanAddressFunc(scanAddressFunc BlockScanAddressFunc) error

	//deprecated
	// SetBlockScanTargetFunc 设置区块扫描过程，查找扫描对象过程方法
	SetBlockScanTargetFunc(scanTargetFunc BlockScanTargetFunc) error

	//SetBlockScanTargetFuncV2 设置区块扫描过程，查找扫描对象过程方法
	//@required
	SetBlockScanTargetFuncV2(scanTargetFunc BlockScanTargetFuncV2) error

	//AddObserver 添加观测者
	//@optional
	AddObserver(obj BlockScanNotificationObject) error

	//RemoveObserver 移除观测者
	//@optional
	RemoveObserver(obj BlockScanNotificationObject) error

	//SetRescanBlockHeight 重置区块链扫描高度
	//@required
	SetRescanBlockHeight(height uint64) error

	//Run 运行
	//@optional
	Run() error

	//Stop 停止扫描
	//@optional
	Stop() error

	//Pause 暂停扫描
	//@optional
	Pause() error

	//Restart 继续扫描
	//@optional
	Restart() error

	//InitBlockScanner 初始化扫描器
	//@optional
	InitBlockScanner() error

	//CloseBlockScanner 关闭扫描器
	//@optional
	CloseBlockScanner() error

	//ScanBlock 扫描指定高度的区块
	//@required
	ScanBlock(height uint64) error

	//NewBlockNotify 新区块通知
	//@optional
	NewBlockNotify(header *BlockHeader) error

	//GetCurrentBlockHeight 获取当前区块高度
	//@required
	GetCurrentBlockHeader() (*BlockHeader, error)

	//GetGlobalMaxBlockHeight 获取区块链全网最大高度
	//@optional
	GetGlobalMaxBlockHeight() uint64

	//GetScannedBlockHeight 获取已扫区块高度
	//@required
	GetScannedBlockHeight() uint64

	//ExtractTransactionData 提取交易单数据
	//@required
	ExtractTransactionData(txid string, scanTargetFunc BlockScanTargetFunc) (map[string][]*TxExtractData, error)

	//GetBalanceByAddress 查询地址余额
	//@required
	GetBalanceByAddress(address ...string) ([]*Balance, error)

	//GetTransactionsByAddress 查询基于账户的交易记录，通过账户关系的地址
	//返回的交易记录以资产账户为集合的结果，转账数量以基于账户来计算
	//@optional
	GetTransactionsByAddress(offset, limit int, coin Coin, address ...string) ([]*TxExtractData, error)

	//SetBlockScanWalletDAI 设置区块扫描过程，上层提供一个钱包数据接口
	//@optional
	SetBlockScanWalletDAI(dai WalletDAI) error

	//SetBlockchainDAI 设置区块链数据访问接口，读取持久化的区块数据
	//@optional
	SetBlockchainDAI(dai BlockchainDAI) error

	//SupportBlockchainDAI 支持外部设置区块链数据访问接口
	//@optional
	SupportBlockchainDAI() bool

	//ExtractTransactionAndReceiptData 提取交易单及交易回执数据
	//@required
	ExtractTransactionAndReceiptData(txid string, scanTargetFunc BlockScanTargetFuncV2) (map[string][]*TxExtractData, map[string]*SmartContractReceipt, error)

	//GetBlockchainSyncStatus 获取当前区块链同步状态
	//@optional
	GetBlockchainSyncStatus() (*BlockchainSyncStatus, error)
}

type BlockScannerBase struct {
	AddressInScanning map[string]string //加入扫描的地址

	Mu               sync.RWMutex                         //读写锁
	Observers        map[BlockScanNotificationObject]bool //观察者
	Scanning         bool                                 //是否扫描中
	PeriodOfTask     time.Duration
	ScanAddressFunc  BlockScanAddressFunc  //区块扫描查询地址算法
	ScanTargetFunc   BlockScanTargetFunc   //区块扫描查询地址算法
	ScanTargetFuncV2 BlockScanTargetFuncV2 //区块扫描查询地址算法

	WalletDAI     WalletDAI
	BlockchainDAI BlockchainDAI
	// contains filtered or unexported fields
}

type Blockchain struct {
	Blocks     uint64
	Headers    uint64
	ScanHeight uint64
}

type BlockchainDAI interface {
	SaveCurrentBlockHead(header *BlockHeader) error
	GetCurrentBlockHead(symbol string) (*BlockHeader, error)
	SaveLocalBlockHead(header *BlockHeader) error
	GetLocalBlockHeadByHeight(height uint64, symbol string) (*BlockHeader, error)
	SaveUnscanRecord(record *UnscanRecord) error
	DeleteUnscanRecordByHeight(height uint64, symbol string) error
	DeleteUnscanRecordByID(id string, symbol string) error
	GetTransactionsByTxID(txid, symbol string) ([]*Transaction, error)
	GetUnscanRecords(symbol string) ([]*UnscanRecord, error)
	SetMaxBlockCache(max uint64, symbol string) error
	SaveTransaction(tx *Transaction) error
}

type BlockchainDAIBase int

type BlockchainLocal struct {
	BlockchainDAIBase
	// contains filtered or unexported fields
}

type BlockchainSyncStatus struct {
	NetworkBlockHeight uint64
	CurrentBlockHeight uint64
	Syncing            bool
}

type Bytes []byte

type CacheEntry struct {
	Key        string
	Value      interface{}
	Expiration int64
}

type Coin struct {
	Symbol     string        `json:"symbol"`
	IsContract bool          `json:"isContract"`
	ContractID string        `json:"contractID"`
	Contract   SmartContract `json:"contract"`
}

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

type FeesSupportAccount struct {
	AccountID        string `json:"accountID"`        //提供手续费支持的账户
	FixSupportAmount string `json:"fixSupportAmount"` //每次转账固定数量
	FeesSupportScale string `json:"feesScale"`        //每次转账消耗手续费的倍率
}

type ICacheManager interface {
	Add(key string, value interface{}, duration time.Duration) error
	Get(key string) (interface{}, bool)
	GetCacheEntry(key string) (*CacheEntry, bool)
	Remove(key string) (interface{}, bool)
	Contains(key string) bool
	Clear()
}

type ImportAddress struct {
	Address `storm:"inline"`
}

type JsonRPCEndpoint interface {

	//SendRPCRequest 发起JSON-RPC请求
	//@optional
	SendRPCRequest(method string, request interface{}) ([]byte, error)

	//SupportJsonRPCEndpoint 是否开放客户端直接调用全节点的JSON-RPC方法
	//@optional
	SupportJsonRPCEndpoint() bool
}

type JsonRPCEndpointBase int

type KeySignature struct {
	EccType   uint32   `json:"eccType"` //曲线类型
	Nonce     string   `json:"nonce"`
	Address   *Address `json:"address"` //提供签名的地址
	Signature string   `json:"signed"`  //未花签名
	Message   string   `json:"msg"`     //被签消息
	RSV       bool     `json:"rsv"`     //签名是否需要合并V
}

type NFT struct {
	Symbol   string `json:"symbol"` //@required 主币的symbol
	Address  string `json:"address"`
	Token    string `json:"token"` //@required NFT的symbol
	Protocol string `json:"protocol"`
	Name     string `json:"name"`
	TokenID  string `json:"tokenID"`
}

type NFTApproval struct {
	Token    NFT    `json:"token"`    //@required nft
	Owner    string `json:"owner"`    //@required nft拥有者
	Operator string `json:"operator"` //required 被授权的操作者
	IsAll    bool   `json:"isAll"`    //@required 是否全部NFT，true：token = null，false，token = *NFT
}

type NFTBalance struct {
	NFT     *NFT
	Balance string
}

type NFTContractDecoder interface {
	//GetNFTBalanceByAddress 查询地址NFT余额列表
	GetNFTBalanceByAddress(nft *NFT, owner string) (*NFTBalance, *Error)
	// GetNFTBalanceByAddressBatch 查询地址NFT余额列表
	GetNFTBalanceByAddressBatch(nft []*NFT, owner []string) ([]*NFTBalance, *Error)
	//GetNFTOwnerByTokenID 查询地址token的拥有者
	GetNFTOwnerByTokenID(nft *NFT) (*NFTOwner, *Error)
	//GetMetaDataOfNFT 查询NFT的MetaData
	GetMetaDataOfNFT(nft *NFT) (*NFTMetaData, *Error)
	//GetNFTTransfer 从event解析NFT转账信息
	GetNFTTransfer(event *SmartContractEvent) (*NFTTransfer, *Error)
}

type NFTContractDecoderBase struct {
}

type NFTMetaData struct {
	NFT *NFT
	URI string
}

type NFTOwner struct {
	NFT   *NFT
	Owner string
}

type NFTTransfer struct {
	Tokens    []NFT    `json:"tokens"`    //@required nft
	Operator  string   `json:"operator"`  //required 被授权转账的操作者
	From      string   `json:"from"`      //@required 发送者
	To        string   `json:"to"`        //@required 接受者
	Amounts   []string `json:"amounts"`   //@required erc1155 token有数量
	EventType uint64   `json:"eventType"` //@required
}

type PublicKey []byte

type RawTransaction struct {
	Coin        Coin                       `json:"coin"`       //@required 区块链类型标识
	TxID        string                     `json:"txID"`       //交易单ID，广播后会生成
	Sid         string                     `json:"sid"`        //业务订单号，保证业务不重复交易而用
	RawHex      string                     `json:"rawHex"`     //区块链协议构造的交易原生数据
	FeeRate     string                     `json:"feeRate"`    //自定义费率
	To          map[string]string          `json:"to"`         //@required 目的地址:转账数量
	Account     *AssetsAccount             `json:"account"`    //@required 创建交易单的账户
	Signatures  map[string][]*KeySignature `json:"sigParts"`   //拥有者accountID: []未花签名
	Required    uint64                     `json:"reqSigs"`    //必要签名
	IsBuilt     bool                       `json:"isBuilt"`    //是否完成构建建议单
	IsCompleted bool                       `json:"isComplete"` //是否完成所有签名
	IsSubmit    bool                       `json:"isSubmit"`   //是否已广播
	Change      *Address                   `json:"change"`     //找零地址
	ExtParam    string                     `json:"extParam"`   //扩展参数，用于调用智能合约，json结构

	Fees     string   `json:"fees"`     //手续费
	TxAmount string   `json:"txAmount"` //交易单实际对账户发生的数量变化
	TxFrom   []string `json:"txFrom"`   //格式："地址":"数量"，备注订单使用
	TxTo     []string `json:"txTo"`     //格式："地址":"数量"，备注订单使用
}

type RawTransactionWithError struct {
	RawTx *RawTransaction `json:"rawTx"`
	Error *Error          `json:"error"`
}

type Recharge struct {
	Sid         string `json:"sid" storm:"id"` //@required base64(sha1(txid+n+addr))，对于账户模型，只有一个输入输出，n = 0。
	TxID        string `json:"txid"`           //@required
	AccountID   string `json:"accountID"`
	Address     string `json:"address"` //@required
	Symbol      string `json:"symbol"`  //Deprecated: use Coin
	Coin        Coin   `json:"coin"`    //@required 区块链类型标识
	Amount      string `json:"amount"`  //@required
	Confirm     int64  `json:"confirm"`
	BlockHash   string `json:"blockHash"`                 //@required
	BlockHeight uint64 `json:"blockHeight" storm:"index"` //@required
	IsMemo      bool   `json:"isMemo"`
	Memo        string `json:"memo"`  //deprecated, 使用ExtParam扩展
	Index       uint64 `json:"index"` //@required
	Received    bool
	CreateAt    int64 `json:"createdAt"` //@required
	Delete      bool
	TxType      uint64 `json:"txType"` // @required 0:转账，1:合约调用(发生于主链)
}

type ScanTarget struct {
	Address          string           //地址字符串
	PublicKey        string           //地址公钥
	Alias            string           //地址别名，可绑定用户别名
	Symbol           string           //币种类别
	BalanceModelType BalanceModelType //余额模型类别
}

type ScanTargetParam struct {
	ScanTarget     string //地址字符串
	Symbol         string //主链类别
	ScanTargetType uint64 // 0: 账户地址，1：账户别名，2：合约地址，3：合约别名，4：地址公钥，5：地址备注
}

type ScanTargetResult struct {
	SourceKey string //关联键，地址关联的账户或ID等等
	Exist     bool   //是否存在

	//对象指针，对应ScanTargetType:
	//0：openwallet.Address
	//1：openwallet.Account
	//2: openwallet SmartContract
	//3: openwallet SmartContract
	//4: openwallet Address
	//5: openwallet Address
	TargetInfo interface{}
}

type SmartContract struct {
	ContractID string `json:"contractID" storm:"id"` //计算ID：base64(sha256({symbol}_{address})) 主链symbol
	Symbol     string `json:"symbol"`                //主币的symbol
	Address    string `json:"address"`
	Token      string `json:"token"` //合约的symbol
	Protocol   string `json:"protocol"`
	Name       string `json:"name"`
	Decimals   uint64 `json:"decimals"`
	// contains filtered or unexported fields
}

type SmartContractCallResult struct {
	Method    string `json:"method"`    //调用方法
	Value     string `json:"value"`     //json结果
	RawHex    string `json:"rawHex"`    //16进制字符串结果
	Status    uint64 `json:"status"`    //0：成功，1：失败
	Exception string `json:"exception"` //异常错误
}

type SmartContractDecoder interface {
	ABIDAI

	//GetTokenBalanceByAddress 查询地址token余额列表
	GetTokenBalanceByAddress(contract SmartContract, address ...string) ([]*TokenBalance, error)
	//调用合约ABI方法
	CallSmartContractABI(wrapper WalletDAI, rawTx *SmartContractRawTransaction) (*SmartContractCallResult, *Error)
	//创建原始交易单
	CreateSmartContractRawTransaction(wrapper WalletDAI, rawTx *SmartContractRawTransaction) *Error
	//SubmitRawTransaction 广播交易单
	SubmitSmartContractRawTransaction(wrapper WalletDAI, rawTx *SmartContractRawTransaction) (*SmartContractReceipt, *Error)
	//GetTokenMetadata 根据合约地址查询token元数据
	GetTokenMetadata(contract string) (*SmartContract, error)
}

type SmartContractDecoderBase struct {
}

type SmartContractEvent struct {
	Contract *SmartContract `json:"contract"` //合约
	Event    string         `json:"event"`    //记录事件
	Value    string         `json:"value"`    //结果参数，json字符串
}

type SmartContractRawTransaction struct {
	Coin         Coin                       `json:"coin"`         //@required 区块链类型标识
	TxID         string                     `json:"txID"`         //交易单ID，广播后会生成
	Sid          string                     `json:"sid"`          //@required 业务订单号，保证业务不重复交易而用
	Account      *AssetsAccount             `json:"account"`      //@required 创建交易单的账户
	Signatures   map[string][]*KeySignature `json:"signatures"`   //拥有者accountID: []未花签名
	IsBuilt      bool                       `json:"isBuilt"`      //是否完成构建建议单
	IsCompleted  bool                       `json:"isComplete"`   //是否完成所有签名
	IsSubmit     bool                       `json:"isSubmit"`     //是否已广播
	Raw          string                     `json:"raw"`          //交易单调用参数，根据RawType填充数据
	RawType      uint64                     `json:"rawType"`      // 0：hex字符串，1：json字符串，2：base64字符串
	ABIParam     []string                   `json:"abiParam"`     //abi调用参数，[method, arg1, arg2, args...]
	Value        string                     `json:"value"`        //主币数量
	FeeRate      string                     `json:"feeRate"`      //自定义费率
	Fees         string                     `json:"fees"`         //手续费
	TxFrom       string                     `json:"txFrom"`       //调用地址
	TxTo         string                     `json:"txTo"`         //调用地址，与合约地址一致
	AwaitResult  bool                       `json:"awaitResult"`  //是否广播后同时等待结果
	AwaitTimeout uint64                     `json:"awaitTimeout"` //广播后等待超时秒，0 = 默认超时90秒
}

type SmartContractReceipt struct {
	Coin        Coin                  `json:"coin"`            //@required 区块链类型标识
	WxID        string                `json:"wxid" storm:"id"` //@required 通过GenTransactionWxID计算
	TxID        string                `json:"txid"`            //@required
	From        string                `json:"from"`            //@required 调用者
	To          string                `json:"to"`              //@required 调用地址，与合约地址一致
	Value       string                `json:"value"`           //主币数量
	Fees        string                `json:"fees"`            //手续费
	RawReceipt  string                `json:"rawReceipt"`      //@required 原始交易回执，一般为json
	Events      []*SmartContractEvent `json:"events"`          //@required 执行事件, 例如：event Transfer
	BlockHash   string                `json:"blockHash"`       //@required
	BlockHeight uint64                `json:"blockHeight"`     //@required
	ConfirmTime int64                 `json:"confirmTime"`     //@required
	Status      string                `json:"status"`          //@required 链上状态，0：失败，1：成功
	Reason      string                `json:"reason"`          //失败原因，失败状态码
	ExtParam    string                `json:"extParam"`        //扩展参数，用于调用智能合约，json结构
}

type SummaryRawTransaction struct {
	Coin               Coin                `json:"coin"`               //@required 区块链类型标识
	FeeRate            string              `json:"feeRate"`            //自定义费率
	SummaryAddress     string              `json:"summaryAddress"`     //@required 目的地址:转账数量
	MinTransfer        string              `json:"minTransfer"`        //最低转账额，默认0
	RetainedBalance    string              `json:"retainedBalance"`    //账户的地址保留余额，默认0
	Account            *AssetsAccount      `json:"account"`            //@required 创建交易单的账户
	AddressStartIndex  int                 `json:"addressStartIndex"`  //汇总账户地址开始位置
	AddressLimit       int                 `json:"addressLimit"`       //汇总账户地址控制数量
	Confirms           uint64              `json:"confirms"`           //汇总的未花交易大于确认数
	FeesSupportAccount *FeesSupportAccount `json:"feesSupportAccount"` //手续费支持账户
	ExtParam           string              `json:"extParam"`           //扩展参数，用于调用智能合约，json结构
}

type SymbolInfo interface {

	//CurveType 曲线类型
	CurveType() uint32

	//FullName 币种全名
	FullName() string

	//Symbol 币种标识
	Symbol() string

	//Decimal 小数位精度
	Decimal() int32

	//BalanceModelType 余额模型类别
	BalanceModelType() BalanceModelType
}

type SymbolInfoBase struct {
}

type TokenBalance struct {
	Contract *SmartContract
	Balance  *Balance
}

type Transaction struct {
	//openwallet自定义的ID，在不同链可能存在重复的txid，
	// 所以我们要生成一个全局不重复的
	WxID        string   `json:"wxid" storm:"id"` //@required 通过GenTransactionWxID计算
	TxID        string   `json:"txid"`            //@required
	AccountID   string   `json:"accountID"`
	Coin        Coin     `json:"coin"` //@required 区块链类型标识
	From        []string `json:"from"` //@required 格式："地址":"数量"
	To          []string `json:"to"`   //@required 格式："地址":"数量"
	Amount      string   `json:"amount"`
	Decimal     int32    `json:"decimal"`  //@required
	TxType      uint64   `json:"txType"`   // @required 0:转账, 1:合约调用(发生于主链), >100: 自定义，可以在TxAction填说明
	TxAction    string   `json:"txAction"` // 执行事件, 例如：合约的Transfer事件
	Confirm     int64    `json:"confirm"`
	BlockHash   string   `json:"blockHash"`   //@required
	BlockHeight uint64   `json:"blockHeight"` //@required
	IsMemo      bool     `json:"isMemo"`
	Memo        string   `json:"memo"` //deprecated, 使用ExtParam扩展
	Fees        string   `json:"fees"` //@required
	Received    bool     `json:"received"`
	SubmitTime  int64    `json:"submitTime"`  //@required
	ConfirmTime int64    `json:"confirmTime"` //@required
	Status      string   `json:"status"`      //链上状态，0：失败，1：成功
	Reason      string   `json:"reason"`      //失败原因，失败状态码
	ExtParam    string   `json:"extParam"`    //扩展参数，用于调用智能合约，json结构

}

type TransactionDecoder interface {
	//SendRawTransaction 广播交易单
	//SendTransaction func(amount, feeRate string, to []string, wallet *Wallet, account *AssetsAccount) (*RawTransaction, error)
	//CreateRawTransaction 创建交易单
	CreateRawTransaction(wrapper WalletDAI, rawTx *RawTransaction) error
	//SignRawTransaction 签名交易单
	SignRawTransaction(wrapper WalletDAI, rawTx *RawTransaction) error
	//SubmitRawTransaction 广播交易单
	SubmitRawTransaction(wrapper WalletDAI, rawTx *RawTransaction) (*Transaction, error)
	//VerifyRawTransaction 验证交易单，验证交易单并返回加入签名后的交易单
	VerifyRawTransaction(wrapper WalletDAI, rawTx *RawTransaction) error
	//GetRawTransactionFeeRate 获取交易单的费率
	GetRawTransactionFeeRate() (feeRate string, unit string, err error)
	//CreateSummaryRawTransaction 创建汇总交易，返回原始交易单数组
	CreateSummaryRawTransaction(wrapper WalletDAI, sumRawTx *SummaryRawTransaction) ([]*RawTransaction, error)
	//EstimateRawTransactionFee 预估手续费
	EstimateRawTransactionFee(wrapper WalletDAI, rawTx *RawTransaction) error
	//CreateSummaryRawTransactionWithError 创建汇总交易，返回能原始交易单数组（包含带错误的原始交易单）
	CreateSummaryRawTransactionWithError(wrapper WalletDAI, sumRawTx *SummaryRawTransaction) ([]*RawTransactionWithError, error)
}

type TransactionDecoderBase struct {
}

type TransactionSigner interface {

	// SignTransactionHash 交易哈希签名算法
	// required
	SignTransactionHash(msg []byte, privateKey []byte, eccType uint32) ([]byte, error)
}

type TransactionSignerBase struct {
}

type TxExtractData struct {

	//消费记录，交易单输入部分
	TxInputs []*TxInput

	//充值记录，交易单输出部分
	TxOutputs []*TxOutPut

	//交易记录
	Transaction *Transaction
}

type TxInput struct {
	//SourceTxID和SourceIndex是utxo模型上的上一个交易输入源，account模型不需要填
	SourceTxID  string //源交易单ID
	SourceIndex uint64 //源交易单输出所因为
	Recharge    `storm:"inline"`
}

type TxOutPut struct {
	Recharge `storm:"inline"`
	ExtParam string //扩展参数，用于记录utxo的解锁字段，json格式
}

type UnscanRecord struct {
	ID          string `storm:"id"` // primary key
	BlockHeight uint64 `json:"blockHeight"`
	TxID        string `json:"txid"`
	Reason      string `json:"reason"`
	Symbol      string `json:"symbol"`
}

type Wallet struct {
	AppID        string `json:"appID"`
	WalletID     string `json:"walletID"  storm:"id"`
	Alias        string `json:"alias"`
	Password     string `json:"password"`
	RootPub      string `json:"rootpub"` //弃用
	RootPath     string `json:"rootPath"`
	KeyFile      string `json:"keyFile"`      //钱包的密钥文件
	DBFile       string `json:"dbFile"`       //钱包的数据库文件
	WatchOnly    bool   `json:"watchOnly"`    //创建watchonly的钱包，没有私钥文件，只有db文件
	IsTrust      bool   `json:"isTrust"`      //是否托管密钥
	AccountIndex int    `json:"accountIndex"` //账户索引数，-1代表未创建账户
	ExtParam     string `json:"extParam"`     //扩展参数，用于调用智能合约，json结构
	// contains filtered or unexported fields
}

type WalletDAI interface {
	//获取当前钱包
	GetWallet() *Wallet
	//根据walletID查询钱包
	GetWalletByID(walletID string) (*Wallet, error)

	//获取单个资产账户
	GetAssetsAccountInfo(accountID string) (*AssetsAccount, error)
	//查询资产账户列表
	GetAssetsAccountList(offset, limit int, cols ...interface{}) ([]*AssetsAccount, error)
	//根据地址查询资产账户
	GetAssetsAccountByAddress(address string) (*AssetsAccount, error)

	//获取单个地址
	GetAddress(address string) (*Address, error)
	//查询地址列表
	GetAddressList(offset, limit int, cols ...interface{}) ([]*Address, error)
	//设置地址的扩展字段
	SetAddressExtParam(address string, key string, val interface{}) error
	//获取地址的扩展字段
	GetAddressExtParam(address string, key string) (interface{}, error)

	//解锁钱包，指定时间内免密
	UnlockWallet(password string, time time.Duration) error
	//获取钱包HDKey
	HDKey(password ...string) (*hdkeystore.HDKey, error)

	//获取钱包所创建的交易单
	GetTransactionByTxID(txid, symbol string) ([]*Transaction, error)
}

type WalletDAIBase struct {
}

type WalletType = uint

type Withdraw struct {
	Symbol   string `json:"coin"`
	WalletID string `json:"walletID"`
	Sid      string `json:"sid"  storm:"id"`
	IsMemo   bool   `json:"isMemo"`
	Address  string `json:"address"`
	Amount   string `json:"amount"`
	Memo     string `json:"memo"`
	Password string `json:"password"`
	TxID     string `json:"txid"`
}