sdk

-- import "github.com/go-xpx-chain-sdk/sdk"

Package sdk provides a client library for the Catapult REST API.

Usage

const (
    AddressSize                              int = 25
    BaseInt64Size                            int = 8
    AmountSize                                   = BaseInt64Size
    KeySize                                  int = 32
    Hash256                                  int = 32
    MosaicIdSize                                 = BaseInt64Size
    NamespaceSize                                = BaseInt64Size
    SizeSize                                 int = 4
    MaxStringSize                            int = 2
    SignerSize                                   = KeySize
    SignatureSize                            int = 64
    HalfOfSignature                              = SignatureSize / 2
    VersionSize                              int = 4
    TypeSize                                 int = 2
    MaxFeeSize                                   = BaseInt64Size
    DeadLineSize                                 = BaseInt64Size
    DurationSize                                 = BaseInt64Size
    StorageSizeSize                              = BaseInt64Size
    TransactionHeaderSize                        = SizeSize + SignerSize + SignatureSize + VersionSize + TypeSize + MaxFeeSize + DeadLineSize
    PropertyTypeSize                         int = 2
    PropertyModificationTypeSize             int = 1
    AccountPropertiesAddressModificationSize     = PropertyModificationTypeSize + AddressSize
    AccountPropertiesMosaicModificationSize      = PropertyModificationTypeSize + MosaicIdSize
    AccountPropertiesEntityModificationSize      = PropertyModificationTypeSize + TypeSize
    AccountPropertyAddressHeader                 = TransactionHeaderSize + PropertyTypeSize
    AccountPropertyMosaicHeader                  = TransactionHeaderSize + PropertyTypeSize
    AccountPropertyEntityTypeHeader              = TransactionHeaderSize + PropertyTypeSize
    LinkActionSize                           int = 1
    AccountLinkTransactionSize                   = TransactionHeaderSize + KeySize + LinkActionSize
    AliasActionSize                          int = 1
    AliasTransactionHeaderSize                   = TransactionHeaderSize + NamespaceSize + AliasActionSize
    AggregateBondedHeaderSize                    = TransactionHeaderSize + SizeSize
    NetworkConfigHeaderSize                      = TransactionHeaderSize + BaseInt64Size + MaxStringSize + MaxStringSize
    BlockchainUpgradeTransactionSize             = TransactionHeaderSize + DurationSize + BaseInt64Size
    HashTypeSize                             int = 1
    LockSize                                     = TransactionHeaderSize + MosaicIdSize + AmountSize + DurationSize + Hash256
    MetadataTypeSize                         int = 1
    MetadataHeaderSize                           = TransactionHeaderSize + MetadataTypeSize
    MetadataV2HeaderSize                         = TransactionHeaderSize + KeySize + BaseInt64Size + 2 + 2
    ModificationsSizeSize                    int = 1
    ModifyContractHeaderSize                     = TransactionHeaderSize + DurationSize + Hash256 + 3*ModificationsSizeSize
    MinApprovalSize                          int = 1
    MinRemovalSize                           int = 1
    ModifyMultisigHeaderSize                     = TransactionHeaderSize + MinApprovalSize + MinRemovalSize + ModificationsSizeSize
    MosaicNonceSize                          int = 4
    MosaicPropertiesHeaderSize               int = 3
    MosaicPropertyIdSize                     int = 1
    MosaicOptionalPropertySize                   = MosaicPropertyIdSize + BaseInt64Size
    MosaicDefinitionTransactionHeaderSize        = TransactionHeaderSize + MosaicNonceSize + MosaicIdSize + MosaicPropertiesHeaderSize
    MosaicSupplyDirectionSize                int = 1
    MosaicSupplyChangeTransactionSize            = TransactionHeaderSize + MosaicIdSize + AmountSize + MosaicSupplyDirectionSize
    MosaicLevySize                               = 1 + AddressSize + MosaicIdSize + MaxFeeSize
    MosaicModifyLevyTransactionSize              = TransactionHeaderSize + MosaicLevySize + MosaicIdSize
    MosaicRemoveLevyTransactionSize              = TransactionHeaderSize + MosaicIdSize
    NamespaceTypeSize                        int = 1
    NamespaceNameSizeSize                    int = 1
    RegisterNamespaceHeaderSize                  = TransactionHeaderSize + NamespaceTypeSize + DurationSize + NamespaceSize + NamespaceNameSizeSize
    SecretLockSize                               = TransactionHeaderSize + MosaicIdSize + AmountSize + DurationSize + HashTypeSize + Hash256 + AddressSize
    ProofSizeSize                            int = 2
    SecretProofHeaderSize                        = TransactionHeaderSize + HashTypeSize + Hash256 + AddressSize + ProofSizeSize
    MosaicsSizeSize                          int = 1
    MessageSizeSize                          int = 2
    TransferHeaderSize                           = TransactionHeaderSize + AddressSize + MosaicsSizeSize + MessageSizeSize
    ReplicasSize                                 = 2
    MinReplicatorsSize                           = 2
    PercentApproversSize                         = 1
    PrepareDriveHeaderSize                       = TransactionHeaderSize + KeySize + DurationSize + DurationSize + AmountSize + StorageSizeSize + ReplicasSize + MinReplicatorsSize + PercentApproversSize
    JoinToDriveHeaderSize                        = TransactionHeaderSize + KeySize
    AddActionsSize                               = 2
    RemoveActionsSize                            = 2
    DriveFileSystemHeaderSize                    = TransactionHeaderSize + KeySize + Hash256 + Hash256 + AddActionsSize + RemoveActionsSize
    FilesSizeSize                                = 2
    FilesDepositHeaderSize                       = TransactionHeaderSize + KeySize + FilesSizeSize
    EndDriveHeaderSize                           = TransactionHeaderSize + KeySize
    StartDriveVerificationHeaderSize             = TransactionHeaderSize + KeySize
    OfferTypeSize                                = 1
    OffersCountSize                              = 1
    AddExchangeOfferSize                         = MosaicIdSize + DurationSize + 2*AmountSize + OfferTypeSize
    AddExchangeOfferHeaderSize                   = TransactionHeaderSize + OffersCountSize
    ExchangeOfferSize                            = DurationSize + 2*AmountSize + OfferTypeSize + KeySize
    ExchangeOfferHeaderSize                      = TransactionHeaderSize + OffersCountSize
    RemoveExchangeOfferSize                      = OfferTypeSize + MosaicIdSize
    RemoveExchangeOfferHeaderSize                = TransactionHeaderSize + OffersCountSize
    StartFileDownloadHeaderSize                  = TransactionHeaderSize + 2 + KeySize
    EndFileDownloadHeaderSize                    = TransactionHeaderSize + 2 + KeySize + Hash256
    OperationIdentifyHeaderSize                  = TransactionHeaderSize + Hash256
    EndOperationHeaderSize                       = TransactionHeaderSize + 1 + Hash256 + 2
    DeployHeaderSize                             = TransactionHeaderSize + KeySize + KeySize + Hash256 + BaseInt64Size
    StartExecuteHeaderSize                       = TransactionHeaderSize + KeySize + 1 + 1 + 2
    DeactivateHeaderSize                         = TransactionHeaderSize + KeySize + KeySize
)

const EmptyPublicKey = "0000000000000000000000000000000000000000000000000000000000000000"

const NUM_CHECKSUM_BYTES = 4

const NamespaceBit uint64 = 1 << 63

const Supply_Mutable = 0x01

const TimestampNemesisBlockMilliseconds int64 = 1459468800 * 1000

const Transferable = 0x02

const (
    DefaultWebsocketReconnectionTimeout = time.Second * 5
    DefaultFeeCalculationStrategy       = MiddleCalculationStrategy
    DefaultMaxFee                       = 5 * 1000000
)

Catapult REST API errors

var (
    ErrResourceNotFound              = newRespError("resource is not found")
    ErrArgumentNotValid              = newRespError("argument is not valid")
    ErrInvalidRequest                = newRespError("request is not valid")
    ErrInternalError                 = newRespError("response is nil")
    ErrNotAcceptedResponseStatusCode = newRespError("not accepted response status code")
)

Metadata errors

var (
    ErrMetadataEmptyAddresses    = errors.New("list adresses ids must not by empty")
    ErrMetadataNilAdress         = errors.New("adress must not be blank")
    ErrMetadataEmptyMosaicIds    = errors.New("list mosaics ids must not by empty")
    ErrMetadataNilMosaicId       = errors.New("mosaicId must not be nil")
    ErrMetadataEmptyNamespaceIds = errors.New("list namespaces ids must not by empty")
    ErrMetadataNilNamespaceId    = errors.New("namespaceId must not be nil")
)

Common errors

var (
    ErrNilAssetId             = errors.New("AssetId should not be nil")
    ErrEmptyAssetIds          = errors.New("AssetId's array should not be empty")
    ErrUnknownBlockchainType  = errors.New("Not supported Blockchain Type")
    ErrInvalidHashLength      = errors.New("The length of Hash is invalid")
    ErrInvalidSignatureLength = errors.New("The length of Signature is invalid")
)

Mosaic errors

var (
    ErrEmptyMosaicIds        = errors.New("list mosaics ids must not by empty")
    ErrNilMosaicId           = errors.New("mosaicId must not be nil")
    ErrWrongBitMosaicId      = errors.New("mosaicId has 64th bit")
    ErrInvalidOwnerPublicKey = errors.New("public owner key is invalid")
    ErrNilMosaicProperties   = errors.New("mosaic properties must not be nil")
)

Namespace errors

var (
    ErrNamespaceTooManyPart = errors.New("too many parts")
    ErrNilNamespaceId       = errors.New("namespaceId is nil or zero")
    ErrWrongBitNamespaceId  = errors.New("namespaceId doesn't have 64th bit")
    ErrEmptyNamespaceIds    = errors.New("list namespace ids must not by empty")
    ErrInvalidNamespaceName = errors.New("namespace name is invalid")
)

Blockchain errors

var (
    ErrNilOrZeroHeight = errors.New("block height should not be nil or zero")
    ErrNilOrZeroLimit  = errors.New("limit should not be nil or zero")
)

Lock errors

var (
    ErrNilSecret = errors.New("Secret should not be nil")
    ErrNilProof  = errors.New("Proof should not be nil")
)

plain errors

var (
    ErrEmptyAddressesIds = errors.New("list of addresses should not be empty")
    ErrNilAddress        = errors.New("address is nil")
    ErrNilHash           = errors.New("hash is nil")
    ErrNilHashes         = errors.New("hashes are nil")
    ErrBlankAddress      = errors.New("address is blank")
    ErrNilAccount        = errors.New("account should not be nil")
    ErrInvalidAddress    = errors.New("wrong address")
    ErrNoChanges         = errors.New("transaction should contain changes")
)

reputations error

var (
    ErrInvalidReputationConfig = errors.New("default reputation should be greater than 0 and less than 1")
)

mosaic id for XEM mosaic

var XemMosaicId, _ = NewMosaicId(0x0DC67FBE1CAD29E3)

mosaic id for XPX mosaic

var XpxMosaicId, _ = NewMosaicId(0x0DC67FBE1CAD29E3)

func ExtractVersion

func ExtractVersion(version uint64) uint8

func GenerateChecksum

func GenerateChecksum(b []byte) ([]byte, error)

func NewReputationConfig

func NewReputationConfig(minInter uint64, defaultRep float64) (*reputationConfig, error)

type AbstractTransaction

type AbstractTransaction struct {
    TransactionInfo
    NetworkType NetworkType    `json:"network_type"`
    Deadline    *Deadline      `json:"deadline"`
    Type        EntityType     `json:"entity_type"`
    Version     EntityVersion  `json:"version"`
    MaxFee      Amount         `json:"max_fee"`
    Signature   string         `json:"signature"`
    Signer      *PublicAccount `json:"signer"`
}

func (*AbstractTransaction) HasMissingSignatures

func (tx *AbstractTransaction) HasMissingSignatures() bool

func (*AbstractTransaction) IsConfirmed

func (tx *AbstractTransaction) IsConfirmed() bool

func (*AbstractTransaction) IsUnannounced

func (tx *AbstractTransaction) IsUnannounced() bool

func (*AbstractTransaction) IsUnconfirmed

func (tx *AbstractTransaction) IsUnconfirmed() bool

func (*AbstractTransaction) String

func (tx *AbstractTransaction) String() string

func (*AbstractTransaction) ToAggregate

func (tx *AbstractTransaction) ToAggregate(signer *PublicAccount)

type Account

type Account struct {
	*PublicAccount
	*crypto.KeyPair
}

func NewAccount

func NewAccount(networkType NetworkType) (*Account, error)

returns new Account generated for passed NetworkType

func NewAccountFromPrivateKey

func NewAccountFromPrivateKey(pKey string, networkType NetworkType) (*Account, error)

returns new Account from private key for passed NetworkType

func (*Account) DecryptMessage

func (a *Account) DecryptMessage(encryptedMessage *SecureMessage, senderPublicAccount *PublicAccount) (*PlainMessage, error)

func (*Account) EncryptMessage

func (a *Account) EncryptMessage(message string, recipientPublicAccount *PublicAccount) (*SecureMessage, error)

func (*Account) Sign

func (a *Account) Sign(tx Transaction) (*SignedTransaction, error)

func (*Account) SignCosignatureTransaction

func (a *Account) SignCosignatureTransaction(tx *CosignatureTransaction) (*CosignatureSignedTransaction, error)

func (*Account) SignWithCosignatures

func (a *Account) SignWithCosignatures(tx *AggregateTransaction, cosignatories []*Account) (*SignedTransaction, error)

sign AggregateTransaction with current Account and with every passed cosignatory Account's returns announced Aggregate SignedTransaction

type AccountInfo

type AccountInfo struct {
	Address         *Address
	AddressHeight   Height
	PublicKey       string
	PublicKeyHeight Height
	AccountType     AccountType
	LinkedAccount   *PublicAccount
	Mosaics         []*Mosaic
	Reputation      float64
}

func (*AccountInfo) String

func (a *AccountInfo) String() string

type AccountLinkAction

type AccountLinkAction uint8

const (
	AccountLink AccountLinkAction = iota
	AccountUnlink
)

AccountLinkAction enums

type AccountLinkTransaction

type AccountLinkTransaction struct {
	AbstractTransaction
	RemoteAccount *PublicAccount
	LinkAction    AccountLinkAction
}

func NewAccountLinkTransaction

func NewAccountLinkTransaction(deadline *Deadline, remoteAccount *PublicAccount, linkAction AccountLinkAction, networkType NetworkType) (*AccountLinkTransaction, error)

returns AccountLinkTransaction from passed PublicAccount and AccountLinkAction

func (*AccountLinkTransaction) GetAbstractTransaction

func (tx *AccountLinkTransaction) GetAbstractTransaction() *AbstractTransaction

func (*AccountLinkTransaction) Size

func (tx *AccountLinkTransaction) Size() int

func (*AccountLinkTransaction) String

func (tx *AccountLinkTransaction) String() string

type AccountProperties

type AccountProperties struct {
	Address            *Address
	AllowedAddresses   []*Address
	AllowedMosaicId    []*MosaicId
	AllowedEntityTypes []EntityType
	BlockedAddresses   []*Address
	BlockedMosaicId    []*MosaicId
	BlockedEntityTypes []EntityType
}

func (*AccountProperties) String

func (a *AccountProperties) String() string

type AccountPropertiesAddressModification

type AccountPropertiesAddressModification struct {
	ModificationType PropertyModificationType
	Address          *Address
}

func (*AccountPropertiesAddressModification) String

func (mod *AccountPropertiesAddressModification) String() string

type AccountPropertiesAddressTransaction

type AccountPropertiesAddressTransaction struct {
	AbstractTransaction
	PropertyType  PropertyType
	Modifications []*AccountPropertiesAddressModification
}

func NewAccountPropertiesAddressTransaction

func NewAccountPropertiesAddressTransaction(deadline *Deadline, propertyType PropertyType,
	modifications []*AccountPropertiesAddressModification, networkType NetworkType) (*AccountPropertiesAddressTransaction, error)

returns AccountPropertiesAddressTransaction from passed PropertyType and AccountPropertiesAddressModification's

func (*AccountPropertiesAddressTransaction) GetAbstractTransaction

func (tx *AccountPropertiesAddressTransaction) GetAbstractTransaction() *AbstractTransaction

func (*AccountPropertiesAddressTransaction) Size

func (tx *AccountPropertiesAddressTransaction) Size() int

func (*AccountPropertiesAddressTransaction) String

func (tx *AccountPropertiesAddressTransaction) String() string

type AccountPropertiesEntityTypeModification

type AccountPropertiesEntityTypeModification struct {
	ModificationType PropertyModificationType
	EntityType       EntityType
}

func (*AccountPropertiesEntityTypeModification) String

func (mod *AccountPropertiesEntityTypeModification) String() string

type AccountPropertiesEntityTypeTransaction

type AccountPropertiesEntityTypeTransaction struct {
	AbstractTransaction
	PropertyType  PropertyType
	Modifications []*AccountPropertiesEntityTypeModification
}

func NewAccountPropertiesEntityTypeTransaction

func NewAccountPropertiesEntityTypeTransaction(deadline *Deadline, propertyType PropertyType,
	modifications []*AccountPropertiesEntityTypeModification, networkType NetworkType) (*AccountPropertiesEntityTypeTransaction, error)

returns AccountPropertiesEntityTypeTransaction from passed PropertyType and AccountPropertiesEntityTypeModification's

func (*AccountPropertiesEntityTypeTransaction) GetAbstractTransaction

func (tx *AccountPropertiesEntityTypeTransaction) GetAbstractTransaction() *AbstractTransaction

func (*AccountPropertiesEntityTypeTransaction) Size

func (tx *AccountPropertiesEntityTypeTransaction) Size() int

func (*AccountPropertiesEntityTypeTransaction) String

func (tx *AccountPropertiesEntityTypeTransaction) String() string

type AccountPropertiesMosaicModification

type AccountPropertiesMosaicModification struct {
	ModificationType PropertyModificationType
	AssetId          AssetId
}

func (*AccountPropertiesMosaicModification) String

func (mod *AccountPropertiesMosaicModification) String() string

type AccountPropertiesMosaicTransaction

type AccountPropertiesMosaicTransaction struct {
	AbstractTransaction
	PropertyType  PropertyType
	Modifications []*AccountPropertiesMosaicModification
}

func NewAccountPropertiesMosaicTransaction

func NewAccountPropertiesMosaicTransaction(deadline *Deadline, propertyType PropertyType,
	modifications []*AccountPropertiesMosaicModification, networkType NetworkType) (*AccountPropertiesMosaicTransaction, error)

returns AccountPropertiesMosaicTransaction from passed PropertyType and AccountPropertiesMosaicModification's

func (*AccountPropertiesMosaicTransaction) GetAbstractTransaction

func (tx *AccountPropertiesMosaicTransaction) GetAbstractTransaction() *AbstractTransaction

func (*AccountPropertiesMosaicTransaction) Size

func (tx *AccountPropertiesMosaicTransaction) Size() int

func (*AccountPropertiesMosaicTransaction) String

func (tx *AccountPropertiesMosaicTransaction) String() string

type AccountService

type AccountService service

func (*AccountService) AggregateBondedTransactions

func (a *AccountService) AggregateBondedTransactions(ctx context.Context, account *PublicAccount, opt *AccountTransactionsOption) ([]*AggregateTransaction, error)

returns an array of AggregateTransaction's where passed account is signer or cosigner

func (*AccountService) GetAccountInfo

func (a *AccountService) GetAccountInfo(ctx context.Context, address *Address) (*AccountInfo, error)

func (*AccountService) GetAccountProperties

func (a *AccountService) GetAccountProperties(ctx context.Context, address *Address) (*AccountProperties, error)

func (*AccountService) GetAccountsInfo

func (a *AccountService) GetAccountsInfo(ctx context.Context, addresses ...*Address) ([]*AccountInfo, error)

func (*AccountService) GetAccountsProperties

func (a *AccountService) GetAccountsProperties(ctx context.Context, addresses ...*Address) ([]*AccountProperties, error)

func (*AccountService) GetMultisigAccountGraphInfo

func (a *AccountService) GetMultisigAccountGraphInfo(ctx context.Context, address *Address) (*MultisigAccountGraphInfo, error)

func (*AccountService) GetMultisigAccountInfo

func (a *AccountService) GetMultisigAccountInfo(ctx context.Context, address *Address) (*MultisigAccountInfo, error)

func (*AccountService) IncomingTransactions

func (a *AccountService) IncomingTransactions(ctx context.Context, account *PublicAccount, opt *AccountTransactionsOption) ([]Transaction, error)

returns an array of Transaction's for which passed account is receiver

func (*AccountService) OutgoingTransactions

func (a *AccountService) OutgoingTransactions(ctx context.Context, account *PublicAccount, opt *AccountTransactionsOption) ([]Transaction, error)

returns an array of Transaction's for which passed account is sender

func (*AccountService) GetAccountNames

func (ref *AccountService) GetAccountNames(ctx context.Context, addresses ...*Address) ([]*AccountName, error)

returns friendly names for accounts.

func (*AccountService) Transactions

func (a *AccountService) Transactions(ctx context.Context, account *PublicAccount, opt *AccountTransactionsOption) ([]Transaction, error)

returns an array of confirmed Transaction's for which passed account is sender or receiver.

func (*AccountService) UnconfirmedTransactions

func (a *AccountService) UnconfirmedTransactions(ctx context.Context, account *PublicAccount, opt *AccountTransactionsOption) ([]Transaction, error)

returns an array of confirmed Transaction's for which passed account is sender or receiver. unconfirmed transactions are those transactions that have not yet been included in a block. they are not guaranteed to be included in any block.

type AccountTransactionsOption

type AccountTransactionsOption struct {
	PageSize int              `url:"pageSize,omitempty"`
	Id       string           `url:"id,omitempty"`
	Ordering TransactionOrder `url:"ordering,omitempty"`
}

type AccountType

type AccountType uint8

const (
	UnlinkedAccount AccountType = iota
	MainAccount
	RemoteAccount
	RemoteUnlinkedAccount
)

AccountType enums

type Address

type Address struct {
	Type    NetworkType
	Address string
}

func EncodedStringToAddresses

func EncodedStringToAddresses(addresses ...string) ([]*Address, error)

func NewAddress

func NewAddress(address string, networkType NetworkType) *Address

returns Address from passed address string for passed NetworkType

func NewAddressFromBase32

func NewAddressFromBase32(encoded string) (*Address, error)

func NewAddressFromNamespace

func NewAddressFromNamespace(namespaceId *NamespaceId) (*Address, error)

returns new Address from namespace identifier

func NewAddressFromPublicKey

func NewAddressFromPublicKey(pKey string, networkType NetworkType) (*Address, error)

returns an Address from public key for passed NetworkType

func NewAddressFromRaw

func NewAddressFromRaw(address string) (*Address, error)

returns Address from passed address string

func (*Address) Pretty

func (ad *Address) Pretty() string

func (*Address) String

func (ad *Address) String() string

type AddressAliasTransaction

type AddressAliasTransaction struct {
	AliasTransaction
	Address *Address
}

func NewAddressAliasTransaction

func NewAddressAliasTransaction(deadline *Deadline, address *Address, namespaceId *NamespaceId, actionType AliasActionType, networkType NetworkType) (*AddressAliasTransaction, error)

returns AddressAliasTransaction from passed Address, NamespaceId and AliasActionType

func (*AddressAliasTransaction) Size

func (tx *AddressAliasTransaction) Size() int

func (*AddressAliasTransaction) String

func (tx *AddressAliasTransaction) String() string

type AddressMetadataInfo

type AddressMetadataInfo struct {
	MetadataInfo
	Address *Address
}

type AggregateTransaction

type AggregateTransaction struct {
	AbstractTransaction
	InnerTransactions []Transaction
	Cosignatures      []*AggregateTransactionCosignature
}

func NewBondedAggregateTransaction

func NewBondedAggregateTransaction(deadline *Deadline, innerTxs []Transaction, networkType NetworkType) (*AggregateTransaction, error)

returns bounded AggregateTransaction from passed array of transactions to be included in

func NewCompleteAggregateTransaction

func NewCompleteAggregateTransaction(deadline *Deadline, innerTxs []Transaction, networkType NetworkType) (*AggregateTransaction, error)

returns complete AggregateTransaction from passed array of own Transaction's to be included in

func (*AggregateTransaction) GetAbstractTransaction

func (tx *AggregateTransaction) GetAbstractTransaction() *AbstractTransaction

func (*AggregateTransaction) Size

func (tx *AggregateTransaction) Size() int

func (*AggregateTransaction) String

func (tx *AggregateTransaction) String() string

type AggregateTransactionCosignature

type AggregateTransactionCosignature struct {
	Signature string
	Signer    *PublicAccount
}

func (*AggregateTransactionCosignature) String

func (agt *AggregateTransactionCosignature) String() string

type AliasActionType

type AliasActionType uint8

const (
	AliasLink AliasActionType = iota
	AliasUnlink
)

AliasActionType enums

type AliasTransaction

type AliasTransaction struct {
	AbstractTransaction
	ActionType  AliasActionType
	NamespaceId *NamespaceId
}

func (*AliasTransaction) GetAbstractTransaction

func (tx *AliasTransaction) GetAbstractTransaction() *AbstractTransaction

func (*AliasTransaction) Size

func (tx *AliasTransaction) Size() int

func (*AliasTransaction) String

func (tx *AliasTransaction) String() string

type AliasType

type AliasType uint8

const (
	NoneAliasType AliasType = iota
	MosaicAliasType
	AddressAliasType
)

AliasType enums

type Amount

type Amount = baseInt64

type AssetId

type AssetId interface {
	fmt.Stringer
	Type() AssetIdType
	Id() uint64
	Equals(AssetId) bool
	// contains filtered or unexported methods
}

type AssetIdType

type AssetIdType uint8

const (
	NamespaceAssetIdType AssetIdType = iota
	MosaicAssetIdType
)

AssetIdType enums

type BlockInfo

type BlockInfo struct {
	NetworkType
	Hash                  string
	GenerationHash        string
	TotalFee              Amount
	NumTransactions       uint64
	Signature             string
	Signer                *PublicAccount
	Version               uint8
	Type                  uint64
	Height                Height
	Timestamp             *Timestamp
	Difficulty            Difficulty
	FeeMultiplier         uint32
	PreviousBlockHash     string
	BlockTransactionsHash string
	BlockReceiptsHash     string
	StateHash             string
	Beneficiary           *PublicAccount
}

func MapBlock

func MapBlock(m []byte) (*BlockInfo, error)

func (*BlockInfo) String

func (b *BlockInfo) String() string

type BlockMapper

type BlockMapper interface {
	MapBlock(m []byte) (*BlockInfo, error)
}

type BlockMapperFn

type BlockMapperFn func(m []byte) (*BlockInfo, error)

func (BlockMapperFn) MapBlock

func (p BlockMapperFn) MapBlock(m []byte) (*BlockInfo, error)

type BlockchainService

type BlockchainService service

func (*BlockchainService) GetBlockByHeight

func (b *BlockchainService) GetBlockByHeight(ctx context.Context, height Height) (*BlockInfo, error)

returns BlockInfo for passed block's height

func (*BlockchainService) GetBlockTransactions

func (b *BlockchainService) GetBlockTransactions(ctx context.Context, height Height) ([]Transaction, error)

returns Transaction's inside of block at passed height

func (*BlockchainService) GetBlockchainHeight

func (b *BlockchainService) GetBlockchainHeight(ctx context.Context) (Height, error)

func (*BlockchainService) GetBlockchainScore

func (b *BlockchainService) GetBlockchainScore(ctx context.Context) (*ChainScore, error)

func (*BlockchainService) GetBlockchainStorage

func (b *BlockchainService) GetBlockchainStorage(ctx context.Context) (*BlockchainStorageInfo, error)

func (*BlockchainService) GetBlocksByHeightWithLimit

func (b *BlockchainService) GetBlocksByHeightWithLimit(ctx context.Context, height Height, limit Amount) ([]*BlockInfo, error)

returns BlockInfo's for range block height - (block height + limit) Example: GetBlocksByHeightWithLimit(ctx, 1, 25) => [BlockInfo25, BlockInfo24, ..., BlockInfo1]

type BlockchainStorageInfo

type BlockchainStorageInfo struct {
	NumBlocks       int `json:"numBlocks"`
	NumTransactions int `json:"numTransactions"`
	NumAccounts     int `json:"numAccounts"`
}

func (*BlockchainStorageInfo) String

func (b *BlockchainStorageInfo) String() string

type BlockchainTimestamp

type BlockchainTimestamp struct {
}

func NewBlockchainTimestamp

func NewBlockchainTimestamp(milliseconds int64) *BlockchainTimestamp

returns new BlockchainTimestamp from passed milliseconds value

func (BlockchainTimestamp) String

func (m BlockchainTimestamp) String() string

func (*BlockchainTimestamp) ToTimestamp

func (t *BlockchainTimestamp) ToTimestamp() *Timestamp

type ChainScore

type ChainScore [2]uint64

func NewChainScore

func NewChainScore(scoreLow uint64, scoreHigh uint64) *ChainScore

returns new ChainScore from passed low and high score

func (*ChainScore) String

func (m *ChainScore) String() string

type Client

type Client struct {

	// Services for communicating to the Catapult REST APIs
	Blockchain  *BlockchainService
	Mosaic      *MosaicService
	Namespace   *NamespaceService
	Network     *NetworkService
	Transaction *TransactionService
	Resolve     *ResolverService
	Account     *AccountService
	Contract    *ContractService
	Metadata    *MetadataService
}

Catapult API Client configuration

func NewClient

func NewClient(httpClient *http.Client, conf *Config) *Client

returns catapult http.Client from passed existing client and configuration if passed client is nil, http.DefaultClient will be used

type Config

type Config struct {
	BaseURLs              []*url.URL
	UsedBaseUrl           *url.URL
	WsReconnectionTimeout time.Duration
	NetworkType
}

Provides service configuration

func NewConfig

func NewConfig(baseUrls []string, networkType NetworkType, wsReconnectionTimeout time.Duration) (*Config, error)

returns config for HTTP Client from passed node url and network type

func NewConfigWithReputation

func NewConfigWithReputation(baseUrls []string, networkType NetworkType, repConf *reputationConfig, wsReconnectionTimeout time.Duration) (*Config, error)

type ConfirmedAddedMapper

type ConfirmedAddedMapper interface {
	MapConfirmedAdded(m []byte) (Transaction, error)
}

func NewConfirmedAddedMapper

func NewConfirmedAddedMapper(mapTransactionFunc mapTransactionFunc) ConfirmedAddedMapper

type ContractInfo

type ContractInfo struct {
	Multisig        string
	MultisigAddress *Address
	Start           Height
	Duration        Duration
	Content         string
	Customers       []string
	Executors       []string
	Verifiers       []string
}

type ContractService

type ContractService service

func (*ContractService) GetContractsByAddress

func (ref *ContractService) GetContractsByAddress(ctx context.Context, address string) ([]*ContractInfo, error)

func (*ContractService) GetContractsInfo

func (ref *ContractService) GetContractsInfo(ctx context.Context, contractPubKeys ...string) ([]*ContractInfo, error)

type CosignatureMapper

type CosignatureMapper interface {
	MapCosignature(m []byte) (*SignerInfo, error)
}

type CosignatureMapperFn

type CosignatureMapperFn func(m []byte) (*SignerInfo, error)

func (CosignatureMapperFn) MapCosignature

func (p CosignatureMapperFn) MapCosignature(m []byte) (*SignerInfo, error)

type CosignatureSignedTransaction

type CosignatureSignedTransaction struct {
	ParentHash Hash   `json:"parentHash"`
	Signature  string `json:"signature"`
	Signer     string `json:"signer"`
}

type CosignatureTransaction

type CosignatureTransaction struct {
	TransactionToCosign *AggregateTransaction
}

func NewCosignatureTransaction

func NewCosignatureTransaction(txToCosign *AggregateTransaction) (*CosignatureTransaction, error)

returns a CosignatureTransaction from passed AggregateTransaction

func NewCosignatureTransactionFromHash

func NewCosignatureTransactionFromHash(hash Hash) *CosignatureTransaction

returns a CosignatureTransaction from passed hash of bounded AggregateTransaction

func (*CosignatureTransaction) String

func (tx *CosignatureTransaction) String() string

type Deadline

type Deadline struct {
	Timestamp
}

func NewDeadline

func NewDeadline(delta time.Duration) *Deadline

returns new Deadline from passed duration

func NewDeadlineFromBlockchainTimestamp

func NewDeadlineFromBlockchainTimestamp(timestamp *BlockchainTimestamp) *Deadline

returns new Deadline from passed BlockchainTimestamp

type Difficulty

type Difficulty = baseInt64

type Duration

type Duration = baseInt64

type Hash

type Hash string

func (Hash) String

func (h Hash) String() string

type HashType

type HashType uint8

const (
	/// Input is hashed using Sha-3-256.
	SHA3_256 HashType = iota
	/// Input is hashed using Keccak-256.
	KECCAK_256
	/// Input is hashed twice: first with SHA-256 and then with RIPEMD-160.
	HASH_160
	/// Input is hashed twice with SHA-256.
	SHA_256
)

func (HashType) String

func (ht HashType) String() string

type Height

type Height = baseInt64

type HttpError

type HttpError struct {
	StatusCode int
}

type LockFundsTransaction

type LockFundsTransaction struct {
	AbstractTransaction
	*Mosaic
	Duration Duration
	*SignedTransaction
}

func NewLockFundsTransaction

func NewLockFundsTransaction(deadline *Deadline, mosaic *Mosaic, duration Duration, signedTx *SignedTransaction, networkType NetworkType) (*LockFundsTransaction, error)

returns a LockFundsTransaction from passed Mosaic, duration in blocks and SignedTransaction

func (*LockFundsTransaction) GetAbstractTransaction

func (tx *LockFundsTransaction) GetAbstractTransaction() *AbstractTransaction

func (*LockFundsTransaction) Size

func (tx *LockFundsTransaction) Size() int

func (*LockFundsTransaction) String

func (tx *LockFundsTransaction) String() string

type Message

type Message interface {
	Type() MessageType
	Payload() []byte
	String() string
}

type MessageType

type MessageType uint8

const (
	PlainMessageType MessageType = iota
	SecureMessageType
)

type MetadataInfo

type MetadataInfo struct {
	MetadataType MetadataType
	Fields       map[string]string
}

type MetadataModification

type MetadataModification struct {
	Type  MetadataModificationType
	Key   string
	Value string
}

func (*MetadataModification) Size

func (m *MetadataModification) Size() int

func (*MetadataModification) String

func (m *MetadataModification) String() string

type MetadataModificationType

type MetadataModificationType uint8

const (
	AddMetadata MetadataModificationType = iota
	RemoveMetadata
)

func (MetadataModificationType) String

func (t MetadataModificationType) String() string

type MetadataService

type MetadataService service

func (*MetadataService) GetAddressMetadatasInfo

func (ref *MetadataService) GetAddressMetadatasInfo(ctx context.Context, addresses ...string) ([]*AddressMetadataInfo, error)

func (*MetadataService) GetMetadataByAddress

func (ref *MetadataService) GetMetadataByAddress(ctx context.Context, address string) (*AddressMetadataInfo, error)

func (*MetadataService) GetMetadataByMosaicId

func (ref *MetadataService) GetMetadataByMosaicId(ctx context.Context, mosaicId *MosaicId) (*MosaicMetadataInfo, error)

func (*MetadataService) GetMetadataByNamespaceId

func (ref *MetadataService) GetMetadataByNamespaceId(ctx context.Context, namespaceId *NamespaceId) (*NamespaceMetadataInfo, error)

func (*MetadataService) GetMosaicMetadatasInfo

func (ref *MetadataService) GetMosaicMetadatasInfo(ctx context.Context, mosaicIds ...*MosaicId) ([]*MosaicMetadataInfo, error)

func (*MetadataService) GetNamespaceMetadatasInfo

func (ref *MetadataService) GetNamespaceMetadatasInfo(ctx context.Context, namespaceIds ...*NamespaceId) ([]*NamespaceMetadataInfo, error)

type MetadataType

type MetadataType uint8

const (
	MetadataNone MetadataType = iota
	MetadataAddressType
	MetadataMosaicType
	MetadataNamespaceType
)

func (MetadataType) String

func (t MetadataType) String() string

type ModifyContractTransaction

type ModifyContractTransaction struct {
	AbstractTransaction
	DurationDelta Duration
	Hash          string
	Customers     []*MultisigCosignatoryModification
	Executors     []*MultisigCosignatoryModification
	Verifiers     []*MultisigCosignatoryModification
}

func NewModifyContractTransaction

func NewModifyContractTransaction(
	deadline *Deadline, durationDelta Duration, hash string,
	customers []*MultisigCosignatoryModification,
	executors []*MultisigCosignatoryModification,
	verifiers []*MultisigCosignatoryModification,
	networkType NetworkType) (*ModifyContractTransaction, error)

returns ModifyContractTransaction from passed duration delta in blocks, file hash, arrays of customers, replicators and verificators

func (*ModifyContractTransaction) GetAbstractTransaction

func (tx *ModifyContractTransaction) GetAbstractTransaction() *AbstractTransaction

func (*ModifyContractTransaction) Size

func (tx *ModifyContractTransaction) Size() int

func (*ModifyContractTransaction) String

func (tx *ModifyContractTransaction) String() string

type ModifyMetadataAddressTransaction

type ModifyMetadataAddressTransaction struct {
	ModifyMetadataTransaction
	Address *Address
}

func NewModifyMetadataAddressTransaction

func NewModifyMetadataAddressTransaction(deadline *Deadline, address *Address, modifications []*MetadataModification, networkType NetworkType) (*ModifyMetadataAddressTransaction, error)

returns ModifyMetadataAddressTransaction from passed Address to be modified, and an array of MetadataModification's

func (*ModifyMetadataAddressTransaction) Size

func (tx *ModifyMetadataAddressTransaction) Size() int

func (*ModifyMetadataAddressTransaction) String

func (tx *ModifyMetadataAddressTransaction) String() string

type ModifyMetadataMosaicTransaction

type ModifyMetadataMosaicTransaction struct {
	ModifyMetadataTransaction
	MosaicId *MosaicId
}

func NewModifyMetadataMosaicTransaction

func NewModifyMetadataMosaicTransaction(deadline *Deadline, mosaicId *MosaicId, modifications []*MetadataModification, networkType NetworkType) (*ModifyMetadataMosaicTransaction, error)

returns ModifyMetadataMosaicTransaction from passed MosaicId to be modified, and an array of MetadataModification's

func (*ModifyMetadataMosaicTransaction) Size

func (tx *ModifyMetadataMosaicTransaction) Size() int

func (*ModifyMetadataMosaicTransaction) String

func (tx *ModifyMetadataMosaicTransaction) String() string

type ModifyMetadataNamespaceTransaction

type ModifyMetadataNamespaceTransaction struct {
	ModifyMetadataTransaction
	NamespaceId *NamespaceId
}

func NewModifyMetadataNamespaceTransaction

func NewModifyMetadataNamespaceTransaction(deadline *Deadline, namespaceId *NamespaceId, modifications []*MetadataModification, networkType NetworkType) (*ModifyMetadataNamespaceTransaction, error)

returns ModifyMetadataNamespaceTransaction from passed NamespaceId to be modified, and an array of MetadataModification's

func (*ModifyMetadataNamespaceTransaction) Size

func (tx *ModifyMetadataNamespaceTransaction) Size() int

func (*ModifyMetadataNamespaceTransaction) String

func (tx *ModifyMetadataNamespaceTransaction) String() string

type ModifyMetadataTransaction

type ModifyMetadataTransaction struct {
	AbstractTransaction
	MetadataType  MetadataType
	Modifications []*MetadataModification
}

func (*ModifyMetadataTransaction) GetAbstractTransaction

func (tx *ModifyMetadataTransaction) GetAbstractTransaction() *AbstractTransaction

func (*ModifyMetadataTransaction) Size

func (tx *ModifyMetadataTransaction) Size() int

func (*ModifyMetadataTransaction) String

func (tx *ModifyMetadataTransaction) String() string

type ModifyMultisigAccountTransaction

type ModifyMultisigAccountTransaction struct {
	AbstractTransaction
	MinApprovalDelta int8
	MinRemovalDelta  int8
	Modifications    []*MultisigCosignatoryModification
}

func NewModifyMultisigAccountTransaction

func NewModifyMultisigAccountTransaction(deadline *Deadline, minApprovalDelta int8, minRemovalDelta int8, modifications []*MultisigCosignatoryModification, networkType NetworkType) (*ModifyMultisigAccountTransaction, error)

returns a ModifyMultisigAccountTransaction from passed min approval and removal deltas and array of MultisigCosignatoryModification's

func (*ModifyMultisigAccountTransaction) GetAbstractTransaction

func (tx *ModifyMultisigAccountTransaction) GetAbstractTransaction() *AbstractTransaction

func (*ModifyMultisigAccountTransaction) Size

func (tx *ModifyMultisigAccountTransaction) Size() int

func (*ModifyMultisigAccountTransaction) String

func (tx *ModifyMultisigAccountTransaction) String() string

type Mosaic

type Mosaic struct {
	AssetId AssetId
	Amount  Amount
}

func NewMosaic

func NewMosaic(assetId AssetId, amount Amount) (*Mosaic, error)

returns a Mosaic for passed AssetId and amount

func newMosaicPanic

func newMosaicPanic(assetId AssetId, amount Amount) *Mosaic

returns a Mosaic for passed AssetId and amount without validation of parameters

func Xem

func Xem(amount uint64) *Mosaic

returns XEM mosaic with passed amount

func XemRelative

func XemRelative(amount uint64) *Mosaic

returns XEM with actual passed amount

func Xpx

func Xpx(amount uint64) *Mosaic

returns XPX mosaic with passed amount

func XpxRelative

func XpxRelative(amount uint64) *Mosaic

returns XPX with actual passed amount

func (*Mosaic) String

func (m *Mosaic) String() string

type MosaicAliasTransaction

type MosaicAliasTransaction struct {
	AliasTransaction
	MosaicId *MosaicId
}

func NewMosaicAliasTransaction

func NewMosaicAliasTransaction(deadline *Deadline, mosaicId *MosaicId, namespaceId *NamespaceId, actionType AliasActionType, networkType NetworkType) (*MosaicAliasTransaction, error)

returns MosaicAliasTransaction from passed MosaicId, NamespaceId and AliasActionType

func (*MosaicAliasTransaction) Size

func (tx *MosaicAliasTransaction) Size() int

func (*MosaicAliasTransaction) String

func (tx *MosaicAliasTransaction) String() string

type MosaicDefinitionTransaction

type MosaicDefinitionTransaction struct {
	AbstractTransaction
	*MosaicProperties
	MosaicNonce uint32
	*MosaicId
}

func NewMosaicDefinitionTransaction

func NewMosaicDefinitionTransaction(deadline *Deadline, nonce uint32, ownerPublicKey string, mosaicProps *MosaicProperties, networkType NetworkType) (*MosaicDefinitionTransaction, error)

returns MosaicDefinitionTransaction from passed nonce, public key of announcer and MosaicProperties

func (*MosaicDefinitionTransaction) GetAbstractTransaction

func (tx *MosaicDefinitionTransaction) GetAbstractTransaction() *AbstractTransaction

func (*MosaicDefinitionTransaction) Size

func (tx *MosaicDefinitionTransaction) Size() int

func (*MosaicDefinitionTransaction) String

func (tx *MosaicDefinitionTransaction) String() string

type MosaicId

type MosaicId struct {
}

func NewMosaicId

func NewMosaicId(id uint64) (*MosaicId, error)

returns MosaicId for passed mosaic identifier

func NewMosaicIdFromNonceAndOwner

func NewMosaicIdFromNonceAndOwner(nonce uint32, ownerPublicKey string) (*MosaicId, error)

returns MosaicId for passed nonce and public key of mosaic owner

func newMosaicIdPanic

func newMosaicIdPanic(id uint64) *MosaicId

TODO

func (*MosaicId) Equals

func (m *MosaicId) Equals(id AssetId) bool

func (*MosaicId) Id

func (m *MosaicId) Id() uint64

func (*MosaicId) String

func (m *MosaicId) String() string

func (*MosaicId) Type

func (m *MosaicId) Type() AssetIdType

type MosaicInfo

type MosaicInfo struct {
	MosaicId   *MosaicId
	Supply     Amount
	Height     Height
	Owner      *PublicAccount
	Revision   uint32
	Properties *MosaicProperties
}

func (*MosaicInfo) String

func (m *MosaicInfo) String() string

type MosaicMetadataInfo

type MosaicMetadataInfo struct {
	MetadataInfo
	MosaicId *MosaicId
}

type MosaicName

type MosaicName struct {
	MosaicId *MosaicId
	Names    []string
}

func (*MosaicName) String

func (m *MosaicName) String() string

type MosaicProperties

type MosaicProperties struct {
	SupplyMutable bool
	Transferable  bool
	LevyMutable   bool
	Divisibility  uint8
	Duration      Duration
}

structure which includes several properties for defining mosaic SupplyMutable

is supply of defined mosaic can be changed in future Transferable - if this property is set to "false", only transfer transactions having the creator as sender or as recipient can transfer mosaics of that type. If set to "true" the mosaics can be transferred to and from arbitrary accounts LevyMutable - if this property is set to "true", whenever other users transact with your mosaic, owner gets a levy fee from them Divisibility - divisibility determines up to what decimal place the mosaic can be divided into Duration - duration in blocks mosaic will be available. After the renew mosaic is inactive and can be renewed

func NewMosaicProperties

func NewMosaicProperties(supplyMutable bool, transferable bool, levyMutable bool, divisibility uint8, duration Duration) *MosaicProperties

returns MosaicProperties from actual values

func (*MosaicProperties) String

func (mp *MosaicProperties) String() string

type MosaicService

type MosaicService service

func (*MosaicService) GetMosaicInfo

func (ref *MosaicService) GetMosaicInfo(ctx context.Context, mosaicId *MosaicId) (*MosaicInfo, error)

func (*MosaicService) GetMosaicInfos

func (ref *MosaicService) GetMosaicInfos(ctx context.Context, mscIds []*MosaicId) ([]*MosaicInfo, error)

func (*MosaicService) GetMosaicsNames

func (ref *MosaicService) GetMosaicsNames(ctx context.Context, mscIds ...*MosaicId) ([]*MosaicName, error)

GetMosaicsNames Get readable names for a set of mosaics post @/mosaic/names

type MosaicSupplyChangeTransaction

type MosaicSupplyChangeTransaction struct {
	AbstractTransaction
	MosaicSupplyType
	AssetId
	Delta Amount
}

func NewMosaicSupplyChangeTransaction

func NewMosaicSupplyChangeTransaction(deadline *Deadline, assetId AssetId, supplyType MosaicSupplyType, delta Duration, networkType NetworkType) (*MosaicSupplyChangeTransaction, error)

returns MosaicSupplyChangeTransaction from passed AssetId, MosaicSupplyTypeand supply delta

func (*MosaicSupplyChangeTransaction) GetAbstractTransaction

func (tx *MosaicSupplyChangeTransaction) GetAbstractTransaction() *AbstractTransaction

func (*MosaicSupplyChangeTransaction) Size

func (tx *MosaicSupplyChangeTransaction) Size() int

func (*MosaicSupplyChangeTransaction) String

func (tx *MosaicSupplyChangeTransaction) String() string

type MosaicSupplyType

type MosaicSupplyType uint8

const (
	Decrease MosaicSupplyType = iota
	Increase
)

func (MosaicSupplyType) String

func (tx MosaicSupplyType) String() string

type MultisigAccountGraphInfo

type MultisigAccountGraphInfo struct {
	MultisigAccounts map[int32][]*MultisigAccountInfo
}

type MultisigAccountInfo

type MultisigAccountInfo struct {
	Account          PublicAccount
	MinApproval      int32
	MinRemoval       int32
	Cosignatories    []*PublicAccount
	MultisigAccounts []*PublicAccount
}

func (*MultisigAccountInfo) String

func (ref *MultisigAccountInfo) String() string

type MultisigCosignatoryModification

type MultisigCosignatoryModification struct {
	Type MultisigCosignatoryModificationType
	*PublicAccount
}

func (*MultisigCosignatoryModification) String

func (m *MultisigCosignatoryModification) String() string

type MultisigCosignatoryModificationType

type MultisigCosignatoryModificationType uint8

const (
	Add MultisigCosignatoryModificationType = iota
	Remove
)

func (MultisigCosignatoryModificationType) String

func (t MultisigCosignatoryModificationType) String() string

type NamespaceAlias

type NamespaceAlias struct {
	Type AliasType
}

NamespaceAlias contains aliased mosaicId or address and type of alias

func (*NamespaceAlias) Address

func (ref *NamespaceAlias) Address() *Address

func (*NamespaceAlias) MosaicId

func (ref *NamespaceAlias) MosaicId() *MosaicId

func (*NamespaceAlias) String

func (ref *NamespaceAlias) String() string

type NamespaceId

type NamespaceId struct {
}

func GenerateNamespacePath

func GenerateNamespacePath(name string) ([]*NamespaceId, error)

returns an array of big ints representation if namespace ids from passed namespace path to create root namespace pass namespace name in format like 'rootname' to create child namespace pass namespace name in format like 'rootname.childname' to create grand child namespace pass namespace name in format like 'rootname.childname.grandchildname'

func NewNamespaceId

func NewNamespaceId(id uint64) (*NamespaceId, error)

returns new NamespaceId from passed namespace identifier

func NewNamespaceIdFromName

func NewNamespaceIdFromName(namespaceName string) (*NamespaceId, error)

returns namespace id from passed namespace name should be used for creating root, child and grandchild namespace ids to create root namespace pass namespace name in format like 'rootname' to create child namespace pass namespace name in format like 'rootname.childname' to create grand child namespace pass namespace name in format like 'rootname.childname.grandchildname'

func newNamespaceIdPanic

func newNamespaceIdPanic(id uint64) *NamespaceId

returns new NamespaceId from passed namespace identifier TODO

func (*NamespaceId) Equals

func (m *NamespaceId) Equals(id AssetId) bool

func (*NamespaceId) Id

func (m *NamespaceId) Id() uint64

func (*NamespaceId) String

func (m *NamespaceId) String() string

func (*NamespaceId) Type

func (m *NamespaceId) Type() AssetIdType

type NamespaceInfo

type NamespaceInfo struct {
	NamespaceId *NamespaceId
	Active      bool
	TypeSpace   NamespaceType
	Depth       int
	Levels      []*NamespaceId
	Alias       *NamespaceAlias
	Parent      *NamespaceInfo
	Owner       *PublicAccount
	StartHeight Height
	EndHeight   Height
}

func (*NamespaceInfo) String

func (ref *NamespaceInfo) String() string

type NamespaceMetadataInfo

type NamespaceMetadataInfo struct {
	MetadataInfo
	NamespaceId *NamespaceId
}

type NamespaceName

type NamespaceName struct {
	NamespaceId *NamespaceId
	Name        string
	ParentId    *NamespaceId /* Optional NamespaceId my be nil */
}

func (*NamespaceName) String

func (n *NamespaceName) String() string

type NamespaceService

type NamespaceService service

NamespaceService provides a set of methods for obtaining information about the namespace

func (*NamespaceService) GetLinkedAddress

func (ref *NamespaceService) GetLinkedAddress(ctx context.Context, namespaceId *NamespaceId) (*Address, error)

GetLinkedAddress @/namespace/%s

func (*NamespaceService) GetLinkedMosaicId

func (ref *NamespaceService) GetLinkedMosaicId(ctx context.Context, namespaceId *NamespaceId) (*MosaicId, error)

GetLinkedMosaicId @/namespace/%s

func (*NamespaceService) GetNamespaceInfo

func (ref *NamespaceService) GetNamespaceInfo(ctx context.Context, nsId *NamespaceId) (*NamespaceInfo, error)

func (*NamespaceService) GetNamespaceInfosFromAccount

func (ref *NamespaceService) GetNamespaceInfosFromAccount(ctx context.Context, address *Address, nsId *NamespaceId,
	pageSize int) ([]*NamespaceInfo, error)

returns NamespaceInfo's corresponding to passed Address and NamespaceId with maximum limit TODO: fix pagination

func (*NamespaceService) GetNamespaceInfosFromAccounts

func (ref *NamespaceService) GetNamespaceInfosFromAccounts(ctx context.Context, addrs []*Address, nsId *NamespaceId,
	pageSize int) ([]*NamespaceInfo, error)

returns NamespaceInfo's corresponding to passed Address's and NamespaceId with maximum limit TODO: fix pagination

func (*NamespaceService) GetNamespaceNames

func (ref *NamespaceService) GetNamespaceNames(ctx context.Context, nsIds []*NamespaceId) ([]*NamespaceName, error)

type NamespaceType

type NamespaceType uint8

const (
	Root NamespaceType = iota
	Sub
)

type NetworkService

type NetworkService service

func (*NetworkService) GetNetworkType

func (ref *NetworkService) GetNetworkType(ctx context.Context) (NetworkType, error)

type NetworkType

type NetworkType uint8

const (
	Mijin           NetworkType = 96
	MijinTest       NetworkType = 144
	Public          NetworkType = 184
	PublicTest      NetworkType = 168
	Private         NetworkType = 200
	PrivateTest     NetworkType = 176
	NotSupportedNet NetworkType = 0
	AliasAddress    NetworkType = 145
)

func ExtractNetworkType

func ExtractNetworkType(version uint64) NetworkType

func NetworkTypeFromString

func NetworkTypeFromString(networkType string) NetworkType

func (NetworkType) String

func (nt NetworkType) String() string

type PartialAddedMapper

type PartialAddedMapper interface {
	MapPartialAdded(m []byte) (*AggregateTransaction, error)
}

func NewPartialAddedMapper

func NewPartialAddedMapper(mapTransactionFunc mapTransactionFunc) PartialAddedMapper

type PartialRemovedInfo

type PartialRemovedInfo struct {
	Meta *TransactionInfo
}

func MapPartialRemoved

func MapPartialRemoved(m []byte) (*PartialRemovedInfo, error)

type PartialRemovedMapper

type PartialRemovedMapper interface {
	MapPartialRemoved(m []byte) (*PartialRemovedInfo, error)
}

type PartialRemovedMapperFn

type PartialRemovedMapperFn func(m []byte) (*PartialRemovedInfo, error)

func (PartialRemovedMapperFn) MapPartialRemoved

func (p PartialRemovedMapperFn) MapPartialRemoved(m []byte) (*PartialRemovedInfo, error)

type PlainMessage

type PlainMessage struct {
}

func NewPlainMessage

func NewPlainMessage(payload string) *PlainMessage

func NewPlainMessageFromEncodedData

func NewPlainMessageFromEncodedData(encodedData []byte, recipient *xpxcrypto.PrivateKey, sender *xpxcrypto.PublicKey) (*PlainMessage, error)

func (*PlainMessage) Message

func (m *PlainMessage) Message() string

func (*PlainMessage) Payload

func (m *PlainMessage) Payload() []byte

func (*PlainMessage) String

func (m *PlainMessage) String() string

func (*PlainMessage) Type

func (m *PlainMessage) Type() MessageType

type Proof

type Proof struct {
	Data []byte
}

func NewProofFromBytes

func NewProofFromBytes(proof []byte) *Proof

func NewProofFromHexString

func NewProofFromHexString(hexProof string) (*Proof, error)

func NewProofFromString

func NewProofFromString(proof string) *Proof

func NewProofFromUint16

func NewProofFromUint16(number uint16) *Proof

func NewProofFromUint32

func NewProofFromUint32(number uint32) *Proof

func NewProofFromUint64

func NewProofFromUint64(number uint64) *Proof

func NewProofFromUint8

func NewProofFromUint8(number uint8) *Proof

func (*Proof) ProofString

func (p *Proof) ProofString() string

bytes representation of Proof

func (*Proof) Secret

func (p *Proof) Secret(hashType HashType) (*Secret, error)

returns Secret generated from Proof with passed HashType

func (*Proof) Size

func (p *Proof) Size() int

bytes length of Proof

func (*Proof) String

func (p *Proof) String() string

type PropertyModificationType

type PropertyModificationType uint8

const (
	AddProperty PropertyModificationType = iota
	RemoveProperty
)

PropertyModificationType enums

type PropertyType

type PropertyType uint8

const (
	AllowAddress     PropertyType = 0x01
	AllowMosaic      PropertyType = 0x02
	AllowTransaction PropertyType = 0x04
	Sentinel         PropertyType = 0x05
	BlockAddress     PropertyType = 0x80 + 0x01
	BlockMosaic      PropertyType = 0x80 + 0x02
	BlockTransaction PropertyType = 0x80 + 0x04
)

Account property type 0x01 The property type is an address. 0x02 The property type is mosaic id. 0x04 The property type is a transaction type. 0x05 Property type sentinel. 0x80 + type The property is interpreted as a blocking operation.

type PublicAccount

type PublicAccount struct {
	Address   *Address
	PublicKey string
}

func NewAccountFromPublicKey

func NewAccountFromPublicKey(pKey string, networkType NetworkType) (*PublicAccount, error)

returns a PublicAccount from public key for passed NetworkType

func (*PublicAccount) String

func (ref *PublicAccount) String() string

type RegisterNamespaceTransaction

type RegisterNamespaceTransaction struct {
	AbstractTransaction
	*NamespaceId
	NamespaceType
	NamspaceName string
	Duration     Duration
	ParentId     *NamespaceId
}

func NewRegisterRootNamespaceTransaction

func NewRegisterRootNamespaceTransaction(deadline *Deadline, namespaceName string, duration Duration, networkType NetworkType) (*RegisterNamespaceTransaction, error)

returns a RegisterNamespaceTransaction from passed namespace name and duration in blocks

func NewRegisterSubNamespaceTransaction

func NewRegisterSubNamespaceTransaction(deadline *Deadline, namespaceName string, parentId *NamespaceId, networkType NetworkType) (*RegisterNamespaceTransaction, error)

returns a RegisterNamespaceTransaction from passed namespace name and parent NamespaceId

func (*RegisterNamespaceTransaction) GetAbstractTransaction

func (tx *RegisterNamespaceTransaction) GetAbstractTransaction() *AbstractTransaction

func (*RegisterNamespaceTransaction) Size

func (tx *RegisterNamespaceTransaction) Size() int

func (*RegisterNamespaceTransaction) String

func (tx *RegisterNamespaceTransaction) String() string

type ResolverService

type ResolverService struct {
	NamespaceService *NamespaceService
	MosaicService    *MosaicService
}

TODO: Implement resolving namespace to account

func (*ResolverService) GetMosaicInfoByAssetId

func (ref *ResolverService) GetMosaicInfoByAssetId(ctx context.Context, assetId AssetId) (*MosaicInfo, error)

func (*ResolverService) GetMosaicInfosByAssetIds

func (ref *ResolverService) GetMosaicInfosByAssetIds(ctx context.Context, assetIds ...AssetId) ([]*MosaicInfo, error)

type RespErr

type RespErr struct {
}

func (*RespErr) Error

func (r *RespErr) Error() string

type Secret

type Secret struct {
	Hash []byte
	Type HashType
}

func NewSecret

func NewSecret(hash []byte, hashType HashType) (*Secret, error)

returns Secret from passed hash and HashType

func NewSecretFromHexString

func NewSecretFromHexString(hash string, hashType HashType) (*Secret, error)

returns Secret from passed hex string hash and HashType

func (*Secret) HashString

func (s *Secret) HashString() string

func (*Secret) String

func (s *Secret) String() string

type SecretLockTransaction

type SecretLockTransaction struct {
	AbstractTransaction
	*Mosaic
	Duration  Duration
	Secret    *Secret
	Recipient *Address
}

func NewSecretLockTransaction

func NewSecretLockTransaction(deadline *Deadline, mosaic *Mosaic, duration Duration, secret *Secret, recipient *Address, networkType NetworkType) (*SecretLockTransaction, error)

returns a SecretLockTransaction from passed Mosaic, duration in blocks, Secret and mosaic recipient Address

func (*SecretLockTransaction) GetAbstractTransaction

func (tx *SecretLockTransaction) GetAbstractTransaction() *AbstractTransaction

func (*SecretLockTransaction) Size

func (tx *SecretLockTransaction) Size() int

func (*SecretLockTransaction) String

func (tx *SecretLockTransaction) String() string

type SecretProofTransaction

type SecretProofTransaction struct {
	AbstractTransaction
	HashType
	Proof *Proof
}

func NewSecretProofTransaction

func NewSecretProofTransaction(deadline *Deadline, hashType HashType, proof *Proof, networkType NetworkType) (*SecretProofTransaction, error)

returns a SecretProofTransaction from passed HashType and Proof

func (*SecretProofTransaction) GetAbstractTransaction

func (tx *SecretProofTransaction) GetAbstractTransaction() *AbstractTransaction

func (*SecretProofTransaction) Size

func (tx *SecretProofTransaction) Size() int

func (*SecretProofTransaction) String

func (tx *SecretProofTransaction) String() string

type SecureMessage

type SecureMessage struct {
}

func NewSecureMessage

func NewSecureMessage(encodedData []byte) *SecureMessage

func NewSecureMessageFromPlaintText

func NewSecureMessageFromPlaintText(plaintText string, sender *xpxcrypto.PrivateKey, recipient *xpxcrypto.PublicKey) (*SecureMessage, error)

func (*SecureMessage) Payload

func (m *SecureMessage) Payload() []byte

func (*SecureMessage) String

func (m *SecureMessage) String() string

func (*SecureMessage) Type

func (m *SecureMessage) Type() MessageType

type SignedTransaction

type SignedTransaction struct {
	EntityType `json:"transactionType"`
	Payload         string `json:"payload"`
	Hash            Hash   `json:"hash"`
}

type SignerInfo

type SignerInfo struct {
	Signer     string `json:"signer"`
	Signature  string `json:"signature"`
	ParentHash Hash   `json:"parentHash"`
}

func MapCosignature

func MapCosignature(m []byte) (*SignerInfo, error)

type StatusInfo

type StatusInfo struct {
	Status string `json:"status"`
	Hash   Hash   `json:"hash"`
}

func MapStatus

func MapStatus(m []byte) (*StatusInfo, error)

type StatusMapper

type StatusMapper interface {
	MapStatus(m []byte) (*StatusInfo, error)
}

type StatusMapperFn

type StatusMapperFn func(m []byte) (*StatusInfo, error)

func (StatusMapperFn) MapStatus

func (p StatusMapperFn) MapStatus(m []byte) (*StatusInfo, error)

type Timestamp

type Timestamp struct {
	time.Time
}

func NewTimestamp

func NewTimestamp(milliseconds int64) *Timestamp

returns new Timestamp from passed milliseconds value

func (*Timestamp) ToBlockchainTimestamp

func (t *Timestamp) ToBlockchainTimestamp() *BlockchainTimestamp

type Transaction

type Transaction interface {
	GetAbstractTransaction() *AbstractTransaction
	String() string
	// number of bytes of serialized transaction
	Size() int
	// contains filtered or unexported methods
}

func MapTransaction

func MapTransaction(b *bytes.Buffer) (Transaction, error)

func MapTransactions

func MapTransactions(b *bytes.Buffer) ([]Transaction, error)

type TransactionHashesDTO

type TransactionHashesDTO struct {
	Hashes []string `json:"hashes"`
}

type TransactionIdsDTO

type TransactionIdsDTO struct {
	Ids []string `json:"transactionIds"`
}

type TransactionInfo

type TransactionInfo struct {
	Height              Height
	Index               uint32
	Id                  string
	Hash                Hash
	MerkleComponentHash Hash
	AggregateHash       Hash
	AggregateId         string
}

func (*TransactionInfo) String

func (ti *TransactionInfo) String() string

type TransactionOrder

type TransactionOrder string

const (
	TRANSACTION_ORDER_ASC  TransactionOrder = "id"
	TRANSACTION_ORDER_DESC TransactionOrder = "-id"
)

type TransactionService

type TransactionService struct {
	BlockchainService *BlockchainService
}

func (*TransactionService) Announce

func (txs *TransactionService) Announce(ctx context.Context, tx *SignedTransaction) (string, error)

returns transaction hash after announcing passed SignedTransaction

func (*TransactionService) AnnounceAggregateBonded

func (txs *TransactionService) AnnounceAggregateBonded(ctx context.Context, tx *SignedTransaction) (string, error)

returns transaction hash after announcing passed aggregate bounded SignedTransaction

func (*TransactionService) AnnounceAggregateBondedCosignature

func (txs *TransactionService) AnnounceAggregateBondedCosignature(ctx context.Context, c *CosignatureSignedTransaction) (string, error)

returns transaction hash after announcing passed CosignatureSignedTransaction

func (*TransactionService) GetTransaction

func (txs *TransactionService) GetTransaction(ctx context.Context, id string) (Transaction, error)

returns Transaction for passed transaction id or hash

func (*TransactionService) GetTransactionEffectiveFee

func (txs *TransactionService) GetTransactionEffectiveFee(ctx context.Context, transactionId string) (int, error)

Gets a transaction's effective paid fee

func (*TransactionService) GetTransactionStatus

func (txs *TransactionService) GetTransactionStatus(ctx context.Context, id string) (*TransactionStatus, error)

returns TransactionStatus for passed transaction id or hash

func (*TransactionService) GetTransactionStatuses

func (txs *TransactionService) GetTransactionStatuses(ctx context.Context, hashes []string) ([]*TransactionStatus, error)

returns an array of TransactionStatus's for passed transaction ids or hashes

func (*TransactionService) GetTransactions

func (txs *TransactionService) GetTransactions(ctx context.Context, ids []string) ([]Transaction, error)

returns an array of Transaction's for passed array of transaction ids or hashes

type TransactionStatus

type TransactionStatus struct {
	Deadline *Deadline
	Group    string
	Status   string
	Hash     Hash
	Height   Height
}

func (*TransactionStatus) String

func (ts *TransactionStatus) String() string

type EntityType

type EntityType uint16

const (
    AccountPropertiesAddress       EntityType = 0x4150
    AccountPropertiesMosaic        EntityType = 0x4250
    AccountProperties              EntityType = 0x4350
    AddressAlias                   EntityType = 0x424e
    AggregateBonded                EntityType = 0x4241
    AggregateComplete              EntityType = 0x4141
    AddExchangeOffer               EntityType = 0x415D
    AddHarvester                   EntityType = 0x4161
    ExchangeOffer                  EntityType = 0x425D
    RemoveExchangeOffer            EntityType = 0x435D
    RemoveHarvester                EntityType = 0x4261
    RegularBlock                   EntityType = 0x8143
    NemesisBlock                   EntityType = 0x8043
    NetworkConfig                  EntityType = 0x4159
    BlockchainUpgrade              EntityType = 0x4158
    AccountLink                    EntityType = 0x414c
    HashLock                       EntityType = 0x4148
    MetadataAddress                EntityType = 0x413d
    MetadataMosaic                 EntityType = 0x423d
    MetadataNamespace              EntityType = 0x433d
    AccountMetadata                EntityType = 0x413f
    MosaicMetadata                 EntityType = 0x423f
    NamespaceMetadata              EntityType = 0x433f
    ModifyContract                 EntityType = 0x4157
    ModifyMultisig                 EntityType = 0x4155
    MosaicAlias                    EntityType = 0x434e
    MosaicDefinition               EntityType = 0x414d
    MosaicSupplyChange             EntityType = 0x424d
    MosaicModifyLevy               EntityType = 0x434d
    MosaicRemoveLevy               EntityType = 0x444d
    RegisterNamespace              EntityType = 0x414e
    SecretLock                     EntityType = 0x4152
    SecretProof                    EntityType = 0x4252
    Transfer                       EntityType = 0x4154
    ReplicatorOnboarding           EntityType = 0x4662
    ReplicatorsCleanup             EntityType = 0x4062
    ReplicatorTreeRebuild          EntityType = 0x4167
    PrepareBlockchainDrive         EntityType = 0x4162
    DataModification               EntityType = 0x4262
    DataModificationApproval       EntityType = 0x4462
    DataModificationSingleApproval EntityType = 0x4B62
    DataModificationCancel         EntityType = 0x4562
    StoragePayment                 EntityType = 0x4A62
    DownloadPayment                EntityType = 0x4962
    Download                       EntityType = 0x4362
    FinishDownload                 EntityType = 0x4862
    VerificationPayment            EntityType = 0x4C62
    EndDriveVerificationV2         EntityType = 0x4F62
    DownloadApproval               EntityType = 0x4D62
    DriveClosure                   EntityType = 0x4E62
    ReplicatorOffboarding          EntityType = 0x4762
    CreateLiquidityProvider        EntityType = 0x4168
    ManualRateChange               EntityType = 0x4268
)

func (EntityType) String

func (t EntityType) String() string

type EntityVersion

type EntityVersion uint8

const (
    AccountPropertyAddressVersion    EntityVersion = 1
    AccountPropertyMosaicVersion     EntityVersion = 1
    AccountPropertyEntityTypeVersion EntityVersion = 1
    AddressAliasVersion              EntityVersion = 1
    AggregateBondedVersion           EntityVersion = 3
    AggregateCompletedVersion        EntityVersion = 3
    AddExchangeOfferVersion          EntityVersion = 4
    ExchangeOfferVersion             EntityVersion = 2
    RemoveExchangeOfferVersion       EntityVersion = 2
    NetworkConfigVersion             EntityVersion = 1
    BlockchainUpgradeVersion         EntityVersion = 1
    LinkAccountVersion               EntityVersion = 2
    LockVersion                      EntityVersion = 1
    AccountMetadataVersion           EntityVersion = 1
    MosaicMetadataVersion            EntityVersion = 1
    NamespaceMetadataVersion         EntityVersion = 1
    MetadataAddressVersion           EntityVersion = 1
    MetadataMosaicVersion            EntityVersion = 1
    MetadataNamespaceVersion         EntityVersion = 1
    ModifyContractVersion            EntityVersion = 3
    ModifyMultisigVersion            EntityVersion = 3
    MosaicAliasVersion               EntityVersion = 1
    MosaicDefinitionVersion          EntityVersion = 3
    MosaicSupplyChangeVersion        EntityVersion = 2
    MosaicModifyLevyVersion          EntityVersion = 1
    MosaicRemoveLevyVersion          EntityVersion = 1
    RegisterNamespaceVersion         EntityVersion = 2
    SecretLockVersion                EntityVersion = 1
    SecretProofVersion               EntityVersion = 1
    TransferVersion                  EntityVersion = 3
    PrepareDriveVersion              EntityVersion = 3
    JoinToDriveVersion               EntityVersion = 1
    DriveFileSystemVersion           EntityVersion = 1
    FilesDepositVersion              EntityVersion = 1
    EndDriveVersion                  EntityVersion = 1
    DriveFilesRewardVersion          EntityVersion = 1
    StartDriveVerificationVersion    EntityVersion = 1
    EndDriveVerificationVersion      EntityVersion = 1
    StartFileDownloadVersion         EntityVersion = 1
    EndFileDownloadVersion           EntityVersion = 1
    DeployVersion                    EntityVersion = 1
    StartExecuteVersion              EntityVersion = 1
    EndExecuteVersion                EntityVersion = 1
    StartOperationVersion            EntityVersion = 1
    EndOperationVersion              EntityVersion = 1
    HarvesterVersion                 EntityVersion = 1
    OperationIdentifyVersion         EntityVersion = 1
    SuperContractFileSystemVersion   EntityVersion = 1
    DeactivateVersion                EntityVersion = 1
)

type TransferTransaction

type TransferTransaction struct {
	AbstractTransaction
	Message   Message
	Mosaics   []*Mosaic
	Recipient *Address
}

func NewTransferTransaction

func NewTransferTransaction(deadline *Deadline, recipient *Address, mosaics []*Mosaic, message Message, networkType NetworkType) (*TransferTransaction, error)

returns a TransferTransaction from passed transfer recipient Adderess, array of Mosaic's to transfer and transfer Message

func NewTransferTransactionWithNamespace

func NewTransferTransactionWithNamespace(deadline *Deadline, recipient *NamespaceId, mosaics []*Mosaic, message Message, networkType NetworkType) (*TransferTransaction, error)

returns TransferTransaction from passed recipient NamespaceId, Mosaic's and transfer Message

func (*TransferTransaction) GetAbstractTransaction

func (tx *TransferTransaction) GetAbstractTransaction() *AbstractTransaction

func (*TransferTransaction) MessageSize

func (tx *TransferTransaction) MessageSize() int

func (*TransferTransaction) Size

func (tx *TransferTransaction) Size() int

func (*TransferTransaction) String

func (tx *TransferTransaction) String() string

type UnconfirmedAddedMapper

type UnconfirmedAddedMapper interface {
	MapUnconfirmedAdded(m []byte) (Transaction, error)
}

func NewUnconfirmedAddedMapper

func NewUnconfirmedAddedMapper(mapTransactionFunc mapTransactionFunc) UnconfirmedAddedMapper

type UnconfirmedRemoved

type UnconfirmedRemoved struct {
	Meta *TransactionInfo
}

func MapUnconfirmedRemoved

func MapUnconfirmedRemoved(m []byte) (*UnconfirmedRemoved, error)

type UnconfirmedRemovedMapper

type UnconfirmedRemovedMapper interface {
	MapUnconfirmedRemoved(m []byte) (*UnconfirmedRemoved, error)
}

type UnconfirmedRemovedMapperFn

type UnconfirmedRemovedMapperFn func(m []byte) (*UnconfirmedRemoved, error)

func (UnconfirmedRemovedMapperFn) MapUnconfirmedRemoved

func (p UnconfirmedRemovedMapperFn) MapUnconfirmedRemoved(m []byte) (*UnconfirmedRemoved, error)

type VarSize

type VarSize uint32

const (
	ByteSize  VarSize = 1
	ShortSize VarSize = 2
	IntSize   VarSize = 4
)

type WsMessageInfo

type WsMessageInfo struct {
	Address     *Address
	ChannelName string
}

type WsMessageInfoDTO

type WsMessageInfoDTO struct {
	Meta wsMessageInfoMetaDTO `json:"meta"`
}

func (*WsMessageInfoDTO) ToStruct

func (dto *WsMessageInfoDTO) ToStruct() (*WsMessageInfo, error)

Files

api.md

Latest commit

History