NewTx runs the given txvm program through an instance of the txvm virtual machine, populating a new Tx object with its side effects.

PushdataByte writes instructions to b, pushing byt onto the stack.

Sign produces a chainkd signature of msg using xprv.

Sign invokes a callback function to add signatures to Inputs and Issuances in the template. The callback adds as many as it can, up to the number need

StackLen returns the length of the stack of the VM's current contract.

Tx produces a bc.Tx from the transaction currently described by the template. This involves rendering the transaction as txvm code, running it, and ex

UnmarshalJSON satisfies the json.Unmarshaler interface.

charges the creation cost of a tuple containing the given data and logs it

CommitAppliedBlock takes a block, commits it to persistent storage and sets c's state. Unlike CommitBlock, it accepts an already applied snapshot. Com

ContractSeed computes the seed of a contract whose initial program is prog.

Delete removes item from t, if present.

FromBytes parses a Block from a byte slice, by unmarshaling and converting a RawBlock protobuf.

IsZero tells whether a Hash pointer is nil or points to an all-zero hash.

State returns the most recent state available. It will not be current unless the current process is the leader. Callers should examine the returned st

WriteItem writes length-prefixed item to the hash state.

rightEncode encodes integer in a variable-length encoding unambiguously parseable from the end of a string. Used by TupleHash and KMAC.

AddPrefixkv appends keyval to any prefix stored in ctx, and returns a new context with the longer prefix.

AssetID computes the ID of an asset using the standard asset-issuance contract with the given parameters.

Input: s[0]+256*s[1]+...+256^63*s[63] = s Output: s[0]+256*s[1]+...+256^31*s[31] = s mod l where l = 2^252 + 27742317777372353535851937790883648493.

SignBlock produces a SignedBlock from a Block. It invokes its callback once for each position in [0..N) where N is the number of pubkeys in the previo

Sum256 returns the SHA3-256 digest of the data.

TxMerkleRoot creates a merkle tree from a slice of Transactions and returns the root hash of the tree.

TODO(bobg): Update the hook mechanism.

Bytes produces xprv as a byte slice.

Copy makes a copy of provided snapshot. Copying a snapshot is an O(n) operation where n is the number of nonces in the snapshot's nonce set.

Create creates a log writing to the named file with mode 0644 (before umask), appending to it if it already exists. It will rotate to files name.1, na

FeToBytes marshals h to s. Preconditions: |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. Write p=2^255-19; q=floor(h/p). Basic claim: q = fl

Get256 returns an initialized SHA3-256 hash ready to use. It is like sha3.New256 except it uses the freelist. The caller should call Put256 when finis

GetRunlimit causes the vm to write its ending runlimit to the given pointer on exit.

Helper marks the calling function as a log helper function. When logging file and line information, that function will be skipped. Helper may be calle

Name returns the name of opcode.

NewInitialBlock produces the first block for a new blockchain, using the given pubkeys and quorum for its NextPredicate.

NewShake256 creates a new SHAKE128 variable-output-length ShakeHash. Its generic security strength is 256 bits against all attacks if at least 64 byte

Put256 resets h and puts it in the freelist.

Scan satisfies the driver.Scanner interface

Verify verifies that sig is a proper signature of msg using xpub's corresponding XPrv.

Walk walks t calling walkFn for each item. If an error is returned by walkFn at any point, processing is stopped and the error is returned.

WithDetail returns a new error that wraps err as a chain error messsage containing text as its additional context. Function Detail will return the giv

XPub produces the XPub corresponding to xprv.

benchmarkHash tests the speed to hash num buffers of buflen each.

leftEncode encodes integer in a variable-length encoding unambiguously parseable from the beginning of a string. Used to encode strings for all cSHAKE

wrap adds a context message and stack trace to err and returns a new error containing the new context. This function is meant to be composed within ot

Bytes returns binary representation of a EC point (32-byte slice)

FeNeg sets h = -f Preconditions: |f| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1.1*2^24,etc. Postconditions: |h| bounded by 1.1*2^25,1.1*2^24,1.1*2^25,1

IsPushdataOp tells whether the given opcode is a pushdata instruction.

IsSmallInt tells whether the given integer can be encoded with a small-integer-encoding instruction.

MulAdd computes ab+c (mod L) and places the result in z, returning that. Any or all of the pointers may be the same.

New produces a Result from a bc.Tx by parsing the Tx object's Log.

New224 creates a new SHA3-224 hash. Its generic security strength is 224 bits against preimage attacks, and 112 bits against collision attacks.

NewXPrv takes a source of random bytes and produces a new XPrv. If r is nil, crypto/rand.Reader is used.

PushdataInt64 writes instructions to b pushing v onto the stack. It panics if v does not fit in a int64.

The scalars are GF(2^252 + 27742317777372353535851937790883648493). Input: a[0]+256*a[1]+...+256^31*a[31] = a b[0]+256*b[1]+...+256^31*b[31] = b c[0]+

Seed returns the contract seed of the VM's current contract.

Value satisfies the driver.Valuer interface

WithCommitments takes in a slice of *bc.Tx and wraps each of them with their commitments, returning a slice of *bc.CommitmentsTx

benchmarkShake is specialized to the Shake instances, which don't require a copy on reading output.