NewHash produces a hash from a 32-byte array.

Wrap adds a context message and stack trace to err and returns a new error with the new context. Arguments are handled as in fmt.Print. Use Root to re

FeMul calculates h = f * g Can overlap h with f or g. Preconditions: |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. |g| bounded by 1.1*2^26,

Op writes the provided opcode to b.

WithData returns a new error that wraps err as a chain error message containing a value of type map[string]interface{} as an extra data item. The map

FeSquare calculates h = f*f. Can overlap h with f. Preconditions: |f| bounded by 1.1*2^26,1.1*2^25,1.1*2^26,1.1*2^25,etc. Postconditions: |h| bounde

New returns an error that formats as the given text.

Bytes returns the hash as a byte slice.

Insert inserts item into t. It is an error for item to be a prefix of an element in t or to contain an element in t as a prefix. If item itself is al

It satisfies the error interface.

stack access

RootHash returns the Merkle root of the tree.

FatalErr calls t.Fatal with err and a stack trace.

Sum applies padding to the hash state and then squeezes out the desired number of output bytes.

PushdataBytes writes instructions to b, pushing data onto the stack.

AddOutput adds an Output to the template.

DeepEqual is similar to reflect.DeepEqual, but treats nil as equal to empty maps and slices. Some of the implementation is cribbed from Go's reflect p

Write makes one call on the underlying writer if no error has previously occurred.

Millis converts a time.Time to a number of milliseconds since 1970.

Bytes produces xpub as a byte slice.

PushdataInt64 writes instructions to b pushing v onto the stack.

Add adds the points in x and y, storing the result in z and returning that. Any or all of x, y, and z may be the same pointers.

NewCommitmentsTx takes a Tx object and returns a CommitmentsTx wrapped with the transaction's nonce and witness commitments.

AddInput adds an Input to the template.

SetOutput sets the log output to w. If SetOutput hasn't been called, the default behavior is to write to stdout.

ApplyBlock updates s in place. It runs in three phases: PruneNonces, ApplyBlockHeader, and ApplyTx (the latter called in a loop for each transaction).

Root returns the original error that was wrapped by one or more calls to Wrap. If e does not wrap other errors, it will be returned as-is.

WithDetailf is like WithDetail, except it formats the detail message as in fmt.Printf. Function Detail will return the formatted text when called on t

AddIssuance adds an Issuance to the template.

Contains returns whether t contains item.

Empty returns an empty state snapshot.

Sign signs the message with privateKey and returns a signature. It will panic if len(privateKey) is not PrivateKeySize.

Wrapf is like Wrap, but arguments are handled as in fmt.Printf.

Notation: word mnemonic 12345 number x'aa' or x"aa" hex data 'foo' or "foo" string [dup] quoted program {x, y, z} tupl

Hash will return the hash for this node.

VMHash computes the hash of the "function" f applied to the byte string x.

Validate is the main entrypoint to txvm. It runs the given program, producing its transaction ID if it gets as far as a "finalize" instruction. Other

HashFromBytes creates a new Hash from a byte slice. The caller is responsible for ensuring the byte slice is of the right length. It will be 0-padde

Reset resets the ShakeHash to its initial state.

Child produces the child of xprv with the given selector.

next reads the next Unicode char into s.ch. s.ch < 0 means end-of-file.

ApplyTx updates s in place.

Write writes p to the log file f. It writes only complete lines to the underlying file. Incomplete lines are buffered in memory and written once a NL

Stack returns the stack trace of an error. If the error has no stack information, it returns an empty stack trace.

GenerateBlock generates a valid, but unsigned, candidate block from the current pending transaction pool. It returns the new block and a snapshot of w

AssetID computes the asset ID of the issuance.

Byte32 returns the hash as a 32-byte array.

GenerateKey generates a public/private key pair using entropy from rand. If rand is nil, crypto/rand.Reader will be used.

MustAssemble calls Assemble and panics on error.

NewChain returns a new Chain using store as the underlying storage.

Printkv prints a structured log entry to stdout. Log fields are specified as a variadic sequence of alternating keys and values. Duplicate keys will

Root creates a merkle tree from a slice of byte slices and returns the root hash of the tree.

Tuple executes fn, passing in a TupleBuilder that exposes pushdata operations. All operations performed on the TupleBuilder during fn are shadowed to

UnmarshalText satisfies the TextUnmarshaler interface. It decodes hex data from b into h.

Encode serializes an arbitrary data type in a program, which, when executed, produces that data.

New returns a new MemStore.

StackItem returns an "inspected" copy of an item on the VM's current contract stack, by position. Position 0 is the bottom of the stack and StackLen()

Verify reports whether sig is a valid signature of message by publicKey. It will panic if len(publicKey) is not PublicKeySize.

AddInt64 returns a + b with an integer overflow check.

AddRetirement adds a Retirement to the template.

TODO(jackson): Can we make this builder more ergonomic? https://github.com/interstellar/i10r/pull/2790#issuecomment-373210076 Build returns the assemb

GeScalarMultBase computes h = a*B, where a = a[0]+256*a[1]+...+256^31 a[31] B is the Ed25519 base point (x,4/5) with x positive. Preconditions: a[31]

Height returns the current height of the blockchain.

MarshalJSON satisfies the json.Marshaler interface.