action

package

Go to main page

Versions in this module

v0

v0.8.2

Jan 25, 2019

Changes in this version

+ func IsEnoughBalance(balance data.Balance, value data.Coin, fee data.Coin) bool

type OLVMContext

+ func (context OLVMContext) GetValue(key string) interface{}

v0.8.1

Dec 31, 2018

Changes in this version

+ func CheckBalances(app interface{}, owner id.AccountKey, identityAccountKey id.AccountKey, ...) bool

+ func CheckRegisterFee(app interface{}, owner id.AccountKey, fee data.Coin) bool

+ func TransferVT(app interface{}, applyValidator id.ApplyValidator) status.Code

type Register

+ Fee data.Coin

v0.8.0

Dec 19, 2018

Changes in this version

+ func CheckAmountsAbsolute(app interface{}, inputs []SendInput, outputs []SendOutput) bool

+ func CheckPayTo(app interface{}, pay []SendTo) bool

+ func CheckSendTo(balance data.Balance, sendTo SendTo, fee data.Coin) bool

+ func CheckValidatorList(app interface{}, SendTo []SendTo) bool

+ func CompareResults(recent OLVMResult, original OLVMResult) bool

+ func Convert(installData Install) (id.AccountKey, string, version.Version, data.Script)

+ func GetExecutionContext(app interface{}) data.Datastore

+ func GetSmartContracts(app interface{}) data.Datastore

+ func GetValidators(app interface{}) *id.Validators

+ func RunScript(app interface{}, request *OLVMRequest) interface

+ func SaveContext(app interface{}, owner id.AccountKey, name string, version version.Version, ...)

type ApplyValidator

+ Identity string

+ NodeName string

+ Purge bool

type Base

+ func (b Base) Validate() status.Code

+ type Compare struct

+ Name string

+ Owner id.AccountKey

+ Result OLVMResult

+ Version version.Version

+ type Contract struct

+ Data ContractData

+ Fee data.Coin

+ Function ContractFunction

+ Gas data.Coin

+ func (transaction *Contract) Compare(app interface{}) status.Code

+ func (transaction *Contract) CreateCompareRequest(app interface{}, owner id.AccountKey, name string, version version.Version, ...) []byte

+ func (transaction *Contract) Execute(app interface{}) Transaction

+ func (transaction *Contract) Install(app interface{})

+ func (transaction *Contract) ProcessCheck(app interface{}) status.Code

+ func (transaction *Contract) ProcessDeliver(app interface{}) status.Code

+ func (transaction *Contract) Resolve(app interface{}) Commands

+ func (transaction *Contract) ShouldProcess(app interface{}) bool

+ func (transaction *Contract) TransactionType() Type

+ func (transaction *Contract) Validate() status.Code

+ type ContractData interface

+ type ContractFunction int

+ const COMPARE

+ const EXECUTE

+ const INSTALL

type Execute

+ Name string

+ Owner id.AccountKey

+ Version version.Version

+ type Install struct

+ Name string

+ Owner id.AccountKey

+ Script []byte

+ Version version.Version

+ type OLVMContext struct

+ Data interface{}

+ type OLVMRequest struct

+ Address string

+ CallString string

+ Context OLVMContext

+ From string

+ SourceCode []byte

+ Transaction Transaction

+ Value int

+ func NewOLVMRequest(script []byte, context OLVMContext) *OLVMRequest

+ type OLVMResult struct

+ Context OLVMContext

+ Elapsed string

+ Out string

+ Ret string

+ Status status.Code

+ Transactions []Transaction

+ func GetContext(app interface{}, owner id.AccountKey, name string, version version.Version) OLVMResult

+ func NewOLVMResult() *OLVMResult

type Payment

+ SendTo []SendTo

type Send

+ SendTo SendTo

+ func (transaction Send) TransactionTags(app interface{}) Tags

+ type SendTo struct

+ AccountKey id.AccountKey

+ Amount data.Coin

+ func (st SendTo) IsValid() bool

+ type Send_Absolute struct

+ Fee data.Coin

+ Gas data.Coin

+ Inputs []SendInput

+ Outputs []SendOutput

+ func (transaction *Send_Absolute) ProcessCheck(app interface{}) status.Code

+ func (transaction *Send_Absolute) ProcessDeliver(app interface{}) status.Code

+ func (transaction *Send_Absolute) Resolve(app interface{}) Commands

+ func (transaction *Send_Absolute) ShouldProcess(app interface{}) bool

+ func (transaction *Send_Absolute) TransactionType() Type

+ func (transaction *Send_Absolute) Validate() status.Code

type Swap

+ func (transaction Swap) TransactionTags(app interface{}) Tags

type SwapExchange

+ func (se SwapExchange) GetKeyHash(app interface{}) string

type SwapInit

+ func (si SwapInit) GetKey() *SwapKey

+ func (si SwapInit) GetKeyHash(app interface{}) string

type SwapKey

+ func (sk SwapKey) Hash() []byte

type SwapMessage

+ GetKeyHash func(interface{}) string

type SwapVerify

+ func (sv SwapVerify) GetKeyHash(app interface{}) string

type Type

+ const SMART_CONTRACT

v0.7.1

Dec 7, 2018

Changes in this version

+ func GetBalances(app interface{}) *data.ChainState

+ type ApplyValidator struct

+ AccountKey id.AccountKey

+ Stake data.Coin

+ TendermintAddress string

+ TendermintPubKey string

+ func (transaction *ApplyValidator) ProcessCheck(app interface{}) status.Code

+ func (transaction *ApplyValidator) ProcessDeliver(app interface{}) status.Code

+ func (transaction *ApplyValidator) Resolve(app interface{}) Commands

+ func (transaction *ApplyValidator) ShouldProcess(app interface{}) bool

+ func (transaction *ApplyValidator) Validate() status.Code

type Base

+ func (b Base) GetOwner() id.AccountKey

+ func (b Base) GetSigners() []id.PublicKey

+ func (b Base) TransactionTags() Tags

type ExternalSend

+ Amount data.Coin

+ Chain data.ChainType

+ ExFee data.Coin

+ ExGas data.Coin

+ Receiver string

+ Sender string

+ type Payment struct

+ Fee data.Coin

+ Gas data.Coin

+ Inputs []SendInput

+ Outputs []SendOutput

+ func (transaction *Payment) ProcessCheck(app interface{}) status.Code

+ func (transaction *Payment) ProcessDeliver(app interface{}) status.Code

+ func (transaction *Payment) Resolve(app interface{}) Commands

+ func (transaction *Payment) ShouldProcess(app interface{}) bool

+ func (transaction *Payment) Validate() status.Code

+ type PaymentRecord struct

+ Amount data.Coin

+ BlockHeight int64

+ type Tags common.KVPairs

type Transaction

+ GetOwner func() id.AccountKey

+ GetSigners func() []id.PublicKey

+ TransactionTags func() Tags

type Type

+ const APPLY_VALIDATOR

+ const PAYMENT

+ func (t Type) String() string

v0.7.0

Nov 19, 2018

Changes in this version

+ const INITIATOR_INITIATE

+ const INITIATOR_REDEEM

+ const NOSTAGE

+ const PARTICIPANT_PARTICIPATE

+ const PARTICIPANT_REDEEM

+ const SWAP_FINISH

+ const SWAP_MATCHED

+ const SWAP_MATCHING

+ const SWAP_REFUND

+ func DeleteContract(app interface{}, contractKey []byte, nonce int64)

+ func DeleteSwap(app interface{}, key id.AccountKey)

+ func GetBool(value FunctionValue) *bool

+ func GetChain(value FunctionValue) data.ChainType

+ func GetContracts(app interface{}) data.Datastore

+ func GetSigners(owner []byte) []id.PublicKey

+ func ValidateSignature(transaction SignedTransaction) bool

type Base

+ Target id.AccountKey

type Commands

+ func (cs Commands) Execute(app interface{}) status.Code

type Commit

+ func (transaction *Commit) TransactionType() Type

type Event

+ Step int

+ SwapKeyHash []byte

type ExternalLock

+ func (transaction *ExternalLock) TransactionType() Type

type ExternalSend

+ func (transaction *ExternalSend) TransactionType() Type

type Forget

+ func (transaction *Forget) TransactionType() Type

+ type FunctionValues map[Parameter]FunctionValue

+ func ClearEvent(app interface{}, chain data.ChainType, context FunctionValues, tx Transaction) (bool, FunctionValues)

+ func CreateCheckEvent(app interface{}, chain data.ChainType, context FunctionValues, tx Transaction) (bool, FunctionValues)

+ func FinalizeSwap(app interface{}, chain data.ChainType, context FunctionValues, tx Transaction) (bool, FunctionValues)

+ func NextStage(app interface{}, chain data.ChainType, context FunctionValues, tx Transaction) (bool, FunctionValues)

+ func VerifySwap(app interface{}, chain data.ChainType, context FunctionValues, tx Transaction) (bool, FunctionValues)

type Parameter

+ const CHAIN

+ const CONTRACT

+ const DELAYTIME

+ const FINISHED

+ const NEXTCHAINNAME

+ const NEXTSTAGE

+ const OWNER

+ const PREVIOUS

+ const STAGE

+ const STOREKEY

+ const SWAPMESSAGE

+ const TARGET

type Prepare

+ func (transaction *Prepare) TransactionType() Type

type Publish

+ func (transaction *Publish) TransactionType() Type

type Register

+ TendermintAddress string

+ TendermintPubKey string

+ func CreateRegisterRequest(identity string, chainId string, sequence int64, nodeName string, ...) *Register

+ func (transaction *Register) TransactionType() Type

type Send

+ func (transaction *Send) TransactionType() Type

+ type SignedTransaction struct

+ Signatures []TransactionSignature

type Swap

+ Stage swapStageType

+ SwapMessage SwapMessage

+ func (swap *Swap) CommandExecute(app interface{}, commands Commands, c chan status.Code)

+ func (transaction *Swap) TransactionType() Type

+ type SwapExchange struct

+ Chain data.ChainType

+ Contract common.Contract

+ PreviousTx []byte

+ SwapKeyHash []byte

+ type SwapInit struct

+ Amount data.Coin

+ CounterParty Party

+ Exchange data.Coin

+ Fee data.Coin

+ Gas data.Coin

+ Nonce int64

+ Party Party

+ Preimage []byte

+ type SwapKey struct

+ Amount data.Coin

+ Exchange data.Coin

+ Initiator id.AccountKey

+ Nonce int64

+ Participant id.AccountKey

+ type SwapMessage interface

+ func GetSwapMessage(value FunctionValue) SwapMessage

+ type SwapVerify struct

+ Event Event

type Transaction

+ TransactionType func() Type

+ type TransactionSignature struct

+ Signature []byte

type Verify

+ func (transaction *Verify) TransactionType() Type

v0.6.2

Nov 6, 2018

v0.6.1

Oct 22, 2018

v0.6.0

Sep 25, 2018

v0.5.3

Sep 10, 2018

Changes in this version

+ type HtlContract struct

+ LockHeight int64

+ Secrethash [32]byte

+ StartFromHeight int64

+ Transaction Transaction

+ func CreateHtlContract(app interface{}, transaction Transaction, scrhash [32]byte, lock time.Duration) *HtlContract

+ type MultiSigBox struct

+ Lockers []BoxLocker

+ M int

+ N int

+ func NewMultiSigBox(m int, n int, message Message) *MultiSigBox

+ func (msb MultiSigBox) Sign(locker *BoxLocker) error

+ func (msb MultiSigBox) Unlock(signs []BoxLocker) *Message

v0.5.2

Aug 21, 2018

Changes in this version

+ func FindEvent(app interface{}, eventKey Event) bool

+ func GetContract(app interface{}) *data.Datastore

+ func GetEvent(app interface{}) *data.Datastore

+ func GetHeight(app interface{}) int64

+ func GetNodeAccount(app interface{}) id.Account

+ func SaveContract(app interface{}, contractKey []byte, nonce int64, contract common.Contract)

+ func SaveEvent(app interface{}, eventKey Event, status bool)

type CommandType

+ const FINISH

+ type Event struct

+ Key id.AccountKey

+ Nonce int64

+ Type Type

+ func (e Event) ToKey() []byte

type Message

+ func FindContract(app interface{}, contractKey []byte, nonce int64) Message

type Parameter

+ const COUNT

+ const EVENTTYPE

type Publish

+ Count int

type Type

+ func GetType(value FunctionValue) Type

type Verify

+ Event Event

+ Message Message

v0.5.0

Jul 25, 2018

Changes in this version

+ func AuditContractBTC(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func AuditContractETH(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func AuditContractOLT(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func ExtractSecretBTC(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func ExtractSecretETH(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func ExtractSecretOLT(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func GetBTCContract(value FunctionValue) *bitcoin.HTLContract

+ func GetByte32(value FunctionValue) [32]byte

+ func GetChainID(app interface{}) string

+ func ParticipateBTC(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func ParticipateOLT(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func PrepareTransaction(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func RedeemBTC(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func RedeemOLT(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func RefundBTC(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func RefundOLT(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func SubmitTransactionOLT(context map[Parameter]FunctionValue, chain data.ChainType) (bool, map[Parameter]FunctionValue)

type Command

+ Order int

type CommandType

+ const PREPARE_TRANSACTION

type Parameter

+ const CHAINID

+ const LOCKTIME

+ const MY_ACCOUNT

+ const SEQUENCE

+ const THEM_ACCOUNT

+ type Publish struct

+ Contract Message

+ SecretHash [32]byte

+ Sequence int

+ Target id.AccountKey

+ func ParsePublish(message Message) *Publish

+ func (publish *Publish) Resolve(app interface{}, commands Commands)

+ func (transaction *Publish) Expand(app interface{}) Commands

+ func (transaction *Publish) FindSwap(app interface{}) *Swap

+ func (transaction *Publish) GetNodeAccount(app interface{}) id.Account

+ func (transaction *Publish) ProcessCheck(app interface{}) err.Code

+ func (transaction *Publish) ProcessDeliver(app interface{}) err.Code

+ func (transaction *Publish) ShouldProcess(app interface{}) bool

+ func (transaction *Publish) Validate() err.Code

type Type

+ const CHECKFORERROR

v0.4.0

Jun 30, 2018

Changes in this version

+ var FunctionMapping = [][]Object

+ func AuditContract(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func BroadcastTransaction(ttype Type, transaction Transaction)

+ func CheckAmounts(app interface{}, inputs []SendInput, outputs []SendOutput) bool

+ func CheckBalance(app interface{}, accountKey id.AccountKey, amount data.Coin) bool

+ func CreateContractBTC(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func CreateContractETH(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func CreateContractOLT(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func DelayedTransaction(ttype Type, transaction Transaction, waitTime time.Duration)

+ func Execute(app interface{}, command Command, lastResult map[Parameter]FunctionValue) (err.Code, map[Parameter]FunctionValue)

+ func ExtractSecret(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func GetAccount(app interface{}, accountKey id.AccountKey) id.Account

+ func GetAccountKey(value FunctionValue) id.AccountKey

+ func GetAccounts(app interface{}) *id.Accounts

+ func GetAdmin(app interface{}) *data.Datastore

+ func GetAmount(value FunctionValue) btcutil.Amount

+ func GetBytes(value FunctionValue) []byte

+ func GetChainAccount(app interface{}, name string, chain data.ChainType) id.Account

+ func GetChains(transaction interface{}) []data.ChainType

+ func GetCoin(value FunctionValue) data.Coin

+ func GetETHContract(value FunctionValue) *ethereum.HtlContract

+ func GetIdentities(app interface{}) *id.Identities

+ func GetInt(value FunctionValue) int

+ func GetInt64(value FunctionValue) int64

+ func GetPubKeyHash(address string) *btcutil.AddressPubKeyHash

+ func GetStatus(app interface{}) *data.Datastore

+ func GetString(value FunctionValue) string

+ func GetUtxo(app interface{}) *data.ChainState

+ func Initiate(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func MatchSwap(left *Swap, right *Swap) bool

+ func Noop(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func PackRequest(ttype Type, request Transaction) []byte

+ func Participate(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func ParticipateETH(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func Redeem(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func RedeemETH(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func Refund(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func RefundETH(context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func SaveSwap(status *data.Datastore, accountKey id.AccountKey, transaction *Swap)

+ func SignAndPack(ttype Type, transaction Transaction) []byte

+ func SubmitTransaction(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ func UnpackMessage(message Message) (Type, Message)

+ func WaitForChain(chain data.ChainType, context map[Parameter]FunctionValue) (bool, map[Parameter]FunctionValue)

+ type Base struct

+ ChainId string

+ Delay int64

+ Owner id.AccountKey

+ Sequence int64

+ Signers []PublicKey

+ Type Type

+ type BoxLocker struct

+ PubKey *btcec.PublicKey

+ Signature *btcec.Signature

+ func (bl *BoxLocker) Sign(preImage []byte, nonce []byte, message Message) (bool, error)

+ func (bl *BoxLocker) Verify(message Message) bool

+ type Command struct

+ Chain data.ChainType

+ Data map[Parameter]FunctionValue

+ Function CommandType

+ func (command Command) Execute() (bool, map[Parameter]FunctionValue)

+ type CommandType int

+ const AUDITCONTRACT

+ const EXTRACTSECRET

+ const INITIATE

+ const NOOP

+ const PARTICIPATE

+ const REDEEM

+ const REFUND

+ const SUBMIT_TRANSACTION

+ const WAIT_FOR_CHAIN

+ type Commands []Command

+ func GetCommands(action Type, role Role, chains []data.ChainType) Commands

+ func (commands Commands) Count() int

+ type Commit struct

+ Target string

+ func ParseCommit(message Message) *Commit

+ func (transaction *Commit) Expand(app interface{}) Commands

+ func (transaction *Commit) ProcessCheck(app interface{}) err.Code

+ func (transaction *Commit) ProcessDeliver(app interface{}) err.Code

+ func (transaction *Commit) Resolve(app interface{}, commands Commands)

+ func (transaction *Commit) ShouldProcess(app interface{}) bool

+ func (transaction *Commit) Validate() err.Code

+ type ExternalLock struct

+ Fee data.Coin

+ Gas data.Coin

+ Inputs []SendInput

+ Outputs []SendOutput

+ func ParseExternalLock(message Message) *ExternalLock

+ func (transaction *ExternalLock) Expand(app interface{}) Commands

+ func (transaction *ExternalLock) ProcessCheck(app interface{}) err.Code

+ func (transaction *ExternalLock) ProcessDeliver(app interface{}) err.Code

+ func (transaction *ExternalLock) Resolve(app interface{}, commands Commands)

+ func (transaction *ExternalLock) ShouldProcess(app interface{}) bool

+ func (transaction *ExternalLock) Validate() err.Code

+ type ExternalSend struct

+ Fee data.Coin

+ Gas data.Coin

+ Inputs []SendInput

+ Outputs []SendOutput

+ func ParseExternalSend(message Message) *ExternalSend

+ func (transaction *ExternalSend) Expand(app interface{}) Commands

+ func (transaction *ExternalSend) ProcessCheck(app interface{}) err.Code

+ func (transaction *ExternalSend) ProcessDeliver(app interface{}) err.Code

+ func (transaction *ExternalSend) Resolve(app interface{}, commands Commands)

+ func (transaction *ExternalSend) ShouldProcess(app interface{}) bool

+ func (transaction *ExternalSend) Validate() err.Code

+ type Forget struct

+ Target string

+ func ParseForget(message Message) *Forget

+ func (transaction *Forget) Expand(app interface{}) Commands

+ func (transaction *Forget) ProcessCheck(app interface{}) err.Code

+ func (transaction *Forget) ProcessDeliver(app interface{}) err.Code

+ func (transaction *Forget) Resolve(app interface{}, commands Commands)

+ func (transaction *Forget) ShouldProcess(app interface{}) bool

+ func (transaction *Forget) Validate() err.Code

+ type FunctionValue interface

+ type Message = []byte

+ type Object interface

+ type Parameter byte

+ const AMOUNT

+ const BTCCONTRACT

+ const ETHCONTRACT

+ const EXCHANGE

+ const INITIATOR_ACCOUNT

+ const NONCE

+ const PARTICIPANT_ACCOUNT

+ const PASSWORD

+ const PREIMAGE

+ const ROLE

+ type Party struct

+ Accounts map[data.ChainType]string

+ Key id.AccountKey

+ func GetParty(value FunctionValue) Party

+ type Prepare struct

+ Target string

+ func ParsePrepare(message Message) *Prepare

+ func (transaction *Prepare) Expand(app interface{}) Commands

+ func (transaction *Prepare) ProcessCheck(app interface{}) err.Code

+ func (transaction *Prepare) ProcessDeliver(app interface{}) err.Code

+ func (transaction *Prepare) Resolve(app interface{}, commands Commands)

+ func (transaction *Prepare) ShouldProcess(app interface{}) bool

+ func (transaction *Prepare) Validate() err.Code

+ type PublicKey = crypto.PubKey

+ type Register struct

+ AccountKey id.AccountKey

+ Identity string

+ NodeName string

+ func ParseRegister(message Message) *Register

+ func (transaction Register) Expand(app interface{}) Commands

+ func (transaction Register) ProcessCheck(app interface{}) err.Code

+ func (transaction Register) ProcessDeliver(app interface{}) err.Code

+ func (transaction Register) Resolve(app interface{}, commands Commands)

+ func (transaction Register) ShouldProcess(app interface{}) bool

+ func (transaction Register) Validate() err.Code

+ type Role byte

+ const ALL

+ const INITIATOR

+ const NONE

+ const PARTICIPANT

+ func GetRole(value FunctionValue) Role

+ type Send struct

+ Fee data.Coin

+ Gas data.Coin

+ Inputs []SendInput

+ Outputs []SendOutput

+ func ParseSend(message Message) *Send

+ func (transaction *Send) Expand(app interface{}) Commands

+ func (transaction *Send) ProcessCheck(app interface{}) err.Code

+ func (transaction *Send) ProcessDeliver(app interface{}) err.Code

+ func (transaction *Send) Resolve(app interface{}, commands Commands)

+ func (transaction *Send) ShouldProcess(app interface{}) bool

+ func (transaction *Send) Validate() err.Code

+ type SendInput struct

+ AccountKey id.AccountKey

+ Amount data.Coin

+ PubKey PublicKey

+ Sequence int

+ Signature id.Signature

+ func NewSendInput(accountKey id.AccountKey, amount data.Coin) SendInput

+ type SendOutput struct

+ AccountKey id.AccountKey

+ Amount data.Coin

+ func NewSendOutput(accountKey id.AccountKey, amount data.Coin) SendOutput

+ type Swap struct

+ Amount data.Coin

+ CounterParty Party

+ Exchange data.Coin

+ Fee data.Coin

+ Gas data.Coin

+ Nonce int64

+ Party Party

+ Preimage []byte

+ func FindMatchingSwap(status *data.Datastore, accountKey id.AccountKey, transaction *Swap, ...) (matched *Swap)

+ func ParseSwap(message Message) *Swap

+ func ProcessSwap(app interface{}, transaction *Swap) *Swap

+ func (swap *Swap) Resolve(app interface{}, commands Commands)

+ func (transaction *Swap) Expand(app interface{}) Commands

+ func (transaction *Swap) GetNodeAccount(app interface{}) id.Account

+ func (transaction *Swap) IsParty(account id.Account) *bool

+ func (transaction *Swap) ProcessCheck(app interface{}) err.Code

+ func (transaction *Swap) ProcessDeliver(app interface{}) err.Code

+ func (transaction *Swap) ShouldProcess(app interface{}) bool

+ func (transaction *Swap) Validate() err.Code

+ type Transaction interface

+ Expand func(interface{}) Commands

+ ProcessCheck func(interface{}) err.Code

+ ProcessDeliver func(interface{}) err.Code

+ Resolve func(interface{}, Commands)

+ ShouldProcess func(interface{}) bool

+ Validate func() err.Code

+ func FindSwap(status *data.Datastore, key id.AccountKey) Transaction

+ func Parse(message Message) (Transaction, err.Code)

+ func SignTransaction(transaction Transaction) Transaction

+ type Type byte

+ const COMMIT

+ const EXTERNAL_LOCK

+ const EXTERNAL_SEND

+ const FORGET

+ const INVALID

+ const PREPARE

+ const PUBLISH

+ const READ

+ const REGISTER

+ const SEND

+ const SWAP

+ const VERIFY

+ type Verify struct

+ Target id.AccountKey

+ func ParseVerify(message Message) *Verify

+ func (transaction Verify) Expand(app interface{}) Commands

+ func (transaction Verify) ProcessCheck(app interface{}) err.Code

+ func (transaction Verify) ProcessDeliver(app interface{}) err.Code

+ func (transaction Verify) Resolve(app interface{}, commands Commands)

+ func (transaction Verify) ShouldProcess(app interface{}) bool

+ func (transaction Verify) Validate() err.Code

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL