sdk

package
v0.6.1-0...-c79f37a Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 11, 2020 License: Apache-2.0 Imports: 32 Imported by: 0

Documentation

Overview

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

Index

Constants

View Source 
const (
	DefaultWebsocketReconnectionTimeout = time.Second * 5
	DefaultFeeCalculationStrategy       = MiddleCalculationStrategy
	DefaultMaxFee                       = 5 * 1000000
)
View Source 
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
	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
	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
)
View Source 
const EmptyPublicKey = "0000000000000000000000000000000000000000000000000000000000000000"
View Source 
const NUM_CHECKSUM_BYTES = 4
View Source 
const NamespaceBit uint64 = 1 << 63
View Source 
const Supply_Mutable = 0x01
View Source 
const TimestampNemesisBlockMilliseconds int64 = 1459468800 * 1000
View Source 
const Transferable = 0x02

Variables

View Source 
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")
)

Catapult REST API errors

View Source 
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")
)

Metadata errors

View Source 
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")
)

Common errors

View Source 
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")
)

Mosaic errors

View Source 
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")
)

Namespace errors

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

Blockchain errors

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

Lock errors

View Source 
var (
	ErrEmptyAddressesIds = errors.New("list of addresses should not be empty")
	ErrNilAddress        = errors.New("address is nil")
	ErrNilHash           = errors.New("hash is 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")
)

plain errors

View Source 
var CreditNamespaceId, _ = NewNamespaceIdFromName("besc.myr")

namespace id for BESC credit mosaic

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

reputations error

View Source 
var NetworkNamespaceId, _ = NewNamespaceIdFromName("besc.epcc")

namespace id for BESC network mosaic

View Source 
var StorageNamespaceId, _ = NewNamespaceIdFromName("prx.so")

namespace id for storage mosaic

View Source 
var StreamingNamespaceId, _ = NewNamespaceIdFromName("prx.sm")

namespace id for streaming mosaic

View Source 
var SuperContractNamespaceId, _ = NewNamespaceIdFromName("prx.sc")

namespace id for suepr contract mosaic

View Source 
var XemNamespaceId, _ = NewNamespaceIdFromName("nem.xem")

namespace id for XEM mosaic

View Source 
var XpxNamespaceId, _ = NewNamespaceIdFromName("prx.xpx")

namespace id for XPX mosaic

Functions

func CompareInnerTransaction 

func CompareInnerTransaction(left []Transaction, right []Transaction) bool

func GenerateChecksum 

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

func NewReputationConfig 

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

Types

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) IsAnnounced 

func (tx *AbstractTransaction) IsAnnounced() 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
	// contains filtered or unexported fields
}

func NewAccount 

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

returns new Account generated for passed NetworkType

func NewAccountFromPrivateKey 

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

returns new Account from private key for passed NetworkType and generationHash

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) Bytes 

func (tx *AccountLinkTransaction) Bytes() ([]byte, error)

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 AccountName 

type AccountName struct {
	Address *Address
	Names   []string
}

func (*AccountName) String 

func (a *AccountName) 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) Bytes 

func (tx *AccountPropertiesAddressTransaction) Bytes() ([]byte, error)

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) Bytes 

func (tx *AccountPropertiesEntityTypeTransaction) Bytes() ([]byte, error)

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) Bytes 

func (tx *AccountPropertiesMosaicTransaction) Bytes() ([]byte, error)

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) GetAccountNames 

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

GetAccountNames Returns friendly names for accounts. post @/account/names

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) 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 Action 

type Action struct {
	FileHash *Hash
	FileSize StorageSize
}

func (*Action) String 

func (action *Action) String() string

type AddExchangeOfferTransaction 

type AddExchangeOfferTransaction struct {
	AbstractTransaction
	Offers []*AddOffer
}

Add Exchange Offer Transaction

func NewAddExchangeOfferTransaction 

func NewAddExchangeOfferTransaction(deadline *Deadline, addOffers []*AddOffer, networkType NetworkType) (*AddExchangeOfferTransaction, error)

func (*AddExchangeOfferTransaction) Bytes 

func (tx *AddExchangeOfferTransaction) Bytes() ([]byte, error)

func (*AddExchangeOfferTransaction) GetAbstractTransaction 

func (tx *AddExchangeOfferTransaction) GetAbstractTransaction() *AbstractTransaction

func (*AddExchangeOfferTransaction) Size 

func (tx *AddExchangeOfferTransaction) Size() int

func (*AddExchangeOfferTransaction) String 

func (tx *AddExchangeOfferTransaction) String() string

type AddOffer 

type AddOffer struct {
	Offer
	Duration Duration
}

func (*AddOffer) String 

func (offer *AddOffer) String() string

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) Decode 

func (ad *Address) Decode() ([]byte, error)

func (*Address) Encode 

func (ad *Address) Encode() ([]byte, error)

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) Bytes 

func (tx *AddressAliasTransaction) Bytes() ([]byte, error)

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) Bytes 

func (tx *AggregateTransaction) Bytes() ([]byte, error)

func (*AggregateTransaction) GetAbstractTransaction 

func (tx *AggregateTransaction) GetAbstractTransaction() *AbstractTransaction

func (*AggregateTransaction) Size 

func (tx *AggregateTransaction) Size() int

func (*AggregateTransaction) String 

func (tx *AggregateTransaction) String() string

func (*AggregateTransaction) UpdateUniqueAggregateHash 

func (tx *AggregateTransaction) UpdateUniqueAggregateHash(generationHash *Hash) (err error)

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) Bytes 

func (tx *AliasTransaction) Bytes(builder *flatbuffers.Builder, aliasV flatbuffers.UOffsetT, sizeOfAlias int) ([]byte, error)

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, error)
	// contains filtered or unexported methods
}

func NewAssetIdFromId 

func NewAssetIdFromId(id uint64) (AssetId, error)

type AssetIdType 

type AssetIdType uint8
const (
	NamespaceAssetIdType AssetIdType = iota
	MosaicAssetIdType
)

AssetIdType enums

type BillingDescription 

type BillingDescription struct {
	Start    Height
	End      Height
	Payments []*PaymentInformation
}

func (*BillingDescription) String 

func (desc *BillingDescription) String() string

type BlockChainVersion 

type BlockChainVersion uint64

func NewBlockChainVersion 

func NewBlockChainVersion(major uint16, minor uint16, revision uint16, build uint16) BlockChainVersion

func (BlockChainVersion) String 

func (m BlockChainVersion) String() string

type BlockInfo 

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

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 BlockchainConfig 

type BlockchainConfig struct {
	StartedHeight           Height
	NetworkConfig           *NetworkConfig
	SupportedEntityVersions *SupportedEntities
}

func (BlockchainConfig) String 

func (nc BlockchainConfig) String() string

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 {
	// contains filtered or unexported fields
}

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 BlockchainUpgradeTransaction 

type BlockchainUpgradeTransaction struct {
	AbstractTransaction
	UpgradePeriod        Duration
	NewBlockChainVersion BlockChainVersion
}

func NewBlockchainUpgradeTransaction 

func NewBlockchainUpgradeTransaction(deadline *Deadline, upgradePeriod Duration, newBlockChainVersion BlockChainVersion, networkType NetworkType) (*BlockchainUpgradeTransaction, error)

returns NetworkConfigTransaction from passed ApplyHeightDelta, NetworkConfig and SupportedEntityVersions

func (*BlockchainUpgradeTransaction) Bytes 

func (tx *BlockchainUpgradeTransaction) Bytes() ([]byte, error)

func (*BlockchainUpgradeTransaction) GetAbstractTransaction 

func (tx *BlockchainUpgradeTransaction) GetAbstractTransaction() *AbstractTransaction

func (*BlockchainUpgradeTransaction) Size 

func (tx *BlockchainUpgradeTransaction) Size() int

func (*BlockchainUpgradeTransaction) String 

func (tx *BlockchainUpgradeTransaction) String() string

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
	Exchange      *ExchangeService
	Mosaic        *MosaicService
	Namespace     *NamespaceService
	Network       *NetworkService
	Transaction   *TransactionService
	Resolve       *ResolverService
	Account       *AccountService
	Storage       *StorageService
	SuperContract *SuperContractService
	Lock          *LockService
	Contract      *ContractService
	Metadata      *MetadataService
	// contains filtered or unexported fields
}

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

func (*Client) AdaptAccount 

func (c *Client) AdaptAccount(account *Account) (*Account, error)

AdaptAccount returns a new account with the same network type and generation hash like a Client

func (*Client) BlockGenerationTime 

func (c *Client) BlockGenerationTime(ctx context.Context) (time.Duration, error)

BlockGenerationTime gets value from config. If value not found returns default value - 15s

func (*Client) GenerationHash 

func (c *Client) GenerationHash() *Hash

func (*Client) NetworkType 

func (c *Client) NetworkType() NetworkType

func (*Client) NewAccount 

func (c *Client) NewAccount() (*Account, error)

func (*Client) NewAccountFromPrivateKey 

func (c *Client) NewAccountFromPrivateKey(pKey string) (*Account, error)

func (*Client) NewAccountFromPublicKey 

func (c *Client) NewAccountFromPublicKey(pKey string) (*PublicAccount, error)

func (*Client) NewAccountLinkTransaction 

func (c *Client) NewAccountLinkTransaction(deadline *Deadline, remoteAccount *PublicAccount, linkAction AccountLinkAction) (*AccountLinkTransaction, error)

func (*Client) NewAccountPropertiesAddressTransaction 

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

func (*Client) NewAccountPropertiesEntityTypeTransaction 

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

func (*Client) NewAccountPropertiesMosaicTransaction 

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

func (*Client) NewAddExchangeOfferTransaction 

func (c *Client) NewAddExchangeOfferTransaction(deadline *Deadline, addOffers []*AddOffer) (*AddExchangeOfferTransaction, error)

func (*Client) NewAddressAliasTransaction 

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

func (*Client) NewBlockchainUpgradeTransaction 

func (c *Client) NewBlockchainUpgradeTransaction(deadline *Deadline, upgradePeriod Duration, newBlockChainVersion BlockChainVersion) (*BlockchainUpgradeTransaction, error)

func (*Client) NewBondedAggregateTransaction 

func (c *Client) NewBondedAggregateTransaction(deadline *Deadline, innerTxs []Transaction) (*AggregateTransaction, error)

func (*Client) NewCompleteAggregateTransaction 

func (c *Client) NewCompleteAggregateTransaction(deadline *Deadline, innerTxs []Transaction) (*AggregateTransaction, error)

func (*Client) NewDeactivateTransaction 

func (c *Client) NewDeactivateTransaction(deadline *Deadline, sc string, driveKey string) (*DeactivateTransaction, error)

func (*Client) NewDeployTransaction 

func (c *Client) NewDeployTransaction(deadline *Deadline, drive, owner *PublicAccount, fileHash *Hash, vmVersion uint64) (*DeployTransaction, error)

func (*Client) NewDriveFileSystemTransaction 

func (c *Client) NewDriveFileSystemTransaction(deadline *Deadline, driveKey string, newRootHash *Hash, oldRootHash *Hash, addActions []*Action, removeActions []*Action) (*DriveFileSystemTransaction, error)

func (*Client) NewDriveFilesRewardTransaction 

func (c *Client) NewDriveFilesRewardTransaction(deadline *Deadline, uploadInfos []*UploadInfo) (*DriveFilesRewardTransaction, error)

func (*Client) NewEndDriveTransaction 

func (c *Client) NewEndDriveTransaction(deadline *Deadline, driveKey *PublicAccount) (*EndDriveTransaction, error)

func (*Client) NewEndDriveVerificationTransaction 

func (c *Client) NewEndDriveVerificationTransaction(deadline *Deadline, failures []*FailureVerification) (*EndDriveVerificationTransaction, error)

func (*Client) NewEndExecuteTransaction 

func (c *Client) NewEndExecuteTransaction(deadline *Deadline, mosaics []*Mosaic, token *Hash, status OperationStatus) (*EndExecuteTransaction, error)

func (*Client) NewEndFileDownloadTransaction 

func (c *Client) NewEndFileDownloadTransaction(deadline *Deadline, recipient *PublicAccount, operationToken *Hash, files []*DownloadFile) (*EndFileDownloadTransaction, error)

func (*Client) NewEndOperationTransaction 

func (c *Client) NewEndOperationTransaction(deadline *Deadline, mosaics []*Mosaic, token *Hash, status OperationStatus) (*EndOperationTransaction, error)

func (*Client) NewExchangeOfferTransaction 

func (c *Client) NewExchangeOfferTransaction(deadline *Deadline, confirmations []*ExchangeConfirmation) (*ExchangeOfferTransaction, error)

func (*Client) NewFilesDepositTransaction 

func (c *Client) NewFilesDepositTransaction(deadline *Deadline, driveKey *PublicAccount, files []*File) (*FilesDepositTransaction, error)

func (*Client) NewJoinToDriveTransaction 

func (c *Client) NewJoinToDriveTransaction(deadline *Deadline, driveKey *PublicAccount) (*JoinToDriveTransaction, error)

func (*Client) NewLockFundsTransaction 

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

func (*Client) NewModifyContractTransaction 

func (c *Client) NewModifyContractTransaction(
	deadline *Deadline, durationDelta Duration, hash *Hash,
	customers []*MultisigCosignatoryModification,
	executors []*MultisigCosignatoryModification,
	verifiers []*MultisigCosignatoryModification) (*ModifyContractTransaction, error)

func (*Client) NewModifyMetadataAddressTransaction 

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

func (*Client) NewModifyMetadataMosaicTransaction 

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

func (*Client) NewModifyMetadataNamespaceTransaction 

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

func (*Client) NewModifyMultisigAccountTransaction 

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

func (*Client) NewMosaicAliasTransaction 

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

func (*Client) NewMosaicDefinitionTransaction 

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

func (*Client) NewMosaicSupplyChangeTransaction 

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

func (*Client) NewNetworkConfigTransaction 

func (c *Client) NewNetworkConfigTransaction(deadline *Deadline, delta Duration, config *NetworkConfig, entities *SupportedEntities) (*NetworkConfigTransaction, error)

func (*Client) NewOperationIdentifyTransaction 

func (c *Client) NewOperationIdentifyTransaction(deadline *Deadline, hash *Hash) (*OperationIdentifyTransaction, error)

func (*Client) NewPrepareDriveTransaction 

func (c *Client) NewPrepareDriveTransaction(deadline *Deadline, owner *PublicAccount,
	duration Duration, billingPeriod Duration, billingPrice Amount, driveSize StorageSize,
	replicas uint16, minReplicators uint16, percentApprovers uint8) (*PrepareDriveTransaction, error)

func (*Client) NewRegisterRootNamespaceTransaction 

func (c *Client) NewRegisterRootNamespaceTransaction(deadline *Deadline, namespaceName string, duration Duration) (*RegisterNamespaceTransaction, error)

func (*Client) NewRegisterSubNamespaceTransaction 

func (c *Client) NewRegisterSubNamespaceTransaction(deadline *Deadline, namespaceName string, parentId *NamespaceId) (*RegisterNamespaceTransaction, error)

func (*Client) NewRemoveExchangeOfferTransaction 

func (c *Client) NewRemoveExchangeOfferTransaction(deadline *Deadline, removeOffers []*RemoveOffer) (*RemoveExchangeOfferTransaction, error)

func (*Client) NewSecretLockTransaction 

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

func (*Client) NewSecretProofTransaction 

func (c *Client) NewSecretProofTransaction(deadline *Deadline, hashType HashType, proof *Proof, recipient *Address) (*SecretProofTransaction, error)

func (*Client) NewStartDriveVerificationTransaction 

func (c *Client) NewStartDriveVerificationTransaction(deadline *Deadline, driveKey *PublicAccount) (*StartDriveVerificationTransaction, error)

func (*Client) NewStartExecuteTransaction 

func (c *Client) NewStartExecuteTransaction(deadline *Deadline, supercontract *PublicAccount, mosaics []*Mosaic,
	function string, functionParameters []int64) (*StartExecuteTransaction, error)

func (*Client) NewStartFileDownloadTransaction 

func (c *Client) NewStartFileDownloadTransaction(deadline *Deadline, drive *PublicAccount, files []*DownloadFile) (*StartFileDownloadTransaction, error)

func (*Client) NewSuperContractFileSystemTransaction 

func (c *Client) NewSuperContractFileSystemTransaction(deadline *Deadline, driveKey string, newRootHash *Hash, oldRootHash *Hash, addActions []*Action, removeActions []*Action) (*SuperContractFileSystemTransaction, error)

func (*Client) NewTransferTransaction 

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

func (*Client) NewTransferTransactionWithNamespace 

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

type CommonLockInfo 

type CommonLockInfo struct {
	Account  *PublicAccount
	MosaicId *MosaicId
	Amount   Amount
	Height   Height
	Status   LockStatusType
}

type Config 

type Config struct {
	BaseURLs              []*url.URL
	UsedBaseUrl           *url.URL
	WsReconnectionTimeout time.Duration
	GenerationHash        *Hash
	NetworkType
	FeeCalculationStrategy
	// contains filtered or unexported fields
}

Provides service configuration

func NewConfig 

func NewConfig(ctx context.Context, baseUrls []string) (*Config, error)

returns config for HTTP Client from passed node url, filled by information from remote blockchain node

func NewConfigWithReputation 

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

type ConfigBag 

type ConfigBag struct {
	Name    string
	Comment string
	Index   int
	Fields  map[string]*Field
}

func NewConfigBag 

func NewConfigBag() *ConfigBag

func (ConfigBag) String 

func (c ConfigBag) String() string

type ConfirmedAddedMapper 

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

func NewConfirmedAddedMapper 

func NewConfirmedAddedMapper(mapTransactionFunc mapTransactionFunc, generationHash *Hash) ConfirmedAddedMapper

type ContractInfo 

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

func (*ContractInfo) String 

func (ref *ContractInfo) String() 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
	Signature  *Signature
	Signer     string
}

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 DeactivateTransaction 

type DeactivateTransaction struct {
	AbstractTransaction
	SuperContract string
	DriveKey      string
}

func NewDeactivateTransaction 

func NewDeactivateTransaction(deadline *Deadline, sc string, driveKey string, networkType NetworkType) (*DeactivateTransaction, error)

func (*DeactivateTransaction) Bytes 

func (tx *DeactivateTransaction) Bytes() ([]byte, error)

func (*DeactivateTransaction) GetAbstractTransaction 

func (tx *DeactivateTransaction) GetAbstractTransaction() *AbstractTransaction

func (*DeactivateTransaction) Size 

func (tx *DeactivateTransaction) Size() int

func (*DeactivateTransaction) String 

func (tx *DeactivateTransaction) 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 DeployTransaction 

type DeployTransaction struct {
	AbstractTransaction
	DriveAccount *PublicAccount
	Owner        *PublicAccount
	FileHash     *Hash
	VMVersion    uint64
}

func NewDeployTransaction 

func NewDeployTransaction(deadline *Deadline, drive, owner *PublicAccount, fileHash *Hash, vmVersion uint64, networkType NetworkType) (*DeployTransaction, error)

func (*DeployTransaction) Bytes 

func (tx *DeployTransaction) Bytes() ([]byte, error)

func (*DeployTransaction) GetAbstractTransaction 

func (tx *DeployTransaction) GetAbstractTransaction() *AbstractTransaction

func (*DeployTransaction) Size 

func (tx *DeployTransaction) Size() int

func (*DeployTransaction) String 

func (tx *DeployTransaction) String() string

type Difficulty 

type Difficulty = baseInt64

type DownloadFile 

type DownloadFile = Action

type DownloadInfo 

type DownloadInfo struct {
	OperationToken *Hash
	DriveAccount   *PublicAccount
	FileRecipient  *PublicAccount
	Height         Height
	Files          []*DownloadFile
}

type Drive 

type Drive struct {
	DriveAccount     *PublicAccount
	Start            Height
	State            DriveState
	OwnerAccount     *PublicAccount
	RootHash         *Hash
	Duration         Duration
	BillingPeriod    Duration
	BillingPrice     Amount
	DriveSize        StorageSize
	OccupiedSpace    StorageSize
	Replicas         uint16
	MinReplicators   uint16
	PercentApprovers uint8
	BillingHistory   []*BillingDescription
	Files            map[Hash]StorageSize
	Replicators      map[string]*ReplicatorInfo
	UploadPayments   []*PaymentInformation
}

func (*Drive) String 

func (drive *Drive) String() string

type DriveFileSystemTransaction 

type DriveFileSystemTransaction struct {
	AbstractTransaction
	DriveKey      string
	NewRootHash   *Hash
	OldRootHash   *Hash
	AddActions    []*Action
	RemoveActions []*Action
}

func NewDriveFileSystemTransaction 

func NewDriveFileSystemTransaction(
	deadline *Deadline,
	driveKey string,
	newRootHash *Hash,
	oldRootHash *Hash,
	addActions []*Action,
	removeActions []*Action,
	networkType NetworkType,
) (*DriveFileSystemTransaction, error)

func (*DriveFileSystemTransaction) Bytes 

func (tx *DriveFileSystemTransaction) Bytes() ([]byte, error)

func (*DriveFileSystemTransaction) GetAbstractTransaction 

func (tx *DriveFileSystemTransaction) GetAbstractTransaction() *AbstractTransaction

func (*DriveFileSystemTransaction) Size 

func (tx *DriveFileSystemTransaction) Size() int

func (*DriveFileSystemTransaction) String 

func (tx *DriveFileSystemTransaction) String() string

type DriveFilesRewardTransaction 

type DriveFilesRewardTransaction struct {
	AbstractTransaction
	UploadInfos []*UploadInfo
}

func NewDriveFilesRewardTransaction 

func NewDriveFilesRewardTransaction(
	deadline *Deadline,
	infos []*UploadInfo,
	networkType NetworkType,
) (*DriveFilesRewardTransaction, error)

func (*DriveFilesRewardTransaction) Bytes 

func (tx *DriveFilesRewardTransaction) Bytes() ([]byte, error)

func (*DriveFilesRewardTransaction) GetAbstractTransaction 

func (tx *DriveFilesRewardTransaction) GetAbstractTransaction() *AbstractTransaction

func (*DriveFilesRewardTransaction) Size 

func (tx *DriveFilesRewardTransaction) Size() int

func (*DriveFilesRewardTransaction) String 

func (tx *DriveFilesRewardTransaction) String() string

type DriveParticipantFilter 

type DriveParticipantFilter string
const (
	AllDriveRoles   DriveParticipantFilter = ""
	OwnerDrive      DriveParticipantFilter = "/owner"
	ReplicatorDrive DriveParticipantFilter = "/replicator"
)

type DriveState 

type DriveState uint8
const (
	NotStarted DriveState = iota
	Pending
	InProgress
	Finished
)

type DriveStateInfo 

type DriveStateInfo struct {
	DriveKey string
	State    DriveState
}

func MapDriveState 

func MapDriveState(m []byte) (*DriveStateInfo, error)

type DriveStateMapper 

type DriveStateMapper interface {
	MapDriveState(m []byte) (*DriveStateInfo, error)
}

type DriveStateMapperFn 

type DriveStateMapperFn func(m []byte) (*DriveStateInfo, error)

func (DriveStateMapperFn) MapDriveState 

func (p DriveStateMapperFn) MapDriveState(m []byte) (*DriveStateInfo, error)

type Duration 

type Duration = baseInt64

type EndDriveTransaction 

type EndDriveTransaction struct {
	AbstractTransaction
	DriveKey *PublicAccount
}

func NewEndDriveTransaction 

func NewEndDriveTransaction(
	deadline *Deadline,
	driveKey *PublicAccount,
	networkType NetworkType,
) (*EndDriveTransaction, error)

func (*EndDriveTransaction) Bytes 

func (tx *EndDriveTransaction) Bytes() ([]byte, error)

func (*EndDriveTransaction) GetAbstractTransaction 

func (tx *EndDriveTransaction) GetAbstractTransaction() *AbstractTransaction

func (*EndDriveTransaction) Size 

func (tx *EndDriveTransaction) Size() int

func (*EndDriveTransaction) String 

func (tx *EndDriveTransaction) String() string

type EndDriveVerificationTransaction 

type EndDriveVerificationTransaction struct {
	AbstractTransaction
	Failures []*FailureVerification
}

func NewEndDriveVerificationTransaction 

func NewEndDriveVerificationTransaction(
	deadline *Deadline,
	failures []*FailureVerification,
	networkType NetworkType,
) (*EndDriveVerificationTransaction, error)

func (*EndDriveVerificationTransaction) Bytes 

func (tx *EndDriveVerificationTransaction) Bytes() ([]byte, error)

func (*EndDriveVerificationTransaction) GetAbstractTransaction 

func (tx *EndDriveVerificationTransaction) GetAbstractTransaction() *AbstractTransaction

func (*EndDriveVerificationTransaction) Size 

func (tx *EndDriveVerificationTransaction) Size() int

func (*EndDriveVerificationTransaction) String 

func (tx *EndDriveVerificationTransaction) String() string

type EndExecuteTransaction 

type EndExecuteTransaction = EndOperationTransaction

func NewEndExecuteTransaction 

func NewEndExecuteTransaction(deadline *Deadline, mosaics []*Mosaic, token *Hash, status OperationStatus, networkType NetworkType) (*EndExecuteTransaction, error)

type EndFileDownloadTransaction 

type EndFileDownloadTransaction struct {
	AbstractTransaction
	Recipient      *PublicAccount
	OperationToken *Hash
	Files          []*DownloadFile
}

func NewEndFileDownloadTransaction 

func NewEndFileDownloadTransaction(
	deadline *Deadline,
	recipient *PublicAccount,
	operationToken *Hash,
	files []*DownloadFile,
	networkType NetworkType,
) (*EndFileDownloadTransaction, error)

func (*EndFileDownloadTransaction) Bytes 

func (tx *EndFileDownloadTransaction) Bytes() ([]byte, error)

func (*EndFileDownloadTransaction) GetAbstractTransaction 

func (tx *EndFileDownloadTransaction) GetAbstractTransaction() *AbstractTransaction

func (*EndFileDownloadTransaction) Size 

func (tx *EndFileDownloadTransaction) Size() int

func (*EndFileDownloadTransaction) String 

func (tx *EndFileDownloadTransaction) String() string

type EndOperationTransaction 

type EndOperationTransaction struct {
	AbstractTransaction
	UsedMosaics    []*Mosaic
	OperationToken *Hash
	Status         OperationStatus
}

Must be aggregated in AOT

func NewEndOperationTransaction 

func NewEndOperationTransaction(deadline *Deadline, mosaics []*Mosaic, token *Hash, status OperationStatus, networkType NetworkType) (*EndOperationTransaction, error)

func (*EndOperationTransaction) Bytes 

func (tx *EndOperationTransaction) Bytes() ([]byte, error)

func (*EndOperationTransaction) GetAbstractTransaction 

func (tx *EndOperationTransaction) GetAbstractTransaction() *AbstractTransaction

func (*EndOperationTransaction) Size 

func (tx *EndOperationTransaction) Size() int

func (*EndOperationTransaction) String 

func (tx *EndOperationTransaction) String() string

type Entity 

type Entity struct {
	Name              string
	Type              EntityType
	SupportedVersions []EntityVersion
}

func (Entity) String 

func (e Entity) String() string

type EntityType 

type EntityType uint16
const (
	AccountPropertyAddress    EntityType = 0x4150
	AccountPropertyMosaic     EntityType = 0x4250
	AccountPropertyEntityType EntityType = 0x4350
	AddressAlias              EntityType = 0x424e
	AggregateBonded           EntityType = 0x4241
	AggregateCompleted        EntityType = 0x4141
	AddExchangeOffer          EntityType = 0x415D
	ExchangeOffer             EntityType = 0x425D
	RemoveExchangeOffer       EntityType = 0x435D
	Block                     EntityType = 0x8143
	NemesisBlock              EntityType = 0x8043
	NetworkConfigEntityType   EntityType = 0x4159
	BlockchainUpgrade         EntityType = 0x4158
	LinkAccount               EntityType = 0x414c
	Lock                      EntityType = 0x4148
	MetadataAddress           EntityType = 0x413d
	MetadataMosaic            EntityType = 0x423d
	MetadataNamespace         EntityType = 0x433d
	ModifyContract            EntityType = 0x4157
	ModifyMultisig            EntityType = 0x4155
	MosaicAlias               EntityType = 0x434e
	MosaicDefinition          EntityType = 0x414d
	MosaicSupplyChange        EntityType = 0x424d
	RegisterNamespace         EntityType = 0x414e
	SecretLock                EntityType = 0x4152
	SecretProof               EntityType = 0x4252
	Transfer                  EntityType = 0x4154
	PrepareDrive              EntityType = 0x415A
	JoinToDrive               EntityType = 0x425A
	DriveFileSystem           EntityType = 0x435A
	FilesDeposit              EntityType = 0x445A
	EndDrive                  EntityType = 0x455A
	DriveFilesReward          EntityType = 0x465A
	StartDriveVerification    EntityType = 0x475A
	EndDriveVerification      EntityType = 0x485A
	StartFileDownload         EntityType = 0x495A
	EndFileDownload           EntityType = 0x4A5A
	OperationIdentify         EntityType = 0x415F
	StartOperation            EntityType = 0x425F
	EndOperation              EntityType = 0x435F
	Deploy                    EntityType = 0x4160
	StartExecute              EntityType = 0x4260
	EndExecute                EntityType = 0x4360
	SuperContractFileSystem   EntityType = 0x4460
	Deactivate                EntityType = 0x4560
)

func (EntityType) String 

func (t EntityType) String() string

type EntityVersion 

type EntityVersion uint32
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
	MetadataAddressVersion           EntityVersion = 1
	MetadataMosaicVersion            EntityVersion = 1
	MetadataNamespaceVersion         EntityVersion = 1
	ModifyContractVersion            EntityVersion = 3
	ModifyMultisigVersion            EntityVersion = 3
	MosaicAliasVersion               EntityVersion = 1
	MosaicDefinitionVersion          EntityVersion = 3
	MosaicSupplyChangeVersion        EntityVersion = 2
	RegisterNamespaceVersion         EntityVersion = 2
	SecretLockVersion                EntityVersion = 1
	SecretProofVersion               EntityVersion = 1
	TransferVersion                  EntityVersion = 3
	PrepareDriveVersion              EntityVersion = 2
	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
	OperationIdentifyVersion         EntityVersion = 1
	SuperContractFileSystemVersion   EntityVersion = 1
	DeactivateVersion                EntityVersion = 1
)

func ExtractVersion 

func ExtractVersion(version int64) EntityVersion

type ExchangeConfirmation 

type ExchangeConfirmation struct {
	Offer
	Owner *PublicAccount
}

func (*ExchangeConfirmation) String 

func (offer *ExchangeConfirmation) String() string

type ExchangeOfferTransaction 

type ExchangeOfferTransaction struct {
	AbstractTransaction
	Confirmations []*ExchangeConfirmation
}

Exchange Transaction

func NewExchangeOfferTransaction 

func NewExchangeOfferTransaction(deadline *Deadline, confirmations []*ExchangeConfirmation, networkType NetworkType) (*ExchangeOfferTransaction, error)

func (*ExchangeOfferTransaction) Bytes 

func (tx *ExchangeOfferTransaction) Bytes() ([]byte, error)

func (*ExchangeOfferTransaction) GetAbstractTransaction 

func (tx *ExchangeOfferTransaction) GetAbstractTransaction() *AbstractTransaction

func (*ExchangeOfferTransaction) Size 

func (tx *ExchangeOfferTransaction) Size() int

func (*ExchangeOfferTransaction) String 

func (tx *ExchangeOfferTransaction) String() string

type ExchangeService 

type ExchangeService struct {
	ResolveService *ResolverService
	// contains filtered or unexported fields
}

func (*ExchangeService) GetAccountExchangeInfo 

func (e *ExchangeService) GetAccountExchangeInfo(ctx context.Context, account *PublicAccount) (*UserExchangeInfo, error)

func (*ExchangeService) GetExchangeOfferByAssetId 

func (e *ExchangeService) GetExchangeOfferByAssetId(ctx context.Context, assetId AssetId, offerType OfferType) ([]*OfferInfo, error)

Return offers with same operation type and mosaic id. Example: If you want to buy Storage units, you need to call GetExchangeOfferByAssetId(StorageMosaicId, SellOffer)

type FailureVerification 

type FailureVerification struct {
	Replicator  *PublicAccount
	BlochHashes []*Hash
}

func (*FailureVerification) Size 

func (fail *FailureVerification) Size() int

func (*FailureVerification) String 

func (fail *FailureVerification) String() string

type FeeCalculationStrategy 

type FeeCalculationStrategy uint32
const (
	HighCalculationStrategy   FeeCalculationStrategy = 2500
	MiddleCalculationStrategy FeeCalculationStrategy = 250
	LowCalculationStrategy    FeeCalculationStrategy = 25
)

FeeCalculationStrategy enums

type Field 

type Field struct {
	Key     string
	Value   string
	Comment string
	Index   int
}

func NewField 

func NewField() *Field

func (Field) String 

func (c Field) String() string

type File 

type File struct {
	FileHash *Hash
}

func (*File) String 

func (file *File) String() string

type FilesDepositTransaction 

type FilesDepositTransaction struct {
	AbstractTransaction
	DriveKey *PublicAccount
	Files    []*File
}

Files Deposit Transaction

func NewFilesDepositTransaction 

func NewFilesDepositTransaction(
	deadline *Deadline,
	driveKey *PublicAccount,
	files []*File,
	networkType NetworkType,
) (*FilesDepositTransaction, error)

func (*FilesDepositTransaction) Bytes 

func (tx *FilesDepositTransaction) Bytes() ([]byte, error)

func (*FilesDepositTransaction) GetAbstractTransaction 

func (tx *FilesDepositTransaction) GetAbstractTransaction() *AbstractTransaction

func (*FilesDepositTransaction) Size 

func (tx *FilesDepositTransaction) Size() int

func (*FilesDepositTransaction) String 

func (tx *FilesDepositTransaction) String() string

type Hash 

type Hash [32]byte

func CalculateCompositeHash 

func CalculateCompositeHash(secret *Hash, recipient *Address) (*Hash, error)

func CalculateSecretLockInfoHash 

func CalculateSecretLockInfoHash(secret *Secret, recipient *Address) (*Hash, error)

func InnerTransactionHash 

func InnerTransactionHash(tx Transaction) *Hash

func StringToHash 

func StringToHash(hash string) (*Hash, error)

func UniqueAggregateHash 

func UniqueAggregateHash(aggregateTx *AggregateTransaction, tx Transaction, generationHash *Hash) (*Hash, error)

func (Hash) Empty 

func (h Hash) Empty() bool

func (Hash) Equal 

func (h Hash) Equal(other *Hash) bool

func (Hash) String 

func (h Hash) String() string

func (Hash) Xor 

func (h Hash) Xor(other *Hash) *Hash

type HashLockInfo 

type HashLockInfo struct {
	CommonLockInfo
	Hash *Hash
}

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
	// / Internal type inside of blockchain
	Internal_Hash_Type
)

func (HashType) String 

func (ht HashType) String() string

type Height 

type Height = baseInt64

type HttpError 

type HttpError struct {
	StatusCode int
	// contains filtered or unexported fields
}

type JoinToDriveTransaction 

type JoinToDriveTransaction struct {
	AbstractTransaction
	DriveKey *PublicAccount
}

func NewJoinToDriveTransaction 

func NewJoinToDriveTransaction(
	deadline *Deadline,
	driveKey *PublicAccount,
	networkType NetworkType,
) (*JoinToDriveTransaction, error)

func (*JoinToDriveTransaction) Bytes 

func (tx *JoinToDriveTransaction) Bytes() ([]byte, error)

func (*JoinToDriveTransaction) GetAbstractTransaction 

func (tx *JoinToDriveTransaction) GetAbstractTransaction() *AbstractTransaction

func (*JoinToDriveTransaction) Size 

func (tx *JoinToDriveTransaction) Size() int

func (*JoinToDriveTransaction) String 

func (tx *JoinToDriveTransaction) String() string

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) Bytes 

func (tx *LockFundsTransaction) Bytes() ([]byte, error)

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 LockService 

type LockService service

func (*LockService) GetHashLockInfo 

func (s *LockService) GetHashLockInfo(ctx context.Context, hash *Hash) (*HashLockInfo, error)

func (*LockService) GetHashLockInfosByAccount 

func (s *LockService) GetHashLockInfosByAccount(ctx context.Context, account *PublicAccount) ([]*HashLockInfo, error)

func (*LockService) GetSecretLockInfo 

func (s *LockService) GetSecretLockInfo(ctx context.Context, compositeHash *Hash) (*SecretLockInfo, error)

func (*LockService) GetSecretLockInfosByAccount 

func (s *LockService) GetSecretLockInfosByAccount(ctx context.Context, account *PublicAccount) ([]*SecretLockInfo, error)

func (*LockService) GetSecretLockInfosBySecret 

func (s *LockService) GetSecretLockInfosBySecret(ctx context.Context, secret *Hash) ([]*SecretLockInfo, error)

type LockStatusType 

type LockStatusType uint8
const (
	/// Lock is unused.
	Unused LockStatusType = iota

	/// Lock was already used.
	Used
)

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          *Hash
	Customers     []*MultisigCosignatoryModification
	Executors     []*MultisigCosignatoryModification
	Verifiers     []*MultisigCosignatoryModification
}

func NewModifyContractTransaction 

func NewModifyContractTransaction(
	deadline *Deadline, durationDelta Duration, hash *Hash,
	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) Bytes 

func (tx *ModifyContractTransaction) Bytes() ([]byte, error)

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) Bytes 

func (tx *ModifyMetadataAddressTransaction) Bytes() ([]byte, error)

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) Bytes 

func (tx *ModifyMetadataMosaicTransaction) Bytes() ([]byte, error)

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) Bytes 

func (tx *ModifyMetadataNamespaceTransaction) Bytes() ([]byte, error)

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) Bytes 

func (tx *ModifyMetadataTransaction) Bytes(builder *flatbuffers.Builder, metadataV flatbuffers.UOffsetT, sizeOfMetadata int) ([]byte, error)

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) Bytes 

func (tx *ModifyMultisigAccountTransaction) Bytes() ([]byte, error)

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 Credit 

func Credit(amount uint64) *Mosaic

returns credit mosaic with passed amount

func CreditRelative 

func CreditRelative(amount uint64) *Mosaic

returns credit with actual passed amount

func Network 

func Network(amount uint64) *Mosaic

returns network mosaic with passed amount

func NetworkRelative 

func NetworkRelative(amount uint64) *Mosaic

returns network mosaic with actual passed amount

func NewMosaic 

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

returns a Mosaic for passed AssetId and amount

func Storage 

func Storage(amount uint64) *Mosaic

returns storage mosaic with passed amount

func Streaming 

func Streaming(amount uint64) *Mosaic

returns streaming with actual passed amount

func SuperContractMosaic 

func SuperContractMosaic(amount uint64) *Mosaic

returns super contract mosaic with passed amount

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) Bytes 

func (tx *MosaicAliasTransaction) Bytes() ([]byte, error)

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) Bytes 

func (tx *MosaicDefinitionTransaction) Bytes() ([]byte, error)

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 {
	// contains filtered or unexported fields
}

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 (*MosaicId) Equals 

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

func (*MosaicId) Id 

func (m *MosaicId) Id() uint64

func (*MosaicId) MarshalJSON 

func (m *MosaicId) MarshalJSON() ([]byte, error)

func (*MosaicId) String 

func (m *MosaicId) String() string

func (*MosaicId) Type 

func (m *MosaicId) Type() AssetIdType

func (*MosaicId) UnmarshalJSON 

func (m *MosaicId) UnmarshalJSON(data []byte) error

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 {
	MosaicPropertiesHeader
	OptionalProperties []MosaicProperty
}

func NewMosaicProperties 

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

returns MosaicProperties from actual values

func (*MosaicProperties) Duration 

func (mp *MosaicProperties) Duration() Duration

func (*MosaicProperties) String 

func (mp *MosaicProperties) String() string

type MosaicPropertiesHeader 

type MosaicPropertiesHeader struct {
	SupplyMutable bool
	Transferable  bool
	Divisibility  uint8
}

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 `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

type MosaicProperty 

type MosaicProperty struct {
	Id    MosaicPropertyId
	Value baseInt64
}

func (*MosaicProperty) String 

func (mp *MosaicProperty) String() string

type MosaicPropertyId 

type MosaicPropertyId uint8
const (
	MosaicPropertyFlagsId MosaicPropertyId = iota
	MosaicPropertyDivisibilityId
	MosaicPropertyDurationId
)

MosaicPropertyId enums

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) Bytes 

func (tx *MosaicSupplyChangeTransaction) Bytes() ([]byte, error)

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
	// contains filtered or unexported fields
}

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 {
	// contains filtered or unexported fields
}

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 (*NamespaceId) Equals 

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

func (*NamespaceId) Id 

func (m *NamespaceId) Id() uint64

func (*NamespaceId) MarshalJSON 

func (m *NamespaceId) MarshalJSON() ([]byte, error)

func (*NamespaceId) String 

func (m *NamespaceId) String() string

func (*NamespaceId) Type 

func (m *NamespaceId) Type() AssetIdType

func (*NamespaceId) UnmarshalJSON 

func (m *NamespaceId) UnmarshalJSON(data []byte) error

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 (info NamespaceInfo) String() string

type NamespaceMetadataInfo 

type NamespaceMetadataInfo struct {
	MetadataInfo
	NamespaceId *NamespaceId
}

type NamespaceName 

type NamespaceName struct {
	NamespaceId *NamespaceId
	FullName    string
}

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 NetworkConfig 

type NetworkConfig struct {
	Sections map[string]*ConfigBag
}

func NewNetworkConfig 

func NewNetworkConfig() *NetworkConfig

func (*NetworkConfig) MarshalBinary 

func (c *NetworkConfig) MarshalBinary() (data []byte, err error)

func (*NetworkConfig) String 

func (c *NetworkConfig) String() string

func (*NetworkConfig) UnmarshalBinary 

func (c *NetworkConfig) UnmarshalBinary(data []byte) error

type NetworkConfigTransaction 

type NetworkConfigTransaction struct {
	AbstractTransaction
	ApplyHeightDelta  Duration
	NetworkConfig     *NetworkConfig
	SupportedEntities *SupportedEntities
}

func NewNetworkConfigTransaction 

func NewNetworkConfigTransaction(deadline *Deadline, delta Duration, config *NetworkConfig, entities *SupportedEntities, networkType NetworkType) (*NetworkConfigTransaction, error)

returns NetworkConfigTransaction from passed ApplyHeightDelta, NetworkConfig and SupportedEntities

func (*NetworkConfigTransaction) Bytes 

func (tx *NetworkConfigTransaction) Bytes() ([]byte, error)

func (*NetworkConfigTransaction) GetAbstractTransaction 

func (tx *NetworkConfigTransaction) GetAbstractTransaction() *AbstractTransaction

func (*NetworkConfigTransaction) Size 

func (tx *NetworkConfigTransaction) Size() int

func (*NetworkConfigTransaction) String 

func (tx *NetworkConfigTransaction) String() string

type NetworkService 

type NetworkService struct {
	BlockchainService *BlockchainService
	// contains filtered or unexported fields
}

func (*NetworkService) GetNetworkConfig 

func (ref *NetworkService) GetNetworkConfig(ctx context.Context) (*BlockchainConfig, error)

func (*NetworkService) GetNetworkConfigAtHeight 

func (ref *NetworkService) GetNetworkConfigAtHeight(ctx context.Context, height Height) (*BlockchainConfig, error)

func (*NetworkService) GetNetworkType 

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

func (*NetworkService) GetNetworkVersion 

func (ref *NetworkService) GetNetworkVersion(ctx context.Context) (*NetworkVersion, error)

func (*NetworkService) GetNetworkVersionAtHeight 

func (ref *NetworkService) GetNetworkVersionAtHeight(ctx context.Context, height Height) (*NetworkVersion, 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 int64) NetworkType

func NetworkTypeFromString 

func NetworkTypeFromString(networkType string) NetworkType

func (NetworkType) String 

func (nt NetworkType) String() string

type NetworkVersion 

type NetworkVersion struct {
	StartedHeight     Height
	BlockChainVersion BlockChainVersion
}

func (NetworkVersion) String 

func (nv NetworkVersion) String() string

type Offer 

type Offer struct {
	Type   OfferType
	Mosaic *Mosaic
	Cost   Amount
}

type OfferInfo 

type OfferInfo struct {
	Type             OfferType
	Owner            *PublicAccount
	Mosaic           *Mosaic
	PriceNumerator   Amount
	PriceDenominator Amount
	Deadline         Height
}

func (*OfferInfo) ConfirmOffer 

func (o *OfferInfo) ConfirmOffer(amount Amount) (*ExchangeConfirmation, error)

func (*OfferInfo) Cost 

func (o *OfferInfo) Cost(amount Amount) (Amount, error)

func (*OfferInfo) String 

func (info *OfferInfo) String() string

type OfferType 

type OfferType uint8
const (
	SellOffer OfferType = iota
	BuyOffer
	UnknownType
)

func (OfferType) CounterOffer 

func (o OfferType) CounterOffer() OfferType

func (OfferType) String 

func (o OfferType) String() string

type Operation 

type Operation struct {
	// Token is hash of first transaction which started the operation. In case of aggregate transaction is UniqueAggregateHash
	Token         *Hash
	Initiator     *PublicAccount
	Height        Height
	Status        OperationStatus
	Executors     []*PublicAccount
	LockedMosaics []*Mosaic
	// Aggregate transactions which were sent during operation.
	AggregateHashes []*Hash
}

type OperationIdentifyTransaction 

type OperationIdentifyTransaction struct {
	AbstractTransaction
	OperationHash *Hash
}

func NewOperationIdentifyTransaction 

func NewOperationIdentifyTransaction(deadline *Deadline, operationKey *Hash, networkType NetworkType) (*OperationIdentifyTransaction, error)

func (*OperationIdentifyTransaction) Bytes 

func (tx *OperationIdentifyTransaction) Bytes() ([]byte, error)

func (*OperationIdentifyTransaction) GetAbstractTransaction 

func (tx *OperationIdentifyTransaction) GetAbstractTransaction() *AbstractTransaction

func (*OperationIdentifyTransaction) Size 

func (tx *OperationIdentifyTransaction) Size() int

func (*OperationIdentifyTransaction) String 

func (tx *OperationIdentifyTransaction) String() string

type OperationStatus 

type OperationStatus uint16
const (
	Unknown OperationStatus = iota
	Started
	Success
	Failure
)

type PartialAddedMapper 

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

func NewPartialAddedMapper 

func NewPartialAddedMapper(mapTransactionFunc mapTransactionFunc, generationHash *Hash) 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 PaymentInformation 

type PaymentInformation struct {
	Receiver *PublicAccount
	Amount   Amount
	Height   Height
}

func (*PaymentInformation) String 

func (info *PaymentInformation) String() string

type PlainMessage 

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

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 PrepareDriveTransaction 

type PrepareDriveTransaction struct {
	AbstractTransaction
	Owner            *PublicAccount
	Duration         Duration
	BillingPeriod    Duration
	BillingPrice     Amount
	DriveSize        StorageSize
	Replicas         uint16
	MinReplicators   uint16
	PercentApprovers uint8
}

Prepare Drive Transaction

func NewPrepareDriveTransaction 

func NewPrepareDriveTransaction(
	deadline *Deadline,
	owner *PublicAccount,
	duration Duration,
	billingPeriod Duration,
	billingPrice Amount,
	driveSize StorageSize,
	replicas uint16,
	minReplicators uint16,
	percentApprovers uint8,
	networkType NetworkType,
) (*PrepareDriveTransaction, error)

func (*PrepareDriveTransaction) Bytes 

func (tx *PrepareDriveTransaction) Bytes() ([]byte, error)

func (*PrepareDriveTransaction) GetAbstractTransaction 

func (tx *PrepareDriveTransaction) GetAbstractTransaction() *AbstractTransaction

func (*PrepareDriveTransaction) Size 

func (tx *PrepareDriveTransaction) Size() int

func (*PrepareDriveTransaction) String 

func (tx *PrepareDriveTransaction) String() string

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) Bytes 

func (tx *RegisterNamespaceTransaction) Bytes() ([]byte, error)

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 RemoveExchangeOfferTransaction 

type RemoveExchangeOfferTransaction struct {
	AbstractTransaction
	Offers []*RemoveOffer
}

Remove Exchange Offer Transaction

func NewRemoveExchangeOfferTransaction 

func NewRemoveExchangeOfferTransaction(deadline *Deadline, removeOffers []*RemoveOffer, networkType NetworkType) (*RemoveExchangeOfferTransaction, error)

func (*RemoveExchangeOfferTransaction) Bytes 

func (tx *RemoveExchangeOfferTransaction) Bytes() ([]byte, error)

func (*RemoveExchangeOfferTransaction) GetAbstractTransaction 

func (tx *RemoveExchangeOfferTransaction) GetAbstractTransaction() *AbstractTransaction

func (*RemoveExchangeOfferTransaction) Size 

func (tx *RemoveExchangeOfferTransaction) Size() int

func (*RemoveExchangeOfferTransaction) String 

func (tx *RemoveExchangeOfferTransaction) String() string

type RemoveOffer 

type RemoveOffer struct {
	Type    OfferType
	AssetId AssetId
}

func (*RemoveOffer) String 

func (offer *RemoveOffer) String() string

type ReplicatorInfo 

type ReplicatorInfo struct {
	Account                   *PublicAccount
	Start                     Height
	End                       Height
	Index                     int
	ActiveFilesWithoutDeposit map[Hash]bool
}

func (*ReplicatorInfo) String 

func (info *ReplicatorInfo) String() string

type ResolverService 

type ResolverService struct {
	NamespaceService *NamespaceService
	MosaicService    *MosaicService
	// contains filtered or unexported fields
}

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 {
	// contains filtered or unexported fields
}

func (*RespErr) Error 

func (r *RespErr) Error() string

type Secret 

type Secret struct {
	Hash Hash     `json:"hash"`
	Type HashType `json:"type"`
}

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 SecretLockInfo 

type SecretLockInfo struct {
	CommonLockInfo
	HashAlgorithm HashType
	CompositeHash *Hash
	Secret        *Hash
	Recipient     *Address
}

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) Bytes 

func (tx *SecretLockTransaction) Bytes() ([]byte, error)

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
	Recipient *Address
}

func NewSecretProofTransaction 

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

returns a SecretProofTransaction from passed HashType and Proof

func (*SecretProofTransaction) Bytes 

func (tx *SecretProofTransaction) Bytes() ([]byte, error)

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 {
	// contains filtered or unexported fields
}

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 Signature 

type Signature [64]byte

func StringToSignature 

func StringToSignature(signature string) (*Signature, error)

func (Signature) String 

func (s Signature) String() string

type SignedTransaction 

type SignedTransaction struct {
	EntityType
	Payload string
	Hash    *Hash
}

func (*SignedTransaction) String 

func (tx *SignedTransaction) String() string

type SignerInfo 

type SignerInfo struct {
	Signer     string
	Signature  *Signature
	ParentHash *Hash
}

func MapCosignature 

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

type StartDriveVerificationTransaction 

type StartDriveVerificationTransaction struct {
	AbstractTransaction
	DriveKey *PublicAccount
}

func NewStartDriveVerificationTransaction 

func NewStartDriveVerificationTransaction(
	deadline *Deadline,
	driveKey *PublicAccount,
	networkType NetworkType,
) (*StartDriveVerificationTransaction, error)

func (*StartDriveVerificationTransaction) Bytes 

func (tx *StartDriveVerificationTransaction) Bytes() ([]byte, error)

func (*StartDriveVerificationTransaction) GetAbstractTransaction 

func (tx *StartDriveVerificationTransaction) GetAbstractTransaction() *AbstractTransaction

func (*StartDriveVerificationTransaction) Size 

func (tx *StartDriveVerificationTransaction) Size() int

func (*StartDriveVerificationTransaction) String 

func (tx *StartDriveVerificationTransaction) String() string

type StartExecuteTransaction 

type StartExecuteTransaction struct {
	AbstractTransaction
	SuperContract      *PublicAccount
	Function           string
	LockMosaics        []*Mosaic
	FunctionParameters []int64
}

func NewStartExecuteTransaction 

func NewStartExecuteTransaction(deadline *Deadline, supercontract *PublicAccount, mosaics []*Mosaic, function string, functionParameters []int64, networkType NetworkType) (*StartExecuteTransaction, error)

func (*StartExecuteTransaction) Bytes 

func (tx *StartExecuteTransaction) Bytes() ([]byte, error)

func (*StartExecuteTransaction) GetAbstractTransaction 

func (tx *StartExecuteTransaction) GetAbstractTransaction() *AbstractTransaction

func (*StartExecuteTransaction) Size 

func (tx *StartExecuteTransaction) Size() int

func (*StartExecuteTransaction) String 

func (tx *StartExecuteTransaction) String() string

type StartFileDownloadTransaction 

type StartFileDownloadTransaction struct {
	AbstractTransaction
	Drive *PublicAccount
	Files []*DownloadFile
}

func NewStartFileDownloadTransaction 

func NewStartFileDownloadTransaction(
	deadline *Deadline,
	drive *PublicAccount,
	files []*DownloadFile,
	networkType NetworkType,
) (*StartFileDownloadTransaction, error)

func (*StartFileDownloadTransaction) Bytes 

func (tx *StartFileDownloadTransaction) Bytes() ([]byte, error)

func (*StartFileDownloadTransaction) GetAbstractTransaction 

func (tx *StartFileDownloadTransaction) GetAbstractTransaction() *AbstractTransaction

func (*StartFileDownloadTransaction) Size 

func (tx *StartFileDownloadTransaction) Size() int

func (*StartFileDownloadTransaction) String 

func (tx *StartFileDownloadTransaction) String() string

type StartOperationTransaction 

type StartOperationTransaction struct {
	AbstractTransaction
	OperationExecutors []*PublicAccount
	Mosaics            []*Mosaic
	Duration           Duration
}

type StatusInfo 

type StatusInfo struct {
	Status string
	Hash   *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 StorageService 

type StorageService struct {
	LockService *LockService
	// contains filtered or unexported fields
}

func (*StorageService) GetAccountDownloadInfos 

func (s *StorageService) GetAccountDownloadInfos(ctx context.Context, recipient *PublicAccount) ([]*DownloadInfo, error)

func (*StorageService) GetAccountDrives 

func (s *StorageService) GetAccountDrives(ctx context.Context, driveKey *PublicAccount, filter DriveParticipantFilter) ([]*Drive, error)

func (*StorageService) GetDownloadInfo 

func (s *StorageService) GetDownloadInfo(ctx context.Context, operationToken *Hash) (*DownloadInfo, error)

func (*StorageService) GetDrive 

func (s *StorageService) GetDrive(ctx context.Context, driveKey *PublicAccount) (*Drive, error)

func (*StorageService) GetDriveDownloadInfos 

func (s *StorageService) GetDriveDownloadInfos(ctx context.Context, drive *PublicAccount) ([]*DownloadInfo, error)

func (*StorageService) GetVerificationStatus 

func (s *StorageService) GetVerificationStatus(ctx context.Context, driveKey *PublicAccount) (*VerificationStatus, error)

type StorageSize 

type StorageSize = baseInt64

type SuperContract 

type SuperContract struct {
	Account   *PublicAccount
	Drive     *PublicAccount
	FileHash  *Hash
	VMVersion uint64
	Start     Height
	End       Height
}

func (*SuperContract) String 

func (s *SuperContract) String() string

type SuperContractFileSystemTransaction 

type SuperContractFileSystemTransaction = DriveFileSystemTransaction

func NewSuperContractFileSystemTransaction 

func NewSuperContractFileSystemTransaction(
	deadline *Deadline,
	driveKey string,
	newRootHash *Hash,
	oldRootHash *Hash,
	addActions []*Action,
	removeActions []*Action,
	networkType NetworkType,
) (*SuperContractFileSystemTransaction, error)

type SuperContractService 

type SuperContractService service

func (*SuperContractService) GetDriveSuperContracts 

func (s *SuperContractService) GetDriveSuperContracts(ctx context.Context, driveKey *PublicAccount) ([]*SuperContract, error)

func (*SuperContractService) GetOperation 

func (s *SuperContractService) GetOperation(ctx context.Context, operationHash *Hash) (*Operation, error)

func (*SuperContractService) GetOperationsByAccount 

func (s *SuperContractService) GetOperationsByAccount(ctx context.Context, account *PublicAccount) ([]*Operation, error)

func (*SuperContractService) GetSuperContract 

func (s *SuperContractService) GetSuperContract(ctx context.Context, contractKey *PublicAccount) (*SuperContract, error)

type SupportedEntities 

type SupportedEntities struct {
	Entities map[EntityType]*Entity
}

func NewSupportedEntities 

func NewSupportedEntities() *SupportedEntities

func (*SupportedEntities) MarshalBinary 

func (s *SupportedEntities) MarshalBinary() (data []byte, err error)

func (*SupportedEntities) String 

func (s *SupportedEntities) String() string

func (*SupportedEntities) UnmarshalBinary 

func (s *SupportedEntities) UnmarshalBinary(data []byte) 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
	Bytes() ([]byte, error)
}

func MapTransaction 

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

func MapTransactions 

func MapTransactions(b *bytes.Buffer, generationHash *Hash) ([]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
	TransactionHash     *Hash
	MerkleComponentHash *Hash
	AggregateHash       *Hash
	UniqueAggregateHash *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
	// contains filtered or unexported fields
}

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 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) Bytes 

func (tx *TransferTransaction) Bytes() ([]byte, error)

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, generationHash *Hash) 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 UploadInfo 

type UploadInfo struct {
	Participant  *PublicAccount
	UploadedSize Amount
}

func (*UploadInfo) String 

func (info *UploadInfo) String() string

type UserExchangeInfo 

type UserExchangeInfo struct {
	Owner  *PublicAccount
	Offers map[OfferType]map[MosaicId]*OfferInfo
}

func (*UserExchangeInfo) String 

func (info *UserExchangeInfo) String() string

type VarSize 

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

type VerificationStatus 

type VerificationStatus struct {
	Active    bool
	Available bool
}

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)

Source Files

View all Source files

Directories

Path Synopsis
handlers
subscribers

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.