burrow: github.com/hyperledger/burrow/deploy/def Index | Files | Directories

package def

import "github.com/hyperledger/burrow/deploy/def"

Index

Package Files

client.go deploy.go job.go jobs.go playbook.go

Constants

const DefaultOutputFile = "deploy.output.json"

Variables

var NewKeyRegex = regexp.MustCompile(`new\((?P<keyName>[[:alnum:]]+)?(,(?P<curveType>[[:alnum:]]+))?\)`)

Used in the Target of UpdateAccount to determine whether to create a new account, e.g. new() or new(key1,ed25519)

func KeyNameCurveType Uses

func KeyNameCurveType(newKeyMatch []string) (keyName, curveType string)

func PublicKeyFromString Uses

func PublicKeyFromString(publicKey string) (crypto.PublicKey, error)

type Account Uses

type Account struct {
    // (Required) address of the account which should be used as the default (if source) is
    // not given for future transactions. Will make sure the burrow keys has the public key
    // for the account. Generally account should be the first job called unless it is used
    // via a flag or environment variables to establish what default to use.
    Address string `mapstructure:"address" json:"address" yaml:"address" toml:"address"`
}

func (*Account) Validate Uses

func (job *Account) Validate() error

type Assert Uses

type Assert struct {
    // (Required) key which should be used for the assertion. This is usually known as the "expected"
    // value in most testing suites
    Key string `mapstructure:"key" json:"key" yaml:"key" toml:"key"`
    // (Required) must be of the set ["eq", "ne", "ge", "gt", "le", "lt", "==", "!=", ">=", ">", "<=", "<"]
    // establishes the relation to be tested by the assertion. If a strings key:value pair is being used
    // only the equals or not-equals relations may be used as the key:value will try to be converted to
    // ints for the remainder of the relations. if strings are passed to them then `monax pkgs do` will return an
    // error
    Relation string `mapstructure:"relation" json:"relation" yaml:"relation" toml:"relation"`
    // (Required) value which should be used for the assertion. This is usually known as the "given"
    // value in most testing suites. Generally it will be a variable expansion from one of the query
    // jobs.
    Value string `mapstructure:"val" json:"val" yaml:"val" toml:"val"`
}

func (*Assert) Validate Uses

func (job *Assert) Validate() error

type Bond Uses

type Bond struct {
    // (Optional, if account job or global account set) address of the account from which to bond (the
    // public key for the account must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required) the Tendermint validator power to claim
    Amount string `mapstructure:"amount" json:"amount" yaml:"amount" toml:"amount"`
    // (Optional, advanced only) sequence to use when burrow keys signs the transaction
    // (do not use unless you know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
}

func (*Bond) Validate Uses

func (job *Bond) Validate() error

type BondArg Uses

type BondArg struct {
    Input    string
    Amount   string
    Sequence string
}

type Build Uses

type Build struct {
    // (Required) the filepath to the contract file. this should be relative to the current path **or**
    // relative to the contracts path established via the --dir.
    // If contract has a "bin" file extension then it will not be sent to the
    // compilers but rather will just be sent to the chain. Note, if you use a "call" job after deploying
    // a binary contract then you will be **required** to utilize an abi field in the call job.
    Contract string `mapstructure:"contract" json:"contract" yaml:"contract" toml:"contract"`
    // (Optional) where to save the result of the compilation
    BinPath string `mapstructure:"binpath" json:"binpath" yaml:"binpath" toml:"binpath"`
    // (Optional) the name of contract to instantiate (it has to be one of the contracts present)
    // in the file defined in Contract above.
    // When none is provided, the system will choose the contract with the same name as that file.
    // use "all" to override and deploy all contracts in order. if "all" is selected the result
    // of the job will default to the address of the contract which was deployed that matches
    // the name of the file (or the last one deployed if there are no matching names; not the "last"
    // one deployed" strategy is non-deterministic and should not be used).
    Instance string `mapstructure:"instance" json:"instance" yaml:"instance" toml:"instance"`
    // (Optional) Path to store an extra copy of the bin file
    Store string `mapstructure:"store" json:"store" yaml:"store" toml:"store"`
}

func (*Build) Validate Uses

func (job *Build) Validate() error

type Call Uses

type Call struct {
    // (Optional, if account job or global account set) address of the account from which to send (the
    // public key for the account must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required) address of the contract which should be called
    Destination string `mapstructure:"destination" json:"destination" yaml:"destination" toml:"destination"`
    // (Required unless testing fallback function) function inside the contract to be called
    Function string `mapstructure:"function" json:"function" yaml:"function" toml:"function"`
    // (Optional) data which should be called. will use the monax-abi tooling under the hood to formalize the
    // transaction
    Data interface{} `mapstructure:"data" json:"data" yaml:"data" toml:"data"`
    // (Optional) amount of tokens to send to the contract
    Amount string `mapstructure:"amount" json:"amount" yaml:"amount" toml:"amount"`
    // (Optional) validators' fee
    Fee string `mapstructure:"fee" json:"fee" yaml:"fee" toml:"fee"`
    // (Optional) amount of gas which should be sent along with the call transaction
    Gas string `mapstructure:"gas" json:"gas" yaml:"gas" toml:"gas"`
    // (Optional, advanced only) sequence to use when burrow keys signs the transaction (do not use unless you
    // know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
    // (Optional) location of the bin file to use (can be relative path or in bin path)
    // deployed contracts save ABI artifacts in the bin folder as *both* the name of the contract
    // and the address where the contract was deployed to
    Bin string `mapstructure:"bin" json:"bin" yaml:"bin" toml:"bin"`
    // (Optional) by default the call job will "store" the return from the contract as the
    // result of the job. If you would like to store the transaction hash instead of the
    // return from the call job as the result of the call job then select "tx" on the save
    // variable. Anything other than "tx" in this field will use the default.
    Save string `mapstructure:"save" json:"save" yaml:"save" toml:"save"`
    // (Optional) the call job's returned variables
    Variables []*abi.Variable
}

func (*Call) String Uses

func (job *Call) String() string

TODO: maybe do for others...

func (*Call) Validate Uses

func (job *Call) Validate() error

type CallArg Uses

type CallArg struct {
    Input    string
    Amount   string
    Sequence string
    Address  string
    Fee      string
    Gas      string
    Data     string
    WASM     string
    Metadata map[acmstate.CodeHash]string
}

type Client Uses

type Client struct {
    MempoolSigning    bool
    ChainAddress      string
    KeysClientAddress string

    AllSpecs *abi.Spec
    // contains filtered or unexported fields
}

func NewClient Uses

func NewClient(chain, keysClientAddress string, mempoolSigning bool, timeout time.Duration) *Client

func (*Client) Bond Uses

func (c *Client) Bond(arg *BondArg, logger *logging.Logger) (*payload.BondTx, error)

func (*Client) Broadcast Uses

func (c *Client) Broadcast(tx payload.Payload, logger *logging.Logger) (*exec.TxExecution, error)

Broadcast payload for remote signing

func (*Client) BroadcastEnvelope Uses

func (c *Client) BroadcastEnvelope(txEnv *txs.Envelope, logger *logging.Logger) (*exec.TxExecution, error)

Broadcast envelope - can be locally signed or remote signing will be attempted

func (*Client) Call Uses

func (c *Client) Call(arg *CallArg, logger *logging.Logger) (*payload.CallTx, error)

func (*Client) CreateKey Uses

func (c *Client) CreateKey(keyName, curveTypeString string, logger *logging.Logger) (crypto.PublicKey, error)

Creates a keypair using attached keys service

func (*Client) Events Uses

func (c *Client) Events(logger *logging.Logger) (rpcevents.ExecutionEventsClient, error)

func (*Client) GetAccount Uses

func (c *Client) GetAccount(address crypto.Address) (*acm.Account, error)

func (*Client) GetMetadata Uses

func (c *Client) GetMetadata(metahash acmstate.MetadataHash) (string, error)

func (*Client) GetMetadataForAccount Uses

func (c *Client) GetMetadataForAccount(address crypto.Address) (string, error)

func (*Client) GetName Uses

func (c *Client) GetName(name string, logger *logging.Logger) (*names.Entry, error)

func (*Client) GetProposal Uses

func (c *Client) GetProposal(hash []byte, logger *logging.Logger) (*payload.Ballot, error)

func (*Client) GetStorage Uses

func (c *Client) GetStorage(address crypto.Address, key binary.Word256) ([]byte, error)

func (*Client) GetValidatorSet Uses

func (c *Client) GetValidatorSet(logger *logging.Logger) (*rpcquery.ValidatorSet, error)

func (*Client) Identify Uses

func (c *Client) Identify(arg *IdentifyArg, logger *logging.Logger) (*payload.IdentifyTx, error)

func (*Client) ListProposals Uses

func (c *Client) ListProposals(proposed bool, logger *logging.Logger) ([]*rpcquery.ProposalResult, error)

func (*Client) Name Uses

func (c *Client) Name(arg *NameArg, logger *logging.Logger) (*payload.NameTx, error)

func (*Client) ParseAddress Uses

func (c *Client) ParseAddress(key string, logger *logging.Logger) (crypto.Address, error)

func (*Client) ParseUint64 Uses

func (c *Client) ParseUint64(amount string) (uint64, error)

func (*Client) Permissions Uses

func (c *Client) Permissions(arg *PermArg, logger *logging.Logger) (*payload.PermsTx, error)

func (*Client) PublicKeyFromAddress Uses

func (c *Client) PublicKeyFromAddress(address *crypto.Address) (*crypto.PublicKey, error)

func (*Client) Query Uses

func (c *Client) Query(logger *logging.Logger) (rpcquery.QueryClient, error)

func (*Client) QueryContract Uses

func (c *Client) QueryContract(arg *QueryArg, logger *logging.Logger) (*exec.TxExecution, error)

func (*Client) Send Uses

func (c *Client) Send(arg *SendArg, logger *logging.Logger) (*payload.SendTx, error)

func (*Client) SignAndBroadcast Uses

func (c *Client) SignAndBroadcast(tx payload.Payload, logger *logging.Logger) (*exec.TxExecution, error)

func (*Client) SignTx Uses

func (c *Client) SignTx(tx payload.Payload, logger *logging.Logger) (*txs.Envelope, error)

func (*Client) Status Uses

func (c *Client) Status(logger *logging.Logger) (*rpc.ResultStatus, error)

func (*Client) Transact Uses

func (c *Client) Transact(logger *logging.Logger) (rpctransact.TransactClient, error)

func (*Client) TxInput Uses

func (c *Client) TxInput(inputString, amountString, sequenceString string, allowMempoolSigning bool, logger *logging.Logger) (*payload.TxInput, error)

func (*Client) Unbond Uses

func (c *Client) Unbond(arg *UnbondArg, logger *logging.Logger) (*payload.UnbondTx, error)

func (*Client) UpdateAccount Uses

func (c *Client) UpdateAccount(arg *GovArg, logger *logging.Logger) (*payload.GovTx, error)

type Deploy Uses

type Deploy struct {
    // (Optional, if account job or global account set) address of the account from which to send (the
    // public key for the account must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required) the filepath to the contract file. this should be relative to the current path **or**
    // relative to the contracts path established via the --dir.
    // If contract has a "bin" file extension then it will not be sent to the
    // compilers but rather will just be sent to the chain. Note, if you use a "call" job after deploying
    // a binary contract then you will be **required** to utilize an abi field in the call job.
    Contract string `mapstructure:"contract" json:"contract" yaml:"contract" toml:"contract"`
    // (Optional) the name of contract to instantiate (it has to be one of the contracts present)
    // in the file defined in Contract above.
    // When none is provided, the system will choose the contract with the same name as that file.
    // use "all" to override and deploy all contracts in order. if "all" is selected the result
    // of the job will default to the address of the contract which was deployed that matches
    // the name of the file (or the last one deployed if there are no matching names; not the "last"
    // one deployed" strategy is non-deterministic and should not be used).
    Instance string `mapstructure:"instance" json:"instance" yaml:"instance" toml:"instance"`
    // (Optional) the file path for the linkReferences for contract
    Libraries string `mapstructure:"libraries" json:"libraries" yaml:"libraries" toml:"libraries"`
    // (Optional) TODO: additional arguments to send along with the contract code
    Data interface{} `mapstructure:"data" json:"data" yaml:"data" toml:"data"`
    // (Optional) amount of tokens to send to the contract which will (after deployment) reside in the
    // contract's account
    Amount string `mapstructure:"amount" json:"amount" yaml:"amount" toml:"amount"`
    // (Optional) validators' fee
    Fee string `mapstructure:"fee" json:"fee" yaml:"fee" toml:"fee"`
    // (Optional) amount of gas which should be sent along with the contract deployment transaction
    Gas string `mapstructure:"gas" json:"gas" yaml:"gas" toml:"gas"`
    // (Optional, advanced only) sequence to use when burrow keys signs the transaction (do not use unless you
    // know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
    // (Optional) todo
    Variables []*abi.Variable
    // (Optional) Path to store an extra copy of the bin file
    Store string `mapstructure:"store" json:"store" yaml:"store" toml:"store"`
}

func (*Deploy) Validate Uses

func (job *Deploy) Validate() error

type DeployArgs Uses

type DeployArgs struct {
    Chain         string   `mapstructure:"," json:"," yaml:"," toml:","`
    KeysService   string   `mapstructure:"," json:"," yaml:"," toml:","`
    MempoolSign   bool     `mapstructure:"," json:"," yaml:"," toml:","`
    LocalABI      bool     `mapstructure:"," json:"," yaml:"," toml:","`
    Wasm          bool     `mapstructure:"," json:"," yaml:"," toml:","`
    Timeout       int      `mapstructure:"," json:"," yaml:"," toml:","`
    Address       string   `mapstructure:"," json:"," yaml:"," toml:","`
    BinPath       string   `mapstructure:"," json:"," yaml:"," toml:","`
    CurrentOutput string   `mapstructure:"," json:"," yaml:"," toml:","`
    Debug         bool     `mapstructure:"," json:"," yaml:"," toml:","`
    DefaultAmount string   `mapstructure:"," json:"," yaml:"," toml:","`
    DefaultFee    string   `mapstructure:"," json:"," yaml:"," toml:","`
    DefaultGas    string   `mapstructure:"," json:"," yaml:"," toml:","`
    DefaultOutput string   `mapstructure:"," json:"," yaml:"," toml:","`
    DefaultSets   []string `mapstructure:"," json:"," yaml:"," toml:","`
    Path          string   `mapstructure:"," json:"," yaml:"," toml:","`
    Verbose       bool     `mapstructure:"," json:"," yaml:"," toml:","`
    Jobs          int      `mapstructure:"," json:"," yaml:"," toml:","`
    ProposeVerify bool     `mapstructure:"," json:"," yaml:"," toml:","`
    ProposeVote   bool     `mapstructure:"," json:"," yaml:"," toml:","`
    ProposeCreate bool     `mapstructure:"," json:"," yaml:"," toml:","`
}

func (*DeployArgs) Validate Uses

func (args *DeployArgs) Validate() error

type DumpState Uses

type DumpState struct {
    WithValidators bool   `mapstructure:"include-validators" json:"include-validators" yaml:"include-validators" toml:"include-validators"`
    ToIPFS         bool   `mapstructure:"to-ipfs" json:"to-ipfs" yaml:"to-ipfs" toml:"to-ipfs"`
    ToFile         bool   `mapstructure:"to-file" json:"to-file" yaml:"to-file" toml:"to-file"`
    IPFSHost       string `mapstructure:"ipfs-host" json:"ipfs-host" yaml:"ipfs-host" toml:"ipfs-host"`
    FilePath       string `mapstructure:"file" json:"file" yaml:"file" toml:"file"`
}

func (*DumpState) Validate Uses

func (job *DumpState) Validate() error

type GovArg Uses

type GovArg struct {
    Input       string
    Native      string
    Power       string
    Sequence    string
    Permissions []string
    Roles       []string
    Address     string
    PublicKey   string
}

type Identify Uses

type Identify struct {
    // (Optional, if account job or global account set) address of the account from which to identify (the
    // public key for the account must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required) file containing the tendermint node to identify as
    NodeKey string `mapstructure:"nodekey" json:"nodekey" yaml:"nodekey" toml:"nodekey"`
    // (Required) publically available network address
    NetAddress string `mapstructure:"netaddress" json:"netaddress" yaml:"netaddress" toml:"netaddress"`
    // (Optional) publically available network moniker
    Moniker string `mapstructure:"moniker" json:"moniker" yaml:"moniker" toml:"moniker"`

    // (Optional, advanced only) sequence to use when burrow keys signs the transaction (do not use unless you
    // know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
}

func (*Identify) Validate Uses

func (job *Identify) Validate() error

type IdentifyArg Uses

type IdentifyArg struct {
    Input      string
    NodeKey    string
    Moniker    string
    NetAddress string
    Amount     string
    Sequence   string
}

type Job Uses

type Job struct {
    // Name of the job
    Name string `mapstructure:"name,omitempty" json:"name,omitempty" yaml:"name,omitempty" toml:"name"`
    // Not marshalled
    Intermediate interface{} `json:"-" yaml:"-" toml:"-"`
    // Not marshalled
    Result interface{} `json:"-" yaml:"-" toml:"-"`
    // For multiple values
    Variables []*abi.Variable `json:"-" yaml:"-" toml:"-"`
    // Create proposal or vote for one
    Proposal *Proposal `mapstructure:"proposal,omitempty" json:"proposal,omitempty" yaml:"proposal,omitempty" toml:"proposal"`
    // Sets/Resets the primary account to use
    Account *Account `mapstructure:"account,omitempty" json:"account,omitempty" yaml:"account,omitempty" toml:"account"`
    // Set an arbitrary value
    Set *Set `mapstructure:"set,omitempty" json:"set,omitempty" yaml:"set,omitempty" toml:"set"`
    // Run a sequence of other deploy.yamls
    Meta *Meta `mapstructure:"meta,omitempty" json:"meta,omitempty" yaml:"meta,omitempty" toml:"meta"`
    // Issue a governance transaction
    UpdateAccount *UpdateAccount `mapstructure:"update-account,omitempty" json:"update-account,omitempty" yaml:"update-account,omitempty" toml:"update-account"`
    // Contract compile and send to the chain functions
    Deploy *Deploy `mapstructure:"deploy,omitempty" json:"deploy,omitempty" yaml:"deploy,omitempty" toml:"deploy"`
    // Contract compile/build
    Build *Build `mapstructure:"build,omitempty" json:"build,omitempty" yaml:"build,omitempty" toml:"build"`
    // Send tokens from one account to another
    Send *Send `mapstructure:"send,omitempty" json:"send,omitempty" yaml:"send,omitempty" toml:"send"`
    // Bond tokens from an account
    Bond *Bond `mapstructure:"bond,omitempty" json:"bond,omitempty" yaml:"bond,omitempty" toml:"bond"`
    // Unbond tokens from an account
    Unbond *Unbond `mapstructure:"unbond,omitempty" json:"unbond,omitempty" yaml:"unbond,omitempty" toml:"unbond"`
    // Utilize monax:db's native name registry to register a name
    RegisterName *RegisterName `mapstructure:"register,omitempty" json:"register,omitempty" yaml:"register,omitempty" toml:"register"`
    // Validator identify as node key
    Identify *Identify `mapstructure:"identify,omitempty" json:"identify,omitempty" yaml:"identify,omitempty" toml:"identify"`
    // Sends a transaction which will update the permissions of an account. Must be sent from an account which
    // has root permissions on the blockchain (as set by either the genesis.json or in a subsequence transaction)
    Permission *Permission `mapstructure:"permission,omitempty" json:"permission,omitempty" yaml:"permission,omitempty" toml:"permission"`
    // Sends a transaction to a contract. Will utilize monax-abi under the hood to perform all of the heavy lifting
    Call *Call `mapstructure:"call,omitempty" json:"call,omitempty" yaml:"call,omitempty" toml:"call"`
    // Wrapper for mintdump dump. WIP
    DumpState *DumpState `mapstructure:"dump-state,omitempty" json:"dump-state,omitempty" yaml:"dump-state,omitempty" toml:"dump-state"`
    // Wrapper for mintdum restore. WIP
    RestoreState *RestoreState `mapstructure:"restore-state,omitempty" json:"restore-state,omitempty" yaml:"restore-state,omitempty" toml:"restore-state"`
    // Sends a "simulated call,omitempty" to a contract. Predominantly used for accessor functions ("Getters,omitempty" within contracts)
    QueryContract *QueryContract `mapstructure:"query-contract,omitempty" json:"query-contract,omitempty" yaml:"query-contract,omitempty" toml:"query-contract"`
    // Queries information from an account.
    QueryAccount *QueryAccount `mapstructure:"query-account,omitempty" json:"query-account,omitempty" yaml:"query-account,omitempty" toml:"query-account"`
    // Queries information about a name registered with monax:db's native name registry
    QueryName *QueryName `mapstructure:"query-name,omitempty" json:"query-name,omitempty" yaml:"query-name,omitempty" toml:"query-name"`
    // Queries information about the validator set
    QueryVals *QueryVals `mapstructure:"query-vals,omitempty" json:"query-vals,omitempty" yaml:"query-vals,omitempty" toml:"query-vals"`
    // Makes and assertion (useful for testing purposes)
    Assert *Assert `mapstructure:"assert,omitempty" json:"assert,omitempty" yaml:"assert,omitempty" toml:"assert"`
}

func (*Job) Payload Uses

func (job *Job) Payload() (Payload, error)

func (*Job) PayloadField Uses

func (job *Job) PayloadField() (reflect.Value, error)

Ensures only one Job payload is set and returns a pointer to that field or an error if none or multiple job payload fields are set

func (*Job) Validate Uses

func (job *Job) Validate() error

type Meta Uses

type Meta struct {
    // (Required) the file path of the sub yaml to run
    File     string    `mapstructure:"file" json:"file" yaml:"file" toml:"file"`
    Playbook *Playbook `json:"-" yaml:"-" toml:"-"`
}

func (*Meta) Validate Uses

func (job *Meta) Validate() error

type NameArg Uses

type NameArg struct {
    Input    string
    Amount   string
    Sequence string
    Name     string
    Data     string
    Fee      string
}

type PackageDeploy Uses

type PackageDeploy struct {
}

type Payload Uses

type Payload interface {
    validation.Validatable
}

type PermArg Uses

type PermArg struct {
    Input      string
    Sequence   string
    Action     string
    Target     string
    Permission string
    Value      string
    Role       string
}

type Permission Uses

type Permission struct {
    // (Optional, if account job or global account set) address of the account from which to send (the
    // public key for the account must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required) actions must be in the set ["set_base", "unset_base", "set_global", "add_role" "rm_role"]
    Action string `mapstructure:"action" json:"action" yaml:"action" toml:"action"`
    // (Required, unless add_role or rm_role action selected) the name of the permission flag which is to
    // be updated
    Permission string `mapstructure:"permission" json:"permission" yaml:"permission" toml:"permission"`
    // (Required) the value of the permission or role which is to be updated
    Value string `mapstructure:"value" json:"value" yaml:"value" toml:"value"`
    // (Required) the target account which is to be updated
    Target string `mapstructure:"target" json:"target" yaml:"target" toml:"target"`
    // (Required, if add_role or rm_role action selected) the role which should be given to the account
    Role string `mapstructure:"role" json:"role" yaml:"role" toml:"role"`
    // (Optional, advanced only) sequence to use when burrow keys signs the transaction (do not use unless you
    // know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
}

func (*Permission) Validate Uses

func (job *Permission) Validate() error

type PermissionString Uses

type PermissionString string

func (PermissionString) Validate Uses

func (ps PermissionString) Validate() error

type Playbook Uses

type Playbook struct {
    Filename string
    Account  string
    // Prevent this playbook from running at the same time as other playbooks
    NoParallel bool `mapstructure:"no-parallel,omitempty" json:"no-parallel,omitempty" yaml:"no-parallel,omitempty" toml:"no-parallel,omitempty"`
    Jobs       []*Job
    Path       string `mapstructure:"-" json:"-" yaml:"-" toml:"-"`
    BinPath    string `mapstructure:"-" json:"-" yaml:"-" toml:"-"`
    // If we're in a proposal or meta job, reference our parent script
    Parent *Playbook `mapstructure:"-" json:"-" yaml:"-" toml:"-"`
}

func (*Playbook) Validate Uses

func (pkg *Playbook) Validate() error

type Proposal Uses

type Proposal struct {
    // (Optional), address of the account that signs the proposal or votes for the proposal
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Optional, advanced only) sequence to use when burrow keys signs the transaction (do not use unless you
    // know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
    // (Required), address of the account used for serialising proposals, the proposals system account
    ProposalAddress string `mapstructure:"proposaladdress" json:"proposaladdress" yaml:"proposaladdress" toml:"proposaladdress"`
    // (Optional), sequence of the ProposalAddress
    ProposalSequence string `mapstructure:"proposalsequence" json:"proposalsequence" yaml:"proposalsequence" toml:"proposalsequence"`
    // (Optional)
    VotingPower string `mapstructure:"votingpower" json:"votingpower" yaml:"votingpower" toml:"votingpower"`
    // (Required) the name of the proposal
    Name string `mapstructure:"name" json:"name" yaml:"name" toml:"name"`
    // (Required) the description of the proposal
    Description string `mapstructure:"description" json:"description" yaml:"description" toml:"description"`
    // (Required) the file path of the sub yaml to run
    Jobs []*Job `mapstructure:"jobs" json:"jobs" yaml:"jobs" toml:"jobs"`
}

func (*Proposal) Validate Uses

func (job *Proposal) Validate() error

type QueryAccount Uses

type QueryAccount struct {
    // (Required) address of the account which should be queried
    Account string `mapstructure:"account" json:"account" yaml:"account" toml:"account"`
    // (Required) field which should be queried. If users are trying to query the permissions of the
    // account one can get either the `permissions.base` which will return the base permission of the
    // account, or one can get the `permissions.set` which will return the setBit of the account.
    Field string `mapstructure:"field" json:"field" yaml:"field" toml:"field"`
}

func (*QueryAccount) Validate Uses

func (job *QueryAccount) Validate() error

type QueryArg Uses

type QueryArg struct {
    Input   string
    Address string
    Data    string
}

type QueryContract Uses

type QueryContract struct {
    // (Optional, if account job or global account set) address of the account from which to send (the
    // public key for the account must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required) address of the contract which should be called
    Destination string `mapstructure:"destination" json:"destination" yaml:"destination" toml:"destination"`
    // (Required) data which should be called. will use the monax-abi tooling under the hood to formalize the
    // transaction. QueryContract will usually be used with "accessor" functions in contracts
    Function string `mapstructure:"function" json:"function" yaml:"function" toml:"function"`
    // (Optional) data to be used in the function arguments. Will use the monax-abi tooling under the hood to formalize the
    // transaction.
    Data interface{} `mapstructure:"data" json:"data" yaml:"data" toml:"data"`
    // (Optional) location of the bin file to use (can be relative path or in abi path)
    // deployed contracts save ABI artifacts in the abi folder as *both* the name of the contract
    // and the address where the contract was deployed to
    Bin string `mapstructure:"bin" json:"bin" yaml:"bin" toml:"bin"`

    Variables []*abi.Variable
}

aka. Simulated Call.

func (*QueryContract) Validate Uses

func (job *QueryContract) Validate() error

type QueryName Uses

type QueryName struct {
    // (Required) name which should be queried
    Name string `mapstructure:"name" json:"name" yaml:"name" toml:"name"`
    // (Required) field which should be quiried (generally will be "data" to get the registered "name")
    Field string `mapstructure:"field" json:"field" yaml:"field" toml:"field"`
}

func (*QueryName) Validate Uses

func (job *QueryName) Validate() error

type QueryVals Uses

type QueryVals struct {
    // (Required) should be of the set ["bonded_validators" or "unbonding_validators"] and it will
    // return a comma separated listing of the addresses which fall into one of those categories
    Query string `mapstructure:"field" json:"field" yaml:"field" toml:"field"`
}

func (*QueryVals) Validate Uses

func (job *QueryVals) Validate() error

type RegisterName Uses

type RegisterName struct {
    // (Optional, if account job or global account set) address of the account from which to send (the
    // public key for the account must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required - unless providing data file) name which will be registered
    Name string `mapstructure:"name" json:"name" yaml:"name" toml:"name"`
    // (Optional, if data_file is used; otherwise required) data which will be stored at the `name` key
    Data string `mapstructure:"data" json:"data" yaml:"data" toml:"data"`
    // (Optional) csv file in the form (name,data[,amount]) which can be used to bulk register names
    DataFile string `mapstructure:"data_file" json:"data_file" yaml:"data_file" toml:"data_file"`
    // (Optional) amount of blocks which the name entry will be reserved for the registering user
    Amount string `mapstructure:"amount" json:"amount" yaml:"amount" toml:"amount"`
    // (Optional) validators' fee
    Fee string `mapstructure:"fee" json:"fee" yaml:"fee" toml:"fee"`
    // (Optional, advanced only) sequence to use when burrow keys signs the transaction (do not use unless you
    // know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
}

func (*RegisterName) Validate Uses

func (job *RegisterName) Validate() error

type RestoreState Uses

type RestoreState struct {
    FromIPFS bool   `mapstructure:"from-ipfs" json:"from-ipfs" yaml:"from-ipfs" toml:"from-ipfs"`
    FromFile bool   `mapstructure:"from-file" json:"from-file" yaml:"from-file" toml:"from-file"`
    IPFSHost string `mapstructure:"ipfs-host" json:"ipfs-host" yaml:"ipfs-host" toml:"ipfs-host"`
    FilePath string `mapstructure:"file" json:"file" yaml:"file" toml:"file"`
}

func (*RestoreState) Validate Uses

func (job *RestoreState) Validate() error

type Send Uses

type Send struct {
    // (Optional, if account job or global account set) address of the account from which to send (the
    // public key for the account must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required) address of the account to send the tokens
    Destination string `mapstructure:"destination" json:"destination" yaml:"destination" toml:"destination"`
    // (Required) amount of tokens to send from the `source` to the `destination`
    Amount string `mapstructure:"amount" json:"amount" yaml:"amount" toml:"amount"`
    // (Optional, advanced only) sequence to use when burrow keys signs the transaction (do not use unless you
    // know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
}

func (*Send) Validate Uses

func (job *Send) Validate() error

type SendArg Uses

type SendArg struct {
    Input    string
    Amount   string
    Sequence string
    Output   string
}

type Set Uses

type Set struct {
    // (Required) value which should be saved along with the jobName (which will be the key)
    // this is useful to set variables which can be used throughout the jobs definition file (deploy.yaml).
    // It should be noted that arrays and bools must be defined using strings as such "[1,2,3]"
    // if they are intended to be used further in a assert job.
    Value string `mapstructure:"val" json:"val" yaml:"val" toml:"val"`
}

func (*Set) Validate Uses

func (job *Set) Validate() error

type Unbond Uses

type Unbond struct {
    // (Optional, if account job or global account set) address of the validator to unbond (the
    // public key for the validator must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required) the Tendermint validator power to unclaim
    Amount string `mapstructure:"amount" json:"amount" yaml:"amount" toml:"amount"`
    // (Optional, advanced only) sequence to use when burrow keys signs the transaction (do not use unless you
    // know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
}

func (*Unbond) Validate Uses

func (job *Unbond) Validate() error

type UnbondArg Uses

type UnbondArg struct {
    Output   string
    Amount   string
    Sequence string
}

type UpdateAccount Uses

type UpdateAccount struct {
    // (Optional, if account job or global account set) address of the account from which to send (the
    // public key for the account must be available to burrow keys)
    Source string `mapstructure:"source" json:"source" yaml:"source" toml:"source"`
    // (Required) The target account that will be governed - either an address or public key (its type will be determined by it's length)
    // if altering power then either a public key must be provided or the requisite public key associated with the address
    // must be available in an connected keys Signer
    Target string `mapstructure:"target" json:"target" yaml:"target" toml:"target"`
    // (Optional) the Tendermint validator power to set for this account
    Power string `mapstructure:"power" json:"power" yaml:"power" toml:"power"`
    // (Optional) The Burrow native token balance to set for this account
    Native string `mapstructure:"native" json:"native" yaml:"native" toml:"native"`
    // (Optional) the permissions to set for this account
    Permissions []PermissionString `mapstructure:"permissions" json:"permissions" yaml:"permissions" toml:"permissions"`
    // (Optional) the account permission roles to set for this account
    Roles []string `mapstructure:"roles" json:"roles" yaml:"roles" toml:"roles"`
    // (Optional, advanced only) sequence to use when burrow keys signs the transaction (do not use unless you
    // know what you're doing)
    Sequence string `mapstructure:"sequence" json:"sequence" yaml:"sequence" toml:"sequence"`
}

UpdateAccount updates an account by overwriting the given values, where values are omitted the existing values are preserved. Currently requires Root permission on Source account

func (*UpdateAccount) Validate Uses

func (job *UpdateAccount) Validate() error

Directories

PathSynopsis
rule

Package def imports 31 packages (graph) and is imported by 24 packages. Updated 2020-04-21. Refresh now. Tools for package owners.