@midnightntwrk/ledger-v10 1.0.0-alpha.1

package/ledger-v10.d.ts

@@ -0,0 +1,3385 @@
+/**
+ * An onchain data value, in field-aligned binary format.
+ */
+export type Value = Array<Uint8Array>;
+/**
+ * The alignment of an onchain field-aligned binary data value.
+ */
+export type Alignment = AlignmentSegment[];
+/**
+ * A segment in a larger {@link Alignment}.
+ */
+export type AlignmentSegment = { tag: 'option', value: Alignment[] } | { tag: 'atom', value: AlignmentAtom };
+/**
+ * A atom in a larger {@link Alignment}.
+ */
+export type AlignmentAtom = { tag: 'compress' } | { tag: 'field' } | { tag: 'bytes', length: number };
+/**
+ * An onchain data value, in field-aligned binary format, annotated with its
+ * alignment.
+ */
+export type AlignedValue = { value: Value, alignment: Alignment };
+/**
+ * A Zswap nullifier, as a hex-encoded 256-bit bitstring
+ */
+export type Nullifier = string;
+/**
+ * A Zswap coin commitment, as a hex-encoded 256-bit bitstring
+ */
+export type CoinCommitment = string;
+/**
+ * A contract address, as a hex-encoded 32-byte string
+ */
+export type ContractAddress = string;
+/**
+ * A user public key address, as a hex-encoded 32-byte string
+ */
+export type UserAddress = string;
+/**
+ * The internal identifier attached to a {@link TokenType}, as a hex-encoded string.
+ */
+export type RawTokenType = string;
+
+/**
+ * Unshielded token type (or color), as a hex-encoded 32-byte string
+ */
+export type UnshieldedTokenType = { tag: 'unshielded', raw: RawTokenType };
+/**
+ * Shielded token type (or color), as a hex-encoded 32-byte string
+ */
+export type ShieldedTokenType = { tag: 'shielded', raw: RawTokenType };
+/**
+ * Dust token type
+ */
+export type DustTokenType = { tag: 'dust' };
+/**
+ * A token type (or color), as a hex-encoded 32-byte string, shielded, unshielded, or Dust
+ */
+export type TokenType = UnshieldedTokenType | ShieldedTokenType | DustTokenType;
+/**
+ * A token domain seperator, the pre-stage of `TokenType`, as 32-byte bytearray
+ */
+export type DomainSeparator = Uint8Array;
+/**
+ * A user public key capable of receiving Zswap coins, as a hex-encoded 32-byte
+ * string
+ */
+export type CoinPublicKey = string;
+/**
+ * A running tally of synthetic resource costs.
+ */
+export type RunningCost = {
+  /**
+   * The amount of (modelled) time spent reading from disk, measured in picoseconds.
+   */
+  readTime: bigint,
+  /**
+   * The amount of (modelled) time spent in single-threaded compute, measured in picoseconds.
+   */
+  computeTime: bigint,
+  /**
+   * The number of (modelled) bytes written.
+   */
+  bytesWritten: bigint,
+  /**
+   * The number of (modelled) bytes deleted.
+   */
+  bytesDeleted: bigint,
+};
+
+/**
+ * The fee prices for transaction
+ */
+export type FeePrices = {
+  /**
+   * The overall price of a full block in an average cost dimension.
+   */
+  overallPrice: number,
+  /**
+   * The price factor of time spent reading from disk.
+   */
+  readFactor: number,
+  /**
+   * The price factor of time spent in single-threaded compute.
+   */
+  computeFactor: number,
+  /**
+   * The price factor of block usage.
+   */
+  blockUsageFactor: number,
+  /**
+   * The price factor of time spent writing to disk.
+   */
+  writeFactor: number,
+}
+
+/**
+ * Holds the coin secret key of a user, serialized as a hex-encoded 32-byte string
+ */
+export class CoinSecretKey {
+  private constructor();
+
+  /**
+   * Clears the coin secret key, so that it is no longer usable nor held in memory
+   */
+  clear(): void;
+
+  yesIKnowTheSecurityImplicationsOfThis_serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): CoinSecretKey
+}
+
+/**
+ * A Zswap nonce, as a hex-encoded 256-bit string
+ */
+export type Nonce = string;
+/**
+ * The algorithm used for a particular signature.
+ *
+ * - `schnorr` corresponds to BIP-340 Schnorr signatures
+ * - `ecdsa` corresponds to ECDSA signatures over secp256k1
+ */
+export type SignatureKind = 'schnorr' | 'ecdsa';
+/**
+ * A hex-encoded signature verifying key annotated with its kind
+ */
+export type SignatureVerifyingKey = { tag: SignatureKind, value: string };
+/**
+ * A hex-encoded signing key annotated with its kind
+ */
+export type SigningKey = { tag: SignatureKind, value: string };
+/**
+ * A hex-encoded signature annotated with its kind
+ */
+export type Signature = { tag: SignatureKind, value: string };
+/**
+ * An internal encoding of a value of the proof systems scalar field
+ */
+export type Fr = Uint8Array;
+/**
+ * Information required to create a new coin, alongside details about the
+ * recipient
+ */
+export type ShieldedCoinInfo = {
+  /**
+   * The coin's type, identifying the currency it represents
+   */
+  type: RawTokenType,
+  /**
+   * The coin's randomness, preventing it from colliding with other coins
+   */
+  nonce: Nonce,
+  /**
+   * The coin's value, in atomic units dependent on the currency
+   *
+   * Bounded to be a non-negative 64-bit integer
+   */
+  value: bigint,
+};
+/**
+ * Information required to spend an existing coin, alongside authorization of
+ * the owner
+ */
+export type QualifiedShieldedCoinInfo = {
+  /**
+   * The coin's type, identifying the currency it represents
+   */
+  type: RawTokenType,
+  /**
+   * The coin's randomness, preventing it from colliding with other coins
+   */
+  nonce: Nonce,
+  /**
+   * The coin's value, in atomic units dependent on the currency
+   *
+   * Bounded to be a non-negative 64-bit integer
+   */
+  value: bigint,
+  /**
+   * The coin's location in the chain's Merkle tree of coin commitments
+   *
+   * Bounded to be a non-negative 64-bit integer
+   */
+  mt_index: bigint,
+};
+
+/**
+ * A key used to index into an array or map in the onchain VM
+ */
+export type Key = { tag: 'value', value: AlignedValue } | { tag: 'stack' };
+/**
+ * An individual operation in the onchain VM
+ *
+ * @typeParam R - `null` or {@link AlignedValue}, for gathering and verifying
+ * mode respectively
+ */
+export type Op<R> = { noop: { n: number } } |
+  'lt' |
+  'eq' |
+  'type' |
+  'size' |
+  'new' |
+  'and' |
+  'or' |
+  'neg' |
+  'log' |
+  'root' |
+  'pop' |
+  { popeq: { cached: boolean, result: R } } |
+  { addi: { immediate: number } } |
+  { subi: { immediate: number } } |
+  { push: { storage: boolean, value: EncodedStateValue } } |
+  { branch: { skip: number } } |
+  { jmp: { skip: number } } |
+  'add' |
+  'sub' |
+  { concat: { cached: boolean, n: number } } |
+  'member' |
+  { rem: { cached: boolean } } |
+  { dup: { n: number } } |
+  { swap: { n: number } } |
+  { idx: { cached: boolean, pushPath: boolean, path: Key[] } } |
+  { ins: { cached: boolean, n: number } } |
+  'ckpt';
+/**
+ * The type of a log event embedded in {@link GatherResult}.
+ */
+export type LogEventType = 'shielded-spend' |
+  'shielded-receive' |
+  'shielded-mint' |
+  'shielded-burn' |
+  'unshielded-spend' |
+  'unshielded-receive' |
+  'unshielded-mint' |
+  'unshielded-burn' |
+  'paused' |
+  'unpaused' |
+  'misc';
+/**
+ * An individual result of observing the results of a non-verifying VM program
+ * execution
+ */
+export type GatherResult = { tag: 'read', content: AlignedValue } |
+  { tag: 'log', content: { version: number, eventType: LogEventType, data: EncodedStateValue} };
+/**
+ * An alternative encoding of {@link StateValue} for use in {@link Op} for
+ * technical reasons
+ */
+export type EncodedStateValue = { tag: 'null' } |
+  { tag: 'cell', content: AlignedValue } |
+  { tag: 'map', content: Map<AlignedValue, EncodedStateValue> } |
+  { tag: 'array', content: EncodedStateValue[] } |
+  { tag: 'boundedMerkleTree', content: [number, Map<bigint, [Uint8Array, undefined]>] };
+/**
+ * A transcript of operations, to be recorded in a transaction
+ */
+export type Transcript<R> = {
+  /**
+   * The execution budget for this transcript, which {@link program} must not
+   * exceed
+   */
+  gas: RunningCost,
+  /**
+   * The effects of the transcript, which are checked before execution, and
+   * must match those constructed by {@link program}
+   */
+  effects: Effects,
+  /**
+   * The sequence of operations that this transcript captured
+   */
+  program: Op<R>[],
+};
+/**
+ * A public address that an entity can be identified by
+ */
+export type PublicAddress = { tag: 'user', address: UserAddress } | { tag: 'contract', address: ContractAddress }
+/**
+ * The context information of a call provided to the VM.
+ */
+export type CallContext = {
+  ownAddress: ContractAddress,
+  /**
+   * The commitment indices map accessible to the contract.
+   */
+  comIndices: Map<CoinCommitment, number>
+  /**
+   * The seconds since the UNIX epoch that have elapsed
+   */
+  secondsSinceEpoch: bigint,
+  /**
+   * The maximum error on {@link secondsSinceEpoch} that should occur, as a
+   * positive seconds value
+   */
+  secondsSinceEpochErr: number,
+  /**
+   * The hash of the block prior to this transaction, as a hex-encoded string
+   */
+  parentBlockHash: string,
+  /**
+   * The balances held by the called contract at the time it was called.
+   */
+  balance: Map<TokenType, bigint>,
+  /**
+   * A public address identifying an entity.
+   */
+  caller?: PublicAddress,
+  /**
+   * The {@link secondsSinceEpoch} of the previous block
+   */
+  lastBlockTime: bigint,
+};
+/**
+ * Context information about the block forwarded to {@link CallContext}.
+ */
+export type BlockContext = {
+  /**
+   * The seconds since the UNIX epoch that have elapsed
+   */
+  secondsSinceEpoch: bigint,
+  /**
+   * The maximum error on {@link secondsSinceEpoch} that should occur, as a
+   * positive seconds value
+   */
+  secondsSinceEpochErr: number,
+  /**
+   * The hash of the block prior to this transaction, as a hex-encoded string
+   */
+  parentBlockHash: string,
+  /**
+   * The {@link secondsSinceEpoch} of the previous block
+   */
+  lastBlockTime: bigint,
+};
+/**
+ * The contract-external effects of a transcript.
+ */
+export type Effects = {
+  /**
+   * The nullifiers (spends) this contract call requires
+   */
+  claimedNullifiers: Nullifier[],
+  /**
+   * The coin commitments (outputs) this contract call requires, as coins
+   * received
+   */
+  claimedShieldedReceives: CoinCommitment[],
+  /**
+   * The coin commitments (outputs) this contract call requires, as coins
+   * sent
+   */
+  claimedShieldedSpends: CoinCommitment[],
+  /**
+   * The contracts called from this contract. The values are, in order:
+   *
+   * - The sequence number of this call
+   * - The contract being called
+   * - The entry point being called
+   * - The communications commitment
+   */
+  claimedContractCalls: Array<[bigint, ContractAddress, string, Fr]>,
+  /**
+   * The shielded tokens minted in this call, as a map from hex-encoded 256-bit domain
+   * separators to unsigned 64-bit integers.
+   */
+  shieldedMints: Map<string, bigint>,
+  /**
+   * The unshielded tokens minted in this call, as a map from hex-encoded 256-bit domain
+   * separators to unsigned 64-bit integers.
+   */
+  unshieldedMints: Map<string, bigint>,
+  /**
+   * The unshielded inputs this contract expects.
+   */
+  unshieldedInputs: Map<TokenType, bigint>,
+  /**
+   * The unshielded outputs this contract authorizes.
+   */
+  unshieldedOutputs: Map<TokenType, bigint>,
+  /**
+   * The unshielded UTXO outputs this contract expects to be present.
+   */
+  claimedUnshieldedSpends: Map<[TokenType, PublicAddress], bigint>,
+};
+
+/**
+ * A hex-encoded commitment of data shared between two contracts in a call
+ */
+export type CommunicationCommitment = string;
+/**
+ * The hex-encoded randomness to {@link CommunicationCommitment}
+ */
+export type CommunicationCommitmentRand = string;
+
+/**
+ * Samples a new {@link CommunicationCommitmentRand} uniformly
+ */
+export function communicationCommitmentRandomness(): CommunicationCommitmentRand;
+
+/**
+ * Computes the communication commitment corresponding to an input/output pair and randomness.
+ */
+export function communicationCommitment(input: AlignedValue, output: AlignedValue, rand: CommunicationCommitmentRand): CommunicationCommitment;
+
+/**
+ * Computes the (hex-encoded) hash of a given contract entry point. Used in
+ * composable contracts to reference the called contract's entry point ID
+ * in-circuit.
+ */
+export function entryPointHash(entryPoint: string | Uint8Array): string;
+
+/**
+ * Randomly samples a {@link SigningKey}. If `kind` is not supplied, assumes
+ * `schnorr`.
+ */
+export function sampleSigningKey(kind?: SignatureKind): SigningKey;
+
+/**
+ * Creates a {@link SigningKey} from provided Bip340 private key.
+ */
+export function signingKeyFromBip340(data: Uint8Array): SigningKey;
+
+/**
+ * Signs arbitrary data with the given signing key.
+ *
+ * WARNING: Do not expose access to this function for valuable keys for data
+ * that is not strictly controlled!
+ */
+export function signData(key: SigningKey, data: Uint8Array): Signature;
+
+/**
+ * Returns the verifying key for a given signing key
+ */
+export function signatureVerifyingKey(sk: SigningKey): SignatureVerifyingKey;
+
+/**
+ * Verifies if a signature is correct
+ */
+export function verifySignature(vk: SignatureVerifyingKey, data: Uint8Array, signature: Signature): boolean;
+
+/**
+ * Encode a raw {@link RawTokenType} into a `Uint8Array` for use in Compact's
+ * `RawTokenType` type
+ */
+export function encodeRawTokenType(tt: RawTokenType): Uint8Array;
+
+/**
+ * Decode a raw {@link RawTokenType} from a `Uint8Array` originating from Compact's
+ * `RawTokenType` type
+ */
+export function decodeRawTokenType(tt: Uint8Array): RawTokenType;
+
+/**
+ * Encode a {@link ContractAddress} into a `Uint8Array` for use in Compact's
+ * `ContractAddress` type
+ */
+export function encodeContractAddress(addr: ContractAddress): Uint8Array;
+
+/**
+ * Decode a {@link ContractAddress} from a `Uint8Array` originating from
+ * Compact's `ContractAddress` type
+ */
+export function decodeContractAddress(addr: Uint8Array): ContractAddress;
+
+/**
+ * Encode a {@link UserAddress} into a `Uint8Array` for use in Compact's
+ * `UserAddress` type
+ */
+export function encodeUserAddress(addr: UserAddress): Uint8Array;
+
+/**
+ * Decode a {@link UserAddress} from a `Uint8Array` originating from
+ * Compact's `UserAddress` type
+ */
+export function decodeUserAddress(addr: Uint8Array): UserAddress;
+
+/**
+ * Encode a {@link CoinPublicKey} into a `Uint8Array` for use in Compact's
+ * `CoinPublicKey` type
+ */
+export function encodeCoinPublicKey(pk: CoinPublicKey): Uint8Array;
+
+/**
+ * Decode a {@link CoinPublicKey} from a `Uint8Array` originating from Compact's
+ * `CoinPublicKey` type
+ */
+export function decodeCoinPublicKey(pk: Uint8Array): CoinPublicKey;
+
+/**
+ * Encode a {@link ShieldedCoinInfo} into a Compact's `ShieldedCoinInfo` TypeScript
+ * representation
+ */
+export function encodeShieldedCoinInfo(coin: ShieldedCoinInfo): { color: Uint8Array, nonce: Uint8Array, value: bigint };
+
+/**
+ * Encode a {@link QualifiedShieldedCoinInfo} into a Compact's `QualifiedShieldedCoinInfo`
+ * TypeScript representation
+ */
+export function encodeQualifiedShieldedCoinInfo(coin: QualifiedShieldedCoinInfo): {
+  color: Uint8Array,
+  nonce: Uint8Array,
+  value: bigint,
+  mt_index: bigint
+};
+
+/**
+ * Decode a {@link ShieldedCoinInfo} from Compact's `ShieldedCoinInfo` TypeScript representation
+ */
+export function decodeShieldedCoinInfo(coin: { color: Uint8Array, nonce: Uint8Array, value: bigint }): ShieldedCoinInfo;
+
+/**
+ * Decode a {@link QualifiedShieldedCoinInfo} from Compact's `QualifiedShieldedCoinInfo`
+ * TypeScript representation
+ */
+export function decodeQualifiedShieldedCoinInfo(coin: {
+  color: Uint8Array,
+  nonce: Uint8Array,
+  value: bigint,
+  mt_index: bigint
+}): QualifiedShieldedCoinInfo;
+
+/**
+ * Derives the raw {@link RawTokenType} associated with a particular
+ * {@link DomainSeparator} and contract.
+ */
+export function rawTokenType(domain_sep: DomainSeparator, contract: ContractAddress): RawTokenType;
+
+/**
+ * Samples a uniform contract address, for use in testing
+ */
+export function sampleContractAddress(): ContractAddress;
+
+/**
+ * Samples a uniform user address, for use in testing
+ */
+export function sampleUserAddress(): UserAddress;
+
+/**
+ * Samples a uniform raw token type, for use in testing to construct
+ * both the shielded and unshielded token types.
+ */
+export function sampleRawTokenType(): RawTokenType;
+
+/**
+ * A sample contract address
+ */
+export function dummyContractAddress(): ContractAddress;
+
+/**
+ * A sample user address
+ */
+export function dummyUserAddress(): UserAddress;
+
+/**
+ * Internal implementation of the runtime's coin commitment primitive.
+ * @internal
+ */
+export function runtimeCoinCommitment(coin: AlignedValue, recipient: AlignedValue): AlignedValue;
+
+/**
+ * Internal implementation of the runtime's coin nullifier primitive.
+ * @internal
+ */
+export function runtimeCoinNullifier(coin: AlignedValue, sender_evidence: AlignedValue): AlignedValue;
+
+/**
+ * Internal implementation of the Merkle tree leaf hash primitive.
+ * @internal
+ */
+export function leafHash(value: AlignedValue): AlignedValue;
+
+/**
+ * Internal implementation of the max aligned size primitive.
+ * @internal
+ */
+export function maxAlignedSize(alignment: Alignment): bigint;
+
+/**
+ * Returns the maximum representable value in the proof systems scalar field
+ * (that is, 1 less than the prime modulus)
+ */
+export function maxField(): bigint;
+
+/**
+ * Converts input, output, and transcript information into a proof preimage
+ * suitable to pass to a `ProvingProvider`.
+ *
+ * The `key_location` parameter is a string used to identify the circuit by
+ * proving machinery, for backwards-compatibility, if unset it defaults to
+ * `'dummy'`.
+ */
+export function proofDataIntoSerializedPreimage(
+  input: AlignedValue,
+  output: AlignedValue,
+  public_transcript: Op<AlignedValue>[],
+  private_transcript_outputs: AlignedValue[],
+  key_location?: string,
+  inner_proofs?: Uint8Array[],
+): Uint8Array;
+
+/**
+ * Takes a bigint modulus the proof systems scalar field
+ */
+export function bigIntModFr(x: bigint): bigint;
+
+/**
+ * Returns the largest representable JubJub scalar (i.e. the JubJub scalar field modulus minus one).
+ */
+export function maxJubjubScalar(): bigint;
+
+/**
+ * Samples a random JubJub scalar, returned as a native field element.
+ */
+export function jubjubSampleScalar(): Value;
+
+/**
+ * Converts a native field element (BLS12-381 scalar) to a JubJub scalar field
+ * element, reducing modulo the JubJub scalar field modulus.
+ */
+export function jubjubScalarFromNative(native: Value): Value;
+
+/**
+ * Converts a JubJub scalar field element to a native field element (BLS12-381 scalar).
+ */
+export function nativeFromJubjubScalar(jubjub: Value): Value;
+
+/**
+ * Internal conversion between field-aligned binary values and bigints within
+ * the scalar field
+ * @internal
+ * @throws If the value does not encode a field element
+ */
+export function valueToBigInt(x: Value): bigint;
+
+/**
+ * Internal conversion between bigints and their field-aligned binary
+ * representation
+ * @internal
+ */
+export function bigIntToValue(x: bigint): Value;
+
+/**
+ * Internal implementation of the transient hash primitive
+ * @internal
+ * @throws If {@link val} does not have alignment {@link align}
+ */
+export function transientHash(align: Alignment, val: Value): Value;
+
+/**
+ * Internal implementation of the transient commitment primitive
+ * @internal
+ * @throws If {@link val} does not have alignment {@link align}, or
+ * {@link opening} does not encode a field element
+ */
+export function transientCommit(align: Alignment, val: Value, opening: Value): Value;
+
+/**
+ * Internal implementation of the persistent hash primitive
+ * @internal
+ * @throws If {@link val} does not have alignment {@link align}, or any
+ * component has a compress alignment
+ */
+export function persistentHash(align: Alignment, val: Value): Value;
+
+/**
+ * Internal implementation of the persistent commitment primitive
+ * @internal
+ * @throws If {@link val} does not have alignment {@link align},
+ * {@link opening} does not encode a 32-byte bytestring, or any component has a
+ * compress alignment
+ */
+export function persistentCommit(align: Alignment, val: Value, opening: Value): Value;
+
+/**
+ * Internal implementation of the degrade to transient primitive
+ * @internal
+ * @throws If {@link persistent} does not encode a 32-byte bytestring
+ */
+export function degradeToTransient(persistent: Value): Value;
+
+/**
+ * Internal implementation of the upgrade from transient primitive
+ * @internal
+ * @throws If {@link transient} does not encode a field element
+ */
+export function upgradeFromTransient(transient: Value): Value;
+
+/**
+ * Internal implementation of the hash to curve primitive
+ * @internal
+ * @throws If {@link val} does not have alignment {@link align}
+ */
+export function hashToCurve(align: Alignment, val: Value): Value;
+
+/**
+ * Internal implementation of the elliptic curve addition primitive
+ * @internal
+ * @throws If either input does not encode an elliptic curve point
+ */
+export function ecAdd(a: Value, b: Value): Value;
+
+/**
+ * Internal implementation of the elliptic curve multiplication primitive
+ * @internal
+ * @throws If {@link a} does not encode an elliptic curve point or {@link b}
+ * does not encode a field element
+ */
+export function ecMul(a: Value, b: Value): Value;
+
+/**
+ * Internal implementation of the elliptic curve generator multiplication
+ * primitive
+ * @internal
+ * @throws if {@link val} does not encode a field element
+ */
+export function ecMulGenerator(val: Value): Value;
+
+/**
+ * Runs a VM program against an initial stack, with an optional gas limit
+ */
+export function runProgram(initial: VmStack, ops: Op<null>[], cost_model: CostModel, gas_limit?: RunningCost): VmResults;
+
+/**
+ * An individual operation, or entry point of a contract, consisting primarily
+ * of a ZK verifier keys, potentially for different versions of the proving
+ * system.
+ *
+ * Only the latest available version is exposed to this API.
+ *
+ * Note that the serialized form of the key is checked on initialization
+ */
+export class ContractOperation {
+  constructor();
+
+  verifierKey: Uint8Array;
+
+  serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): ContractOperation;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * A committee permitted to make changes to this contract. If a threshold of
+ * the public keys in this committee sign off, they can change the rules of
+ * this contract, or recompile it for a new version.
+ *
+ * If the threshold is greater than the number of committee members, it is
+ * impossible for them to sign anything.
+ */
+export class ContractMaintenanceAuthority {
+  /**
+   * Constructs a new authority from its components
+   *
+   * If not supplied, `counter` will default to `0n`. Values should be
+   * non-negative, and at most 2^32 - 1.
+   *
+   * At deployment, `counter` must be `0n`, and any subsequent update should
+   * set counter to exactly one greater than the current value.
+   */
+  constructor(committee: Array<SignatureVerifyingKey>, threshold: number, counter?: bigint);
+
+  /**
+   * The committee public keys
+   */
+  readonly committee: Array<SignatureVerifyingKey>;
+  /**
+   * How many keys must sign rule changes
+   */
+  readonly threshold: number;
+  /**
+   * The replay protection counter
+   */
+  readonly counter: bigint;
+
+  serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): ContractMaintenanceAuthority;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * The state of a contract, consisting primarily of the {@link data} accessible
+ * directly to the contract, and the map of {@link ContractOperation}s that can
+ * be called on it, the keys of which can be accessed with {@link operations},
+ * and the individual operations can be read with {@link operation} and written
+ * to with {@link setOperation}.
+ */
+export class ContractState {
+  /**
+   * Creates a blank contract state
+   */
+  constructor();
+
+  /**
+   * Return a list of the entry points currently registered on this contract
+   */
+  operations(): Array<string | Uint8Array>
+
+  /**
+   * Get the operation at a specific entry point name
+   */
+  operation(operation: string | Uint8Array): ContractOperation | undefined;
+
+  /**
+   * Set a specific entry point name to contain a given operation
+   */
+  setOperation(operation: string | Uint8Array, value: ContractOperation): void;
+
+  /**
+   * Runs a series of operations against the current state, and returns the
+   * results
+   */
+  query(query: Op<null>[], cost_model: CostModel): GatherResult[];
+
+  serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): ContractState;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The current value of the primary state of the contract
+   */
+  data: ChargedState;
+  /**
+   * The maintenance authority associated with this contract
+   */
+  maintenanceAuthority: ContractMaintenanceAuthority;
+  /**
+   * The public balances held by this contract
+   */
+  balance: Map<TokenType, bigint>;
+}
+
+/**
+ * Provides the information needed to fully process a transaction, including
+ * information about the rest of the transaction, and the state of the chain at
+ * the time of execution.
+ */
+export class QueryContext {
+  /**
+   * Construct a basic context from a contract's address and current state
+   * value
+   */
+  constructor(state: ChargedState, address: ContractAddress);
+
+  /**
+   * Register a given coin commitment as being accessible at a specific index,
+   * for use when receiving coins in-contract, and needing to record their
+   * index to later spend them
+   */
+  insertCommitment(comm: CoinCommitment, index: bigint): QueryContext;
+
+  /**
+   * Internal counterpart to {@link insertCommitment}; upgrades an encoded
+   * {@link ShieldedCoinInfo} to an encoded {@link QualifiedShieldedCoinInfo} using the
+   * inserted commitments
+   * @internal
+   */
+  qualify(coin: Value): Value | undefined;
+
+  /**
+   * Runs a transcript in verifying mode against the current query context,
+   * outputting a new query context, with the {@link state} and {@link effects}
+   * from after the execution.
+   */
+  runTranscript(transcript: Transcript<AlignedValue>, cost_model: CostModel): QueryContext;
+
+  /**
+   * Runs a sequence of operations in gather mode, returning the results of the
+   * gather.
+   */
+  query(ops: Op<null>[], cost_model: CostModel, gas_limit?: RunningCost): QueryResults;
+
+  /**
+   * Converts the QueryContext to {@link VmStack}.
+   */
+  toVmStack(): VmStack;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The address of the contract
+   */
+  readonly address: ContractAddress;
+  /**
+   * The block-level information accessible to the contract
+   */
+  block: CallContext;
+  /**
+   * The commitment indices map accessible to the contract, primarily via
+   * {@link qualify}
+   */
+  readonly comIndices: Map<CoinCommitment, bigint>;
+  /**
+   * The effects that occurred during execution against this context, should
+   * match those declared in a {@link Transcript}
+   */
+  effects: Effects;
+  /**
+   * The current contract state retained in the context
+   */
+  readonly state: ChargedState;
+}
+
+/**
+ * A cost model for calculating transaction fees
+ */
+export class CostModel {
+  private constructor();
+
+  /**
+   * The initial cost model of Midnight
+   */
+  static initialCostModel(): CostModel;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * The results of making a query against a specific state or context
+ */
+export class QueryResults {
+  private constructor();
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The context state after executing the query. This can be used to execute
+   * further queries
+   */
+  readonly context: QueryContext;
+  /**
+   * Any events/results that occurred during or from the query
+   */
+  readonly events: GatherResult[];
+  /**
+   * The measured cost of executing the query
+   */
+  readonly gasCost: RunningCost;
+}
+
+/**
+ * Represents a fixed-depth Merkle tree storing hashed data, whose preimages
+ * are unknown
+ */
+export class StateBoundedMerkleTree {
+  /**
+   * Create a blank tree with the given height
+   */
+  constructor(height: number);
+
+  /**
+   * Internal implementation of the merkle tree root primitive.
+   * Returns undefined if the tree has not been fully hashed.
+   * @internal
+   */
+  root(): AlignedValue | undefined;
+
+  /**
+   * Internal implementation of the finding path primitive.
+   * Returns undefined if the leaf is not in the tree.
+   * @internal
+   */
+  findPathForLeaf(
+    leaf: AlignedValue,
+    indexStart?: bigint,
+    indexEnd?: bigint,
+    alreadyHashed?: boolean,
+  ): AlignedValue | undefined;
+
+  /**
+   * Internal implementation of the path construction primitive
+   * @internal
+   * @throws If the index is out-of-bounds for the tree
+   */
+  pathForLeaf(index: bigint, leaf: AlignedValue): AlignedValue;
+
+  /**
+   * Inserts a value into the Merkle tree, returning the updated tree
+   * @throws If the index is out-of-bounds for the tree
+   */
+  update(index: bigint, leaf: AlignedValue): StateBoundedMerkleTree;
+
+  /**
+   * Rehashes the tree, updating all internal hashes and ensuring all
+   * node hashes are present. Necessary because the onchain runtime does
+   * not automatically rehash trees.
+   */
+  rehash(): StateBoundedMerkleTree;
+
+  /**
+   * Erases all but necessary hashes between, and inclusive of, `start` and
+   * `end` inidices @internal
+   * @throws If the indices are out-of-bounds for the tree, or `end < start`
+   */
+  collapse(start: bigint, end: bigint): StateBoundedMerkleTree;
+
+  toString(compact?: boolean): string;
+
+  readonly height: number;
+}
+
+/**
+ * Represents a key-value map, where keys are {@link AlignedValue}s, and values
+ * are {@link StateValue}s.
+ */
+export class StateMap {
+  constructor();
+
+  keys(): AlignedValue[];
+
+  get(key: AlignedValue): StateValue | undefined;
+
+  insert(key: AlignedValue, value: StateValue): StateMap;
+
+  remove(key: AlignedValue): StateMap;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * Represents a {@link StateValue} with storage annotations.
+ *
+ * These track the state usage that has been charged for so far.
+ */
+export class ChargedState {
+  constructor(state: StateValue);
+  readonly state: StateValue;
+  toString(compact?: boolean): string;
+}
+
+/**
+ * Represents the core of a contract's state, and recursively represents each
+ * of its components.
+ *
+ * There are different *classes* of state values:
+ * - `null`
+ * - Cells of {@link AlignedValue}s
+ * - Maps from {@link AlignedValue}s to state values
+ * - Bounded Merkle trees containing {@link AlignedValue} leaves
+ * - Short (\<= 15 element) arrays of state values
+ *
+ * State values are *immutable*, any operations that mutate states will return
+ * a new state instead.
+ */
+export class StateValue {
+  private constructor();
+
+  type(): 'null' | 'cell' | 'map' | 'array' | 'boundedMerkleTree';
+
+  static newNull(): StateValue;
+
+  static newCell(value: AlignedValue): StateValue;
+
+  static newMap(map: StateMap): StateValue;
+
+  static newBoundedMerkleTree(tree: StateBoundedMerkleTree): StateValue;
+
+  static newArray(): StateValue;
+
+  arrayPush(value: StateValue): StateValue;
+
+  asCell(): AlignedValue;
+
+  asMap(): StateMap | undefined;
+
+  asBoundedMerkleTree(): StateBoundedMerkleTree | undefined;
+
+  asArray(): StateValue[] | undefined;
+
+  logSize(): number;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * @internal
+   */
+  encode(): EncodedStateValue;
+
+  /**
+   * @internal
+   */
+  static decode(value: EncodedStateValue): StateValue;
+}
+
+/**
+ * Represents the results of a VM call
+ */
+export class VmResults {
+  private constructor();
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The events that got emitted by this VM invocation
+   */
+  readonly events: GatherResult[];
+  /**
+   * The computed gas cost of running this VM invocation
+   */
+  readonly gasCost: RunningCost;
+  /**
+   * The VM stack at the end of the VM invocation
+   */
+  readonly stack: VmStack;
+}
+
+/**
+ * Represents the state of the VM's stack at a specific point. The stack is an
+ * array of {@link StateValue}s, each of which is also annotated with whether
+ * it is "strong" or "weak"; that is, whether it is permitted to be stored
+ * on-chain or not.
+ */
+export class VmStack {
+  constructor();
+
+  push(value: StateValue, is_strong: boolean): void;
+
+  removeLast(): void;
+
+  length(): number;
+
+  get(idx: number): StateValue | undefined;
+
+  isStrong(idx: number): boolean | undefined;
+
+  toString(compact?: boolean): string;
+}
+
+
+/**
+ * A zero-knowledge proof.
+ */
+export class Proof {
+  constructor(data: String);
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): Proof;
+  toString(compact?: boolean): string;
+  instance: 'proof';
+  private type_: 'proof';
+}
+
+/**
+ * The preimage, or data required to produce, a {@link Proof}.
+ */
+export class PreProof {
+  constructor(data: String);
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): PreProof;
+  toString(compact?: boolean): string;
+  instance: 'pre-proof';
+  private type_: 'pre-proof';
+}
+
+/**
+ * A unit type used to indicate the absence of proofs.
+ */
+export class NoProof {
+  constructor();
+  toString(compact?: boolean): string;
+  instance: 'no-proof';
+  private type_: 'no-proof';
+}
+
+/**
+ * How proofs are currently being represented, between:
+ * - Actual zero-knowledge proofs, as should be transmitted to the network
+ * - The data required to *produce* proofs, for constructing and preparing
+ *   transactions.
+ * - Proofs not being provided, largely for testing use or replaying already
+ *   validated transactions.
+ */
+export type Proofish = Proof | PreProof | NoProof;
+
+/**
+ * A Fiat-Shamir proof of exponent binding (or ephemerally signing) an
+ * {@link Intent}.
+ */
+export class Binding {
+  constructor(data: String);
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): Binding;
+  toString(compact?: boolean): string;
+  instance: 'binding';
+  private type_: 'binding';
+}
+
+/**
+ * Information that will be used to bind an {@link Intent} in the future, but
+ * does not yet prevent modification of it.
+ */
+export class PreBinding {
+  constructor(data: String);
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): PreBinding;
+  toString(compact?: boolean): string;
+  instance: 'pre-binding';
+  private type_: 'pre-binding';
+}
+
+export class NoBinding {
+  constructor(data: String);
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): NoBinding;
+  toString(compact?: boolean): string;
+  instance: 'no-binding';
+  private type_: 'no-binding';
+}
+
+/**
+ * Whether an intent has binding cryptography applied or not. An intent's
+ * content can no longer be modified after it is {@link Binding}.
+ */
+export type Bindingish = Binding | PreBinding | NoBinding;
+
+export class SignatureEnabled {
+  constructor(data: Signature);
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): SignatureEnabled;
+  toString(compact?: boolean): string;
+  readonly instance: 'signature';
+  private type_: 'signature';
+  readonly value: Signature;
+}
+
+export class SignatureErased {
+  constructor();
+  toString(compact?: boolean): string;
+  readonly instance: 'signature-erased';
+  private type_: 'signature-erased';
+}
+
+export type Signaturish = SignatureEnabled | SignatureErased;
+
+/**
+ * A type representing a transaction that has not been proven yet
+ */
+export type UnprovenInput = ZswapInput<PreProof>;
+
+/**
+ * A type representing a transaction output that has not been proven yet.
+ */
+export type UnprovenOutput = ZswapOutput<PreProof>;
+
+/**
+ * A type representing a transaction transient that has not been proven yet.
+ */
+export type UnprovenTransient = ZswapTransient<PreProof>;
+
+/**
+ * A type representing an offer that has not been proven yet.
+ */
+export type UnprovenOffer = ZswapOffer<PreProof>;
+
+/**
+ * A type representing an intent that has not been proven yet.
+ */
+export type UnprovenIntent = Intent<SignatureEnabled, PreProof, PreBinding>;
+
+/**
+ * An interactions with a contract
+ */
+export type ContractAction<P extends Proofish> = ContractCall<P> | ContractDeploy | MaintenanceUpdate;
+
+/**
+ * Strictness criteria for evaluating transaction well-formedness, used for
+ * disabling parts of transaction validation for testing.
+ */
+export class WellFormedStrictness {
+  constructor();
+
+  /**
+   * Whether to require the transaction to have a non-negative balance
+   */
+  enforceBalancing: boolean;
+  /**
+   * Whether to validate Midnight-native (non-contract) proofs in the transaction
+   */
+  verifyNativeProofs: boolean;
+  /**
+   * Whether to validate contract proofs in the transaction
+   */
+  verifyContractProofs: boolean;
+  /**
+   * Whether to enforce the transaction byte limit
+   */
+  enforceLimits: boolean;
+  /**
+   * Whether to enforce the signature verification
+   */
+  verifySignatures: boolean;
+}
+
+/**
+ * Contains the raw file contents required for proving
+ */
+export type ProvingKeyMaterial = {
+  proverKey: Uint8Array,
+  verifierKey: Uint8Array,
+  ir: Uint8Array,
+};
+
+/**
+ * A modelled cost of a transaction or block.
+ */
+export type SyntheticCost = {
+  /**
+   * The amount of (modelled) time spent reading from disk, measured in picoseconds.
+   */
+  readTime: bigint,
+  /**
+   * The amount of (modelled) time spent in single-threaded compute, measured in picoseconds.
+   */
+  computeTime: bigint,
+  /**
+   * The number of bytes of blockspace used
+   */
+  blockUsage: bigint,
+  /**
+   * The net number of (modelled) bytes written, i.e. max(0, absolute written bytes less deleted bytes).
+   */
+  bytesWritten: bigint,
+  /**
+   * The number of (modelled) bytes written temporarily or overwritten.
+   */
+  bytesChurned: bigint,
+};
+
+/**
+ * A normalized form of {@link SyntheticCost}.
+ */
+export type NormalizedCost = {
+  /**
+   * The amount of (modelled) time spent reading from disk, measured in picoseconds.
+   */
+  readTime: number,
+  /**
+   * The amount of (modelled) time spent in single-threaded compute, measured in picoseconds.
+   */
+  computeTime: number,
+  /**
+   * The number of bytes of blockspace used
+   */
+  blockUsage: number,
+  /**
+   * The net number of (modelled) bytes written, i.e. max(0, absolute written bytes less deleted bytes).
+   */
+  bytesWritten: number,
+  /**
+   * The number of (modelled) bytes written temporarily or overwritten.
+   */
+  bytesChurned: number,
+};
+
+/**
+ * An event emitted by the ledger
+ */
+export class Event {
+  private constructor();
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): Event;
+  toString(compact?: boolean): string;
+  readonly source: EventSource;
+  readonly content: EventDetails;
+}
+
+/**
+ * Where an event originated from
+ */
+export type EventSource = {
+  /**
+   * The hash of the originating transaction.
+   */
+  transactionHash: TransactionHash,
+  /**
+   * The logical event segment, that is, during which segment's execution the
+   * event was emitted.
+   */
+  logicalSegment: number,
+  /**
+   * The physical event segment, that is, the segment of the transaction this
+   * event's trigger is contained in.
+   */
+  physicalSegment: number,
+};
+
+/**
+ * Details of the event emitted
+ */
+export type EventDetails =
+  {
+    tag: 'zswapInput',
+    nullifier: Nullifier,
+    contract: ContractAddress | undefined,
+  } | {
+    tag: 'zswapOutput',
+    commitment: CoinCommitment,
+    contract: ContractAddress | undefined,
+    mtIndex: bigint,
+  } | {
+    tag: 'dustInitialUtxo',
+    generation: DustGenerationInfo,
+    generationIndex: bigint,
+    blockTime: Date,
+  } | {
+    tag: 'dustGenerationDtimeUpdate',
+    update: TreeInsertionPath<DustGenerationInfo>,
+    blockTime: Date,
+  } | {
+    tag: 'dustSpendProcessed',
+    commitment: DustCommitment,
+    commitmentIndex: bigint,
+    nullifier: DustNullifier,
+    vFee: bigint,
+    declaredTime: Date,
+    blockTime: Date,
+  } | {
+    tag: 'contractLog',
+    address: ContractAddress,
+    entryPoint: Uint8Array | string,
+    loggedItem: {
+      version: number,
+      eventType: LogEventType,
+      data: EncodedStateValue,
+    },
+  } |
+  // Other variants may be added and some events are not yet supported in this API.
+  { tag: string };
+
+/**
+ * A path evidencing how to insert an entry into a Merkle tree, even if it is
+ * collapsed.
+ */
+export type TreeInsertionPath<A> = {
+  leafHash: string,
+  annotation: A,
+  path: TreeInsertionPathEntry[],
+};
+
+/**
+ * A single entry in a {@link TreeInsertionPath}.
+ */
+export type TreeInsertionPathEntry = {
+  hash: bigint | undefined,
+  goesLeft: boolean,
+};
+
+/**
+ * A secret key for the Dust, used to derive Dust UTxO nonces and prove credentials to spend Dust UTxOs
+ */
+export class DustSecretKey {
+  private constructor();
+
+  /**
+   * Temporary method to create an instance of {@link DustSecretKey} from a bigint (its natural representation)
+   * @param bigint
+   */
+  static fromBigint(bigint: bigint): DustSecretKey;
+
+  /**
+   * Create an instance of {@link DustSecretKey} from a seed.
+   * @param seed
+   */
+  static fromSeed(seed: Uint8Array): DustSecretKey;
+
+  publicKey: DustPublicKey;
+
+  /**
+   * Clears the dust secret key, so that it is no longer usable nor held in memory
+   */
+  clear(): void;
+}
+
+// TODO: Doc comments
+export type DustPublicKey = bigint;
+export type DustInitialNonce = string;
+export type DustNonce = bigint;
+export type DustCommitment = bigint;
+export type DustNullifier = bigint;
+
+export function sampleDustSecretKey(): DustSecretKey;
+
+export function updatedValue(ctime: Date, initialValue: bigint, genInfo: DustGenerationInfo, now: Date, params: DustParameters): bigint;
+
+export type DustOutput = {
+  initialValue: bigint,
+  owner: DustPublicKey,
+  nonce: DustNonce,
+  seq: number,
+  ctime: Date,
+  backingNight: DustInitialNonce,
+};
+
+export type QualifiedDustOutput = {
+  initialValue: bigint,
+  owner: DustPublicKey,
+  nonce: DustNonce,
+  seq: number,
+  ctime: Date,
+  backingNight: DustInitialNonce,
+  mtIndex: bigint,
+};
+
+export type DustGenerationInfo = {
+  value: bigint,
+  owner: DustPublicKey,
+  nonce: DustInitialNonce,
+  dtime: Date | undefined,
+};
+
+export type DustGenerationUniquenessInfo = {
+  value: bigint,
+  owner: DustPublicKey,
+  nonce: DustInitialNonce,
+};
+
+export class DustSpend<P extends Proofish> {
+  private constructor();
+  serialize(): Uint8Array;
+  static deserialize<P extends Proofish>(markerP: P['instance'], raw: Uint8Array): DustSpend<P>;
+  toString(compact?: boolean): string;
+  readonly vFee: bigint;
+  readonly oldNullifier: DustNullifier;
+  readonly newCommitment: DustCommitment;
+  readonly proof: P;
+}
+
+export class DustRegistration<S extends Signaturish> {
+  constructor(markerS: S['instance'], nightKey: SignatureVerifyingKey, dustAddress: DustPublicKey | undefined, allowFeePayment: bigint, signature?: S);
+  serialize(): Uint8Array;
+  static deserialize<S extends Signaturish>(markerS: S['instance'], raw: Uint8Array): DustRegistration<S>;
+  toString(compact?: boolean): string;
+  nightKey: SignatureVerifyingKey;
+  dustAddress: DustPublicKey | undefined;
+  allowFeePayment: bigint;
+  signature: S;
+}
+
+export class DustActions<S extends Signaturish, P extends Proofish> {
+  constructor(markerS: S['instance'], markerP: P['instance'], ctime: Date, spends?: DustSpend<P>[], registrations?: DustRegistration<S>[]);
+  serialize(): Uint8Array;
+  static deserialize<S extends Signaturish, P extends Proofish>(markerS: S['instance'], markerP: P['instance'], raw: Uint8Array): DustActions<S, P>;
+  toString(compact?: boolean): string;
+  spends: DustSpend<P>[];
+  registrations: DustRegistration<S>[];
+  ctime: Date;
+}
+
+export class DustParameters {
+  constructor(nightDustRatio: bigint, generationDecayRate: bigint, dustGracePeriodSeconds: bigint);
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): DustParameters;
+  toString(compact?: boolean): string;
+  nightDustRatio: bigint;
+  generationDecayRate: bigint;
+  dustGracePeriodSeconds: bigint;
+  readonly timeToCapSeconds: bigint;
+}
+
+export class DustUtxoState {
+  constructor();
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): DustUtxoState;
+  toString(compact?: boolean): string;
+}
+
+export class DustGenerationState {
+  constructor();
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): DustGenerationState;
+  toString(compact?: boolean): string;
+}
+
+export class DustGenerationTreeInsertionPath {
+  constructor(state: DustGenerationState, index: bigint);
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): DustGenerationTreeInsertionPath;
+  toString(compact?: boolean): string;
+}
+
+export class DustStateMerkleTreeCollapsedUpdate {
+  private constructor();
+  static newFromGenerationTree(state: DustGenerationState, start: bigint, end: bigint): DustStateMerkleTreeCollapsedUpdate;
+  static newFromCommitmentTree(state: DustUtxoState, start: bigint, end: bigint): DustStateMerkleTreeCollapsedUpdate;
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): DustStateMerkleTreeCollapsedUpdate;
+  toString(compact?: boolean): string;
+}
+
+export class DustState {
+  constructor();
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): DustState;
+  toString(compact?: boolean): string;
+  readonly utxo: DustUtxoState;
+  readonly generation: DustGenerationState;
+}
+
+export class DustStateChanges {
+  constructor(source: TransactionHash, receivedUtxos: QualifiedDustOutput[], spentUtxos: QualifiedDustOutput[]);
+  toString(compact?: boolean): string;
+  /**
+   * The source of the state change, as a hex-encoded string
+   */
+  readonly source: TransactionHash;
+  /**
+   * The UTXOs that were received in this state change
+   */
+  readonly receivedUtxos: QualifiedDustOutput[];
+  /**
+   * The UTXOs that were spent in this state change
+   */
+  readonly spentUtxos: QualifiedDustOutput[];
+}
+
+export class DustLocalStateWithChanges {
+  private constructor();
+  /**
+   * The updated local state after replaying events
+   */
+  readonly state: DustLocalState;
+  /**
+   * The state changes that occurred during the replay
+   */
+  readonly changes: DustStateChanges[];
+}
+
+export class DustLocalState {
+  constructor(params: DustParameters);
+  walletBalance(time: Date): bigint;
+  generationInfo(qdo: QualifiedDustOutput): DustGenerationInfo | undefined;
+  insertGenerationInfo(generationIndex: bigint, generation: DustGenerationInfo, initialNonce?: DustInitialNonce): DustLocalState;
+  removeGenerationInfo(generationIndex: bigint, generation: DustGenerationInfo): DustLocalState;
+  collapseGenerationTree(generationIndexStart: bigint, generationIndexEnd: bigint): DustLocalState;
+  applyGenerationCollapsedUpdate(update: DustStateMerkleTreeCollapsedUpdate): DustLocalState;
+  updateGenerationTreeFromEvidence(evidence: DustGenerationTreeInsertionPath): DustLocalState;
+  generatingTreeRoot(): bigint | undefined;
+  insertCommitment(commitmentIndex: bigint, qdo: QualifiedDustOutput, own_qdo: boolean): DustLocalState;
+  removeCommitment(commitmentIndex: bigint): DustLocalState;
+  collapseCommitmentTree(commitmentIndexStart: bigint, commitmentIndexEnd: bigint): DustLocalState;
+  applyCommitmentCollapsedUpdate(update: DustStateMerkleTreeCollapsedUpdate): DustLocalState;
+  commitmentTreeRoot(): bigint | undefined;
+  spend(sk: DustSecretKey, utxo: QualifiedDustOutput, vFee: bigint, ctime: Date): [DustLocalState, DustSpend<PreProof>];
+  processTtls(time: Date): DustLocalState;
+  replayEvents(sk: DustSecretKey, events: Event[]): DustLocalState;
+  replayEventsWithChanges(sk: DustSecretKey, events: Event[]): DustLocalStateWithChanges;
+  /**
+   * Replays a direct concatenation of serialized ledger events. Otherwise, acts as `replayEventsWithChanges`.
+   */
+  replayRawEvents(sk: DustSecretKey, rawEvents: Uint8Array): DustLocalStateWithChanges;
+  addUtxo(nullifier: DustNullifier, utxo: QualifiedDustOutput, pendingUntil?: Date): DustLocalState;
+  findUtxoByNullifier(nullifier: DustNullifier): QualifiedDustOutput | undefined;
+  removeUtxo(nullifier: DustNullifier): DustLocalState;
+  serialize(): Uint8Array;
+  static deserialize(raw: Uint8Array): DustLocalState;
+  toString(compact?: boolean): string;
+  readonly utxos: QualifiedDustOutput[];
+  readonly nullifiers: Map<DustNullifier, QualifiedDustOutput>;
+  readonly params: DustParameters;
+  syncTime: Date;
+  readonly generatingTreeFirstFree: bigint;
+  readonly commitmentTreeFirstFree: bigint;
+}
+
+/**
+ * Creates a payload for proving a specific transaction through the proof server
+ * @deprecated Use `Transaction.prove` instead.
+ */
+export function createProvingTransactionPayload(
+  transaction: UnprovenTransaction,
+  proving_data: Map<string, ProvingKeyMaterial>,
+): Uint8Array;
+
+/**
+ * Creates a payload for proving a specific proof through the proof server
+ */
+export function createProvingPayload(
+  serializedPreimage: Uint8Array,
+  overwriteBindingInput: bigint | undefined,
+  keyMaterial?: ProvingKeyMaterial,
+): Uint8Array;
+
+/**
+ * Creates a payload for checking a specific proof through the proof server
+ */
+export function createCheckPayload(
+  serializedPreimage: Uint8Array,
+  ir?: Uint8Array,
+): Uint8Array;
+
+/**
+ * Parses the result of a proof-server check call
+ */
+export function parseCheckResult(result: Uint8Array): (bigint | undefined)[]
+
+/**
+ * The state of the Midnight ledger
+ */
+export class LedgerState {
+  /**
+   * Intializes from a Zswap state, with an empty contract set
+   */
+  constructor(network_id: string, zswap: ZswapChainState);
+
+  /**
+   * A fully blank state
+   */
+  static blank(network_id: string): LedgerState;
+
+  /**
+   * Applies a {@link Transaction}
+   */
+  apply(
+    transaction: VerifiedTransaction,
+    context: TransactionContext
+  ): [LedgerState, TransactionResult];
+
+  /**
+   * Applies a system transaction to this ledger state.
+   */
+  applySystemTx(transaction: SystemTransaction, tblock: Date): [LedgerState, Event[]];
+
+  /**
+   * Indexes into the contract state map with a given contract address
+   */
+  index(address: ContractAddress): ContractState | undefined;
+
+  /**
+   * Sets the state of a given contract address from a {@link ChargedState}
+   */
+  updateIndex(address: ContractAddress, state: ChargedState, balance: Map<TokenType, bigint>): LedgerState;
+
+  serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): LedgerState;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * Carries out a post-block update, which does amortized bookkeeping that
+   * only needs to be done once per state change.
+   *
+   * Typically, `postBlockUpdate` should be run after any (sequence of)
+   * (system)-transaction application(s).
+   */
+  postBlockUpdate(tblock: Date, detailedBlockFullness?: NormalizedCost, overallBlockFullness?: number): LedgerState;
+
+  /**
+   * Retrieves the balance of the treasury for a specific token type.
+   */
+  treasuryBalance(token_type: TokenType): bigint;
+
+  /**
+  * How much in block rewards a recipient is owed and can claim.
+  */
+  unclaimedBlockRewards(recipient: UserAddress): bigint;
+
+  /**
+   * How much in bridged night a recipient is owed and can claim.
+   */
+  bridgeReceiving(recipient: UserAddress): bigint;
+
+  /**
+   * Allows distributing the specified amount of Night to the recipient's address.
+   * Use is for testing purposes only.
+   */
+  testingDistributeNight(recipient: UserAddress, amount: bigint, tblock: Date): LedgerState;
+
+  /**
+   * Constructs a ledger state with the given genesis parameterisation, using
+   * the default initial parameters. Allows seeding the locked, reserve, and
+   * treasury NIGHT pools so that subsequent system transactions (e.g.
+   * {@link testingUnlockToTreasury}) can be exercised
+   *
+   * Use is for testing purposes only.
+   */
+  static testingFromGenesis(network_id: string, lockedPool: bigint, reservePool: bigint, treasury: bigint): LedgerState;
+
+  /**
+   * Applies an `UnlockToTreasury` system transaction, moving the given amount
+   * of Night from the locked pool into the treasury.
+   *
+   * Use is for testing purposes only.
+   */
+  testingUnlockToTreasury(amount: bigint, tblock: Date): LedgerState;
+
+  /**
+   * Applies an `UnlockToReserve` system transaction, moving the given amount
+   * of Night from the locked pool into the reserve pool.
+   *
+   * Use is for testing purposes only.
+   */
+  testingUnlockToReserve(amount: bigint, tblock: Date): LedgerState;
+
+  /**
+   * The remaining size of the locked Night pool.
+   */
+  readonly lockedPool: bigint;
+
+  /**
+   * The size of the reserve Night pool
+   */
+  readonly reservePool: bigint;
+
+  /**
+   * How much in bridged night a recipient is owed and can claim.
+   */
+  bridgeReceiving(recipient: UserAddress): bigint;
+
+  /**
+   * The remaining unrewarded supply of native tokens.
+   */
+  readonly blockRewardPool: bigint;
+  /**
+   * The Zswap part of the ledger state
+   */
+  readonly zswap: ZswapChainState;
+  /**
+   * The unshielded utxos present
+   */
+  readonly utxo: UtxoState;
+  /**
+   * The dust subsystem state
+   */
+  readonly dust: DustState;
+  /**
+   * The parameters of the ledger
+   */
+  parameters: LedgerParameters;
+}
+
+/**
+ * An unspent transaction output
+ */
+export type Utxo = {
+  /**
+   * The amount of tokens this UTXO represents
+   */
+  value: bigint,
+  /**
+   * The address owning these tokens.
+   */
+  owner: UserAddress,
+  /**
+   * The token type of this UTXO
+   */
+  type: RawTokenType,
+  /**
+   * The hash of the intent outputting this UTXO
+   */
+  intentHash: IntentHash,
+  /**
+   * The output number of this UTXO in its parent {@link Intent}.
+   */
+  outputNo: number,
+};
+
+/**
+ * An output appearing in an {@link Intent}.
+ */
+export type UtxoOutput = {
+  /**
+   * The amount of tokens this UTXO represents
+   */
+  value: bigint,
+  /**
+   * The address owning these tokens.
+   */
+  owner: UserAddress,
+  /**
+   * The token type of this UTXO
+   */
+  type: RawTokenType,
+};
+
+/**
+ * Converts a bare signature public key to its corresponding address.
+ */
+export function addressFromKey(key: SignatureVerifyingKey): UserAddress;
+
+/**
+ * An input appearing in an {@link Intent}, or a user's local book-keeping.
+ */
+export type UtxoSpend = {
+  /**
+   * The amount of tokens this UTXO represents
+   */
+  value: bigint,
+  /**
+   * The signing key owning these tokens.
+   */
+  owner: SignatureVerifyingKey,
+  /**
+   * The token type of this UTXO
+   */
+  type: RawTokenType,
+  /**
+   * The hash of the intent outputting this UTXO
+   */
+  intentHash: IntentHash,
+  /**
+   * The output number of this UTXO in its parent {@link Intent}.
+   */
+  outputNo: number,
+};
+
+/**
+ * Metadata about a specific UTXO
+ */
+export class UtxoMeta {
+  constructor(ctime: Date);
+  /**
+   * The creation time of the UTXO, that is, when it was inserted into the state.
+   */
+  ctime: Date;
+}
+/**
+ * The sub-state for unshielded UTXOs
+ */
+export class UtxoState {
+  static new(utxos: Map<Utxo, UtxoMeta>): UtxoState;
+  /**
+   * Lookup the metadata for a specific UTXO.
+   */
+  lookupMeta(utxo: Utxo): UtxoMeta | undefined;
+
+  /**
+   * The set of valid UTXOs
+   */
+  readonly utxos: Set<Utxo>;
+
+  /**
+   * Filters out the UTXOs owned by a specific user address
+   */
+  filter(addr: UserAddress): Set<Utxo>;
+
+  /**
+   * Given a prior UTXO state, produce the set differences `this \ prior`, and
+   * `prior \ this`, optionally filtered by a further condition.
+   *
+   * Note that this should be more efficient than iterating or manifesting the
+   * {@link utxos} value, as the low-level implementation can avoid traversing
+   * shared sub-structures.
+   */
+  delta(prior: UtxoState, filterBy?: (utxo: Utxo) => boolean): [Set<Utxo>, Set<Utxo>];
+}
+
+/**
+ * A single contract call segment
+ */
+export class ContractCall<P extends Proofish> {
+  private constructor();
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The address being called
+   */
+  readonly address: ContractAddress;
+  /**
+   * The communication commitment of this call
+   */
+  readonly communicationCommitment: CommunicationCommitment;
+  /**
+   * The entry point being called
+   */
+  readonly entryPoint: Uint8Array | string;
+  /**
+   * The fallible execution stage transcript
+   */
+  readonly fallibleTranscript: Transcript<AlignedValue> | undefined;
+  /**
+   * The guaranteed execution stage transcript
+   */
+  readonly guaranteedTranscript: Transcript<AlignedValue> | undefined;
+  /**
+   * The proof attached to this call
+   */
+  readonly proof: P;
+}
+
+/**
+ * A {@link ContractCall} prior to being partitioned into guarnateed and
+ * fallible parts, for use with {@link Transaction.addCalls}.
+ *
+ * Note that this is similar, but not the same as {@link ContractCall}, which
+ * assumes {@link partitionTranscripts} was already used. {@link
+ * Transaction.addCalls} is a replacement for this that also handles
+ * Zswap components, and creates relevant intents when needed.
+ */
+export class PrePartitionContractCall {
+  constructor(
+    address: ContractAddress,
+    entry_point: Uint8Array | string,
+    op: ContractOperation,
+    pre_transcript: PreTranscript,
+    private_transcript_outputs: AlignedValue[],
+    input: AlignedValue,
+    output: AlignedValue,
+    communication_commitment_rand: CommunicationCommitmentRand,
+    key_location: string,
+    inner_proofs?: Uint8Array[]
+  );
+  toString(compact?: boolean): string;
+}
+
+/**
+ * A {@link ContractCall} still being assembled
+ */
+export class ContractCallPrototype {
+  /**
+   * @param address - The address being called
+   * @param entry_point - The entry point being called
+   * @param op - The operation expected at this entry point
+   * @param guaranteed_public_transcript - The guaranteed transcript computed
+   * for this call
+   * @param fallible_public_transcript - The fallible transcript computed for
+   * this call
+   * @param private_transcript_outputs - The private transcript recorded for
+   * this call
+   * @param input - The input(s) provided to this call
+   * @param output - The output(s) computed from this call
+   * @param communication_commitment_rand - The communication randomness used
+   * for this call
+   * @param key_location - An identifier for how the key for this call may be
+   * looked up
+   * @param inner_proofs - The proofs this call's circuit verifies in-circuit,
+   * one per `inner_proof` instruction in instruction order, each the raw proof
+   * bytes. An instruction whose guard is false still takes an entry, which may
+   * be empty.
+   */
+  constructor(
+    address: ContractAddress,
+    entry_point: Uint8Array | string,
+    op: ContractOperation,
+    guaranteed_public_transcript: Transcript<AlignedValue> | undefined,
+    fallible_public_transcript: Transcript<AlignedValue> | undefined,
+    private_transcript_outputs: AlignedValue[],
+    input: AlignedValue,
+    output: AlignedValue,
+    communication_commitment_rand: CommunicationCommitmentRand,
+    key_location: string,
+    inner_proofs?: Uint8Array[]
+  );
+
+  toString(compact?: boolean): string;
+
+  intoCall(parentBinding: PreBinding): ContractCall<PreProof>;
+}
+
+/**
+ * An intent is a potentially unbalanced partial transaction, that may be
+ * combined with other intents to form a whole.
+ */
+export class Intent<S extends Signaturish, P extends Proofish, B extends Bindingish> {
+  private constructor();
+
+  static new(ttl: Date): UnprovenIntent;
+
+  serialize(): Uint8Array;
+
+  static deserialize<S extends Signaturish, P extends Proofish, B extends Bindingish>(
+    markerS: S['instance'],
+    markerP: P['instance'],
+    markerB: B['instance'],
+    raw: Uint8Array,
+
+  ): Intent<S, P, B>;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * Returns the hash of this intent, for it's given segment ID.
+   */
+  intentHash(segmentId: number): IntentHash;
+
+  /**
+   * Adds a contract call to this intent.
+   */
+  addCall(call: ContractCallPrototype): Intent<S, PreProof, PreBinding>;
+
+  /**
+   * Adds a contract deploy to this intent.
+   */
+  addDeploy(deploy: ContractDeploy): Intent<S, PreProof, PreBinding>;
+
+  /**
+   * Adds a maintenance update to this intent.
+   */
+  addMaintenanceUpdate(update: MaintenanceUpdate): Intent<S, PreProof, PreBinding>;
+
+  /**
+   * Enforces binding for this intent. This is irreversible.
+   * @throws If `segmentId` is not a valid segment ID.
+   */
+  bind(segmentId: number): Intent<S, P, Binding>;
+
+  /**
+   * Removes proofs from this intent.
+   */
+  eraseProofs(): Intent<S, NoProof, NoBinding>;
+
+  /**
+   * Removes signatures from this intent.
+   */
+  eraseSignatures(): Intent<SignatureErased, P, B>;
+
+  /**
+   * The raw data that is signed for unshielded inputs in this intent.
+   */
+  signatureData(segmentId: number): Uint8Array;
+
+  /**
+   * The UTXO inputs and outputs in the guaranteed section of this intent.
+   * @throws Writing throws if `B` is {@link Binding}, unless the only change
+   * is in the signature set.
+   */
+  guaranteedUnshieldedOffer: UnshieldedOffer<S> | undefined;
+  /**
+   * The UTXO inputs and outputs in the fallible section of this intent.
+   * @throws Writing throws if `B` is {@link Binding}, unless the only change
+   * is in the signature set.
+   */
+  fallibleUnshieldedOffer: UnshieldedOffer<S> | undefined;
+  /**
+   * The action sequence of this intent.
+   * @throws Writing throws if `B` is {@link Binding}.
+   */
+  actions: ContractAction<P>[];
+  /**
+   * The DUST interactions made by this intent
+   * @throws Writing throws if `B` is {@link Binding}.
+   */
+  dustActions: DustActions<S, P> | undefined;
+  /**
+   * The time this intent expires.
+   * @throws Writing throws if `B` is {@link Binding}.
+   */
+  ttl: Date;
+  readonly binding: B;
+}
+
+/**
+ * An unshielded offer consists of inputs, outputs, and signatures that
+ * authorize the inputs. The data the signatures sign is provided by {@link
+ * Intent.signatureData}.
+ */
+export class UnshieldedOffer<S extends Signaturish> {
+  private constructor();
+
+  static new(inputs: UtxoSpend[], outputs: UtxoOutput[], signatures: SignatureEnabled[]): UnshieldedOffer<SignatureEnabled>;
+
+  addSignatures(signatures: S[]): UnshieldedOffer<S>;
+
+  eraseSignatures(): UnshieldedOffer<SignatureErased>;
+
+  toString(compact?: boolean): string;
+
+  readonly inputs: UtxoSpend[];
+  readonly outputs: UtxoOutput[];
+  readonly signatures: S[];
+}
+
+/**
+ * The context against which a transaction is run.
+ */
+export class TransactionContext {
+  /**
+   * @param ref_state - A past ledger state that is used as a reference point
+   * for 'static' data.
+   * @param block_context - Information about the block this transaction is, or
+   * will be, contained in.
+   * @param whitelist - A list of contracts that are being tracked, or
+   * `undefined` to track all contracts.
+   */
+  constructor(ref_state: LedgerState, block_context: BlockContext, whitelist?: Set<ContractAddress>);
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * The result status of applying a transaction.
+ * Includes an error message if the transaction failed, or partially failed.
+ */
+export class TransactionResult {
+  private constructor();
+
+  readonly type: 'success' | 'partialSuccess' | 'failure';
+  readonly successfulSegments?: Map<number, boolean>;
+  readonly error?: string;
+  readonly events: Event[];
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * The result status of applying a transaction, without error message
+ */
+export type ErasedTransactionResult = {
+  type: 'success' | 'partialSuccess' | 'failure',
+  successfulSegments?: Map<number, boolean>,
+};
+
+/**
+ * A single update instruction in a {@link MaintenanceUpdate}.
+ */
+export type SingleUpdate = ReplaceAuthority | VerifierKeyRemove | VerifierKeyInsert | IrRemove | IrInsert;
+
+/**
+ * The version associated with a {@link ContractOperation}
+ */
+export class ContractOperationVersion {
+  constructor(version: 'v3' | 'v4');
+
+  readonly version: 'v3' | 'v4';
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * A versioned verifier key to be associated with a {@link ContractOperation}.
+ */
+export class ContractOperationVersionedVerifierKey {
+  constructor(version: 'v3' | 'v4', rawVk: Uint8Array);
+
+  readonly version: 'v3' | 'v4';
+  readonly rawVk: Uint8Array;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * An update instruction to replace the current contract maintenance authority
+ * with a new one.
+ */
+export class ReplaceAuthority {
+  constructor(authority: ContractMaintenanceAuthority);
+
+  readonly authority: ContractMaintenanceAuthority;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * An update instruction to remove a verifier key of a specific operation and
+ * version.
+ */
+export class VerifierKeyRemove {
+  constructor(operation: string | Uint8Array, version: ContractOperationVersion);
+
+  readonly operation: string | Uint8Array;
+  readonly version: ContractOperationVersion;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * An update instruction to insert a verifier key at a specific operation and
+ * version.
+ */
+export class VerifierKeyInsert {
+  constructor(operation: string | Uint8Array, vk: ContractOperationVersionedVerifierKey);
+
+  readonly operation: string | Uint8Array;
+  readonly vk: ContractOperationVersionedVerifierKey;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * An update instruction to remove IR metadata of a specific operation.
+ */
+export class IrRemove {
+  constructor(operation: string | Uint8Array);
+
+  readonly operation: string | Uint8Array;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * An update instruction to insert IR metadata at a specific operation.
+ */
+export class IrInsert {
+  constructor(operation: string | Uint8Array, ir: Uint8Array);
+
+  readonly operation: string | Uint8Array;
+  readonly ir: Uint8Array;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * A contract maintenance update, updating associated operations, or
+ * changing the maintenance authority.
+ */
+export class MaintenanceUpdate {
+  constructor(address: ContractAddress, updates: SingleUpdate[], counter: bigint);
+
+  /**
+   * Adds a new signature to this update
+   */
+  addSignature(idx: bigint, signature: Signature): MaintenanceUpdate;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The raw data any valid signature must be over to approve this update.
+   */
+  readonly dataToSign: Uint8Array;
+  /**
+   * The address this deployment will attempt to create
+   */
+  readonly address: ContractAddress;
+  /**
+   * The updates to carry out
+   */
+  readonly updates: SingleUpdate[];
+  /**
+   * The counter this update is valid against
+   */
+  readonly counter: bigint;
+  /**
+   * The signatures on this update
+   */
+  readonly signatures: [bigint, Signature][];
+}
+
+/**
+ * A contract deployment segment, instructing the creation of a new contract
+ * address, if not already present
+ */
+export class ContractDeploy {
+  /**
+   * Creates a deployment for an arbitrary contract state
+   *
+   * The deployment and its address are randomised.
+   */
+  constructor(initial_state: ContractState);
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The address this deployment will attempt to create
+   */
+  readonly address: ContractAddress;
+  readonly initialState: ContractState;
+}
+
+export type ProvingProvider = {
+  check(
+    serializedPreimage: Uint8Array,
+    keyLocation: string,
+  ): Promise<(bigint | undefined)[]>;
+  prove(
+    serializedPreimage: Uint8Array,
+    keyLocation: string,
+    overwriteBindingInput?: bigint,
+  ): Promise<Uint8Array>;
+  lookupKey(keyLocation: string): Promise<ProvingKeyMaterial | undefined>;
+};
+
+/**
+ * Specifies where something should execute in a transaction.
+ *
+ * Options are:
+ * - As the first thing (alias for `{ tag: 'specific', value: 1 }`)
+ * - In any physical segment, but only utilising the guaranteed logical segment
+ * - In a random segment (ideal for merging with other intents)
+ * - In a specific directly provided segment (in the range 1..65535)
+ */
+export type SegmentSpecifier = { tag: 'first' } | { tag: 'guaranteedOnly' } | { tag: 'random' } | { tag: 'specific', value: number };
+
+/**
+ * A transaction that has been validated with `wellFormed`.
+ **/
+export class VerifiedTransaction {
+  private constructor();
+
+  /**
+   * The actual underlying transaction
+   **/
+  readonly transaction: Transaction<SignatureErased, NoProof, NoBinding>;
+}
+
+/**
+ * A Midnight transaction, consisting a section of {@link
+ * ContractAction}s, and a guaranteed and fallible {@link ZswapOffer}.
+ *
+ * The guaranteed section are run first, and fee payment is taken during this
+ * part. If it succeeds, the fallible section is also run, and atomically
+ * rolled back if it fails.
+ */
+export class Transaction<S extends Signaturish, P extends Proofish, B extends Bindingish> {
+  private constructor();
+
+  /**
+   * Creates a transaction from its parts.
+   */
+  static fromParts(network_id: string, guaranteed?: UnprovenOffer, fallible?: UnprovenOffer, intent?: UnprovenIntent): UnprovenTransaction;
+
+  /**
+   * Creates a transaction from its parts, randomizing the segment ID to better
+   * allow merging.
+   */
+  static fromPartsRandomized(network_id: string, guaranteed?: UnprovenOffer, fallible?: UnprovenOffer, intent?: UnprovenIntent): UnprovenTransaction;
+
+  /**
+   * Creates a rewards claim transaction, the funds claimed must have been
+   * legitimately rewarded previously.
+   */
+  static fromRewards<S extends Signaturish>(rewards: ClaimRewardsTransaction<S>): Transaction<S, PreProof, Binding>;
+
+  /**
+   * Mocks proving, producing a 'proven' transaction that, while it will
+   * *not* verify, is accurate for fee computation purposes.
+   *
+   * Due to the variability in proof sizes, this *only* works for transactions
+   * that do not contain unproven contract calls.
+   *
+   * @throws If called on bound, proven, or proof-erased transactions, or if the
+   * transaction contains unproven contract calls.
+   */
+  mockProve(): Transaction<S, Proof, Binding>;
+  /**
+   * Proves the transaction, with access to a low-level proving provider.
+   * This may *only* be called for `P = PreProof`.
+   *
+   * @throws If called on bound, proven, or proof-erased transactions.
+   */
+  prove(provider: ProvingProvider, cost_model: CostModel): Promise<Transaction<S, Proof, B>>;
+
+  /**
+   * Adds a set of new calls to the transaction.
+   *
+   * In contrast to {@link Intent.addCall}, this takes calls *before*
+   * transcript partitioning ({@link partitionTranscripts}), will create the
+   * target intent where needed, and will ensure that relevant Zswap parts are
+   * placed in the same section as contract interactions with them.
+   *
+   * @throws If called on bound, proven, or proof-erased transactions.
+   */
+  addCalls(
+    segment: SegmentSpecifier,
+    calls: PrePartitionContractCall[],
+    params: LedgerParameters,
+    ttl: Date,
+    zswapInputs?: ZswapInput<PreProof>[],
+    zswapOutputs?: ZswapOutput<PreProof>[],
+    zswapTransient?: ZswapTransient<PreProof>[],
+  ): Transaction<S, P, B>;
+
+  /**
+   * Adds Zswap offer to the segment specified.
+   *
+   * @throws If called on bound transactions.
+   */
+  addZswapOffer(
+    segment: SegmentSpecifier,
+    offer: UnprovenOffer | undefined,
+  ): Transaction<S, P, B>;
+
+  /**
+   * Adds provided intent to the segment specified.
+   *
+   * @throws If called on bound transactions.
+   */
+  addIntent(
+    segment: SegmentSpecifier,
+    intent: Intent<S, P, B> | undefined,
+  ): Transaction<S, P, B>;
+
+  /**
+   * Erases the proofs contained in this transaction
+   */
+  eraseProofs(): Transaction<S, NoProof, NoBinding>;
+
+  /**
+   * Removes signatures from this transaction.
+   */
+  eraseSignatures(): Transaction<SignatureErased, P, B>;
+
+  /**
+   * Enforces binding for this transaction. This is irreversible.
+   */
+  bind(): Transaction<S, P, Binding>;
+
+  /**
+   * Tests well-formedness criteria, optionally including transaction balancing
+   *
+   * @throws If the transaction is not well-formed for any reason
+   */
+  wellFormed(ref_state: LedgerState, strictness: WellFormedStrictness, tblock: Date): VerifiedTransaction;
+
+  /**
+   * Returns the hash associated with this transaction. Due to the ability to
+   * merge transactions, this should not be used to watch for a specific
+   * transaction.
+   */
+  transactionHash(): TransactionHash;
+
+  /**
+   * Returns the set of identifiers contained within this transaction. Any of
+   * these *may* be used to watch for a specific transaction.
+   */
+  identifiers(): TransactionId[];
+
+  /**
+   * Merges this transaction with another
+   *
+   * @throws If both transactions have contract interactions, or they spend the
+   * same coins
+   */
+  merge(other: Transaction<S, P, B>): Transaction<S, P, B>;
+
+  serialize(): Uint8Array;
+
+  static deserialize<S extends Signaturish, P extends Proofish, B extends Bindingish>(
+    markerS: S['instance'],
+    markerP: P['instance'],
+    markerB: B['instance'],
+    raw: Uint8Array,
+
+  ): Transaction<S, P, B>;
+
+  /**
+   * For given fees, and a given section (guaranteed/fallible), what the
+   * surplus or deficit of this transaction in any token type is.
+   *
+   * @throws If `segment` is not a valid segment ID
+   */
+  imbalances(segment: number, fees?: bigint): Map<TokenType, bigint>;
+
+  /**
+   * The underlying resource cost of this transaction.
+   */
+  cost(params: LedgerParameters, enforceTimeToDismiss?: boolean): SyntheticCost;
+
+  /**
+   * The cost of this transaction, in SPECKs.
+   *
+   * Note that this is *only* accurate when called with proven transactions.
+   */
+  fees(params: LedgerParameters, enforceTimeToDismiss?: boolean): bigint;
+
+  /**
+   * The cost of this transaction, in SPECKs, with a safety margin of `n` blocks applied.
+   *
+   * As with {@link fees}, this is only accurate for proven transactions.
+   *
+   * Warning: `n` must be a non-negative integer, and it is an exponent, it is
+   * very easy to get a completely unreasonable margin here!
+   */
+  feesWithMargin(params: LedgerParameters, margin: number): bigint;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The rewards this transaction represents, if applicable
+   */
+  readonly rewards: ClaimRewardsTransaction<S> | undefined;
+  /**
+   * The intents contained in this transaction
+   *
+   * Note that writing to this re-computes binding information if and only if
+   * this transaction is unbound *and* unproven. If this is not the case,
+   * creating or removing intents will lead to a binding error down the line,
+   * but modifying existing intents will succeed.
+   *
+   * @throws On writing if `B` is {@link Binding} or this is not a standard
+   * transaction
+   */
+  intents: Map<number, Intent<S, P, B>> | undefined;
+  /**
+   * The fallible Zswap offer
+   *
+   * Note that writing to this re-computes binding information if and only if
+   * this transaction is unbound *and* unproven. If this is not the case,
+   * creating or removing offer components will lead to a binding error down
+   * the line.
+   *
+   * @throws On writing if `B` is {@link Binding} or this is not a standard
+   * transaction
+   */
+  fallibleOffer: Map<number, ZswapOffer<P>> | undefined;
+  /**
+   * The guaranteed Zswap offer
+   *
+   * Note that writing to this re-computes binding information if and only if
+   * this transaction is unbound *and* unproven. If this is not the case,
+   * creating or removing offer components will lead to a binding error down
+   * the line.
+   *
+   * @throws On writing if `B` is {@link Binding} or this is not a standard
+   * transaction
+   */
+  guaranteedOffer: ZswapOffer<P> | undefined;
+  /**
+   * The binding randomness associated with this transaction
+   */
+  readonly bindingRandomness: bigint;
+}
+
+/**
+ * A transcript prior to partitioning, consisting of the context to run it in, the program that
+ * will make up the transcript, and optionally a communication commitment to bind calls together.
+ */
+export class PreTranscript {
+  constructor(context: QueryContext, program: Op<AlignedValue>[], comm_comm?: CommunicationCommitment);
+
+  toString(compact?: boolean): string;
+}
+
+export type PartitionedTranscript = [Transcript<AlignedValue> | undefined, Transcript<AlignedValue> | undefined];
+
+/**
+ * Computes the communication commitment corresponding to an input/output pair and randomness.
+ */
+export function communicationCommitment(input: AlignedValue, output: AlignedValue, rand: CommunicationCommitmentRand): CommunicationCommitment;
+
+/**
+ * Finalizes a set of programs against their initial contexts,
+ * resulting in guaranteed and fallible {@link Transcript}s, optimally
+ * allocated, and heuristically covered for gas fees.
+ */
+export function partitionTranscripts(calls: PreTranscript[], params: LedgerParameters): PartitionedTranscript[];
+
+/**
+ * The hash of a transaction, as a hex-encoded 256-bit bytestring
+ */
+export type TransactionHash = string;
+/**
+ * The hash of an intent, as a hex-encoded 256-bit bytestring
+ */
+export type IntentHash = string;
+/**
+ * A transaction identifier, used to index merged transactions
+ */
+export type TransactionId = string;
+/**
+ * An encryption public key, used to inform users of new coins sent to them
+ */
+export type EncPublicKey = string;
+
+/**
+ * Samples a dummy user coin public key, for use in testing
+ */
+export function sampleCoinPublicKey(): CoinPublicKey;
+
+/**
+ * Samples a dummy user encryption public key, for use in testing
+ */
+export function sampleEncryptionPublicKey(): EncPublicKey;
+
+/**
+ * Samples a dummy user intent hash, for use in testing
+ */
+export function sampleIntentHash(): IntentHash;
+
+/**
+ * Creates a new {@link ShieldedCoinInfo}, sampling a uniform nonce
+ */
+export function createShieldedCoinInfo(type_: RawTokenType, value: bigint): ShieldedCoinInfo;
+
+/**
+ * The base/system token type
+ */
+export function nativeToken(): UnshieldedTokenType;
+
+/**
+ * The system token type for fees
+ */
+export function feeToken(): DustTokenType;
+
+/**
+ * Default shielded token type for testing
+ */
+export function shieldedToken(): ShieldedTokenType;
+
+/**
+ * Default unshielded token type for testing
+ */
+export function unshieldedToken(): UnshieldedTokenType;
+
+/**
+ * Calculate commitment of a coin owned by a user
+ */
+export function coinCommitment(coin: ShieldedCoinInfo, coinPublicKey: CoinPublicKey): CoinCommitment;
+
+/**
+ * Calculate nullifier of a coin owned by a user
+ */
+export function coinNullifier(coin: ShieldedCoinInfo, coinSecretKey: CoinSecretKey): Nullifier;
+
+/**
+ * Calculate commitment of Dust utxo owned by a user
+ */
+export function dustCommitment(qdo: QualifiedDustOutput): DustCommitment;
+
+/**
+ * Calculate nullifier of Dust utxo owned by a user
+ */
+export function dustNullifier(qdo: QualifiedDustOutput, sk: DustSecretKey): DustNullifier;
+
+/**
+ * Calculate Dust nonce
+ */
+export function dustNonce(initialNonce: DustInitialNonce, seq: bigint, sk: DustSecretKey): DustNonce;
+
+/**
+ * Calculate Dust first nonce (when seq=0)
+ */
+export function dustFirstNonce(backingNight: DustInitialNonce, dustAddress: DustPublicKey): DustNonce;
+
+/**
+ * Calculate Dust initial nonce (a backing night hash)
+ */
+export function dustInitialNonce(outputNo: bigint, intentHash: IntentHash): DustInitialNonce;
+
+/**
+ * Returns a new Dust UTXO with a reduced value and the sequential nonce
+ */
+export function successorDustUtxo(qdo: QualifiedDustOutput, now: Date, subtractFee: bigint, newCommitmentIndex: bigint, genInfo: DustGenerationInfo, sk: DustSecretKey, dustParams: DustParameters): QualifiedDustOutput;
+
+/**
+ * Parameters used by the Midnight ledger, including transaction fees and
+ * bounds
+ */
+export class LedgerParameters {
+  private constructor();
+
+  /**
+   * The initial parameters of Midnight
+   */
+  static initialParameters(): LedgerParameters;
+
+  /**
+   * The cost model used for transaction fees contained in these parameters
+   */
+  readonly transactionCostModel: TransactionCostModel;
+  /**
+   * The parameters associated with DUST.
+   */
+  readonly dust: DustParameters;
+
+  /**
+   * The maximum price adjustment per block with the current parameters, as a multiplicative
+   * factor (that is: 1.1 would indicate a 10% adjustment). Will always return the positive (>1)
+   * adjustment factor. Note that negative adjustments are the additive inverse (1.1 has a
+   * corresponding 0.9 downward adjustment), *not* the multiplicative as might reasonably be
+   * assumed.
+   */
+  maxPriceAdjustment(): number;
+
+  serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): LedgerParameters;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * Normalizes a detailed block fullness cost to the block limits.
+   *
+   * @throws if any of the block limits is exceeded
+   */
+  normalizeFullness(fullness: SyntheticCost): NormalizedCost;
+
+  /**
+   * The fee prices for transaction
+   */
+  readonly feePrices: FeePrices;
+}
+
+export class TransactionCostModel {
+  private constructor();
+
+  /**
+   * The initial cost model of Midnight
+   */
+  static initialTransactionCostModel(): TransactionCostModel;
+
+  /**
+   * The increase in fees to expect from adding a new input to a transaction
+   */
+  readonly inputFeeOverhead: bigint;
+  /**
+   * The increase in fees to expect from adding a new output to a transaction
+   */
+  readonly outputFeeOverhead: bigint;
+
+  serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): TransactionCostModel;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * A cost model for calculating transaction fees
+   */
+  readonly runtimeCostModel: CostModel;
+
+  /**
+   * A baseline cost to begin with
+   */
+  readonly baselineCost: RunningCost;
+}
+
+
+/**
+ * A compact delta on the coin commitments Merkle tree, used to keep local
+ * spending trees in sync with the global state without requiring receiving all
+ * transactions.
+ */
+export class MerkleTreeCollapsedUpdate {
+  /**
+   * Create a new compact update from a non-compact state, and inclusive
+   * `start` and `end` indices
+   *
+   * @throws If the indices are out-of-bounds for the state, or `end < start`
+   */
+  constructor(state: ZswapChainState, start: bigint, end: bigint);
+
+  serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): MerkleTreeCollapsedUpdate;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * Holds the encryption secret key of a user, which may be used to determine if
+ * a given offer contains outputs addressed to this user
+ */
+export class EncryptionSecretKey {
+  private constructor();
+
+  /**
+   * Clears the encryption secret key, so that it is no longer usable nor held in memory
+   */
+  clear(): void;
+
+  test<P extends Proofish>(offer: ZswapOffer<P>): boolean;
+
+  yesIKnowTheSecurityImplicationsOfThis_serialize(): Uint8Array;
+  yesIKnowTheSecurityImplicationsOfThis_taggedSerialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): EncryptionSecretKey
+  static taggedDeserialize(raw: Uint8Array): EncryptionSecretKey
+}
+
+export class ZswapSecretKeys {
+  private constructor();
+
+  /**
+   * Derives secret keys from a 32-byte seed
+   */
+  static fromSeed(seed: Uint8Array): ZswapSecretKeys;
+
+  /**
+   * Derives secret keys from a 32-byte seed using deprecated implementation.
+   * Use only for compatibility purposes
+   */
+  static fromSeedRng(seed: Uint8Array): ZswapSecretKeys;
+
+
+  /**
+   * Clears the secret keys, so that they are no longer usable nor held in memory
+   * Note: it does not clear copies of the keys - which is particularly relevant for proof preimages
+   * Note: this will cause all other operations to fail
+   */
+  clear(): void;
+
+  readonly coinPublicKey: CoinPublicKey;
+  readonly coinSecretKey: CoinSecretKey;
+  readonly encryptionPublicKey: EncPublicKey;
+  readonly encryptionSecretKey: EncryptionSecretKey;
+}
+
+/**
+ * The on-chain state of Zswap, consisting of a Merkle tree of coin
+ * commitments, a set of nullifiers, an index into the Merkle tree, and a set
+ * of valid past Merkle tree roots
+ */
+export class ZswapChainState {
+  constructor();
+
+  serialize(): Uint8Array;
+
+  /**
+   * The first free index in the coin commitment tree
+   */
+  readonly firstFree: bigint;
+
+  static deserialize(raw: Uint8Array): ZswapChainState;
+
+  /**
+   * Given a whole ledger serialized state, deserialize only the Zswap portion
+   */
+  static deserializeFromLedgerState(raw: Uint8Array): ZswapChainState;
+
+  /**
+   * Carries out a post-block update, which does amortized bookkeeping that
+   * only needs to be done once per state change.
+   *
+   * Typically, `postBlockUpdate` should be run after any (sequence of)
+   * (system)-transaction application(s).
+   *
+   * @param tblock - timestamp of a block last batch of updates was applied at
+   * @param retentionDuration - number of seconds to retain past Merkle tree roots
+   */
+  postBlockUpdate(tblock: Date, retentionDuration: bigint): ZswapChainState;
+
+  /**
+   * Try to apply an {@link ZswapOffer} to the state, returning the updated state
+   * and a map on newly inserted coin commitments to their inserted indices.
+   *
+   * @param whitelist - A set of contract addresses that are of interest. If
+   * set, *only* these addresses are tracked, and all other information is
+   * discarded.
+   */
+  tryApply<P extends Proofish>(offer: ZswapOffer<P>, whitelist?: Set<ContractAddress>): [ZswapChainState, Map<CoinCommitment, bigint>];
+
+  toString(compact?: boolean): string;
+
+  /**
+   * Filters the state to only include coins that are relevant to a given
+   * contract address.
+   *
+   * @param contractAddress
+   */
+  filter(contractAddress: ContractAddress): ZswapChainState;
+}
+
+export class ZswapStateChanges {
+  constructor(source: TransactionHash, receivedCoins: QualifiedShieldedCoinInfo[], spentCoins: QualifiedShieldedCoinInfo[]);
+  toString(compact?: boolean): string;
+  /**
+   * The source of the state change, as a hex-encoded string
+   */
+  readonly source: TransactionHash;
+  /**
+   * The coins that were received in this state change
+   */
+  readonly receivedCoins: QualifiedShieldedCoinInfo[];
+  /**
+   * The coins that were spent in this state change
+   */
+  readonly spentCoins: QualifiedShieldedCoinInfo[];
+}
+
+export class ZswapLocalStateWithChanges {
+  private constructor();
+  /**
+   * The updated local state after replaying events
+   */
+  readonly state: ZswapLocalState;
+  /**
+   * The state changes that occurred during the replay
+   */
+  readonly changes: ZswapStateChanges[];
+}
+
+/**
+ * The local state of a user/wallet, consisting of a set
+ * of unspent coins
+ *
+ * It also keeps track of coins that are in-flight, either expecting to spend
+ * or expecting to receive, and a local copy of the global coin commitment
+ * Merkle tree to generate proofs against.
+ *
+ * It does not store keys internally, but accepts them as arguments to various operations.
+ */
+export class ZswapLocalState {
+  /**
+   * Creates a new, empty state
+   */
+  constructor();
+
+  /**
+   * Applies a collapsed Merkle tree update to the current local state, fast
+   * forwarding through the indices included in it, if it is a correct update.
+   *
+   * The general flow for usage if Alice is in state A, and wants to ask Bob how to reach the new state B, is:
+   *  - Find where she left off – what's her firstFree?
+   *  - Find out where she's going – ask for Bob's firstFree.
+   *  - Find what contents she does care about – ask Bob for the filtered
+   *    entries she want to include proper in her tree.
+   *  - In order, of Merkle tree indices:
+   *    - Insert (with `apply` offers Alice cares about).
+   *    - Skip (with this method) sections Alice does not care about, obtaining
+   *      the collapsed update covering the gap from Bob.
+   * Note that `firstFree` is not included in the tree itself, and both ends of
+   * updates *are* included.
+   */
+  applyCollapsedUpdate(update: MerkleTreeCollapsedUpdate): ZswapLocalState;
+
+  /**
+   * Directly inserts a coin owned by this wallet into the state at `this.first_free`.
+   *
+   * This function requires secret keys as coins are indexed by nullifier, and
+   * secret keys are required to compute this.
+   */
+  insertCoin(secretKeys: ZswapSecretKeys, coin: ShieldedCoinInfo): ZswapLocalState;
+
+  /**
+   * Removes a given coin from the tracked coins by its nullifier.
+   */
+  removeCoinByNullifier(nullifier: Nullifier): ZswapLocalState;
+
+  /**
+   * Replays observed events against the current local state. These *must* be replayed
+   * in the same order as emitted by the chain being followed.
+   */
+  replayEvents(secretKeys: ZswapSecretKeys, events: Event[]): ZswapLocalState;
+  /**
+   * Replays observed events against the current local state, returning both the updated state
+   * and the state changes. These *must* be replayed in the same order as emitted by the chain being followed.
+   */
+  replayEventsWithChanges(secretKeys: ZswapSecretKeys, events: Event[]): ZswapLocalStateWithChanges;
+  /**
+   * Replays a direct concatenation of serialized ledger events. Otherwise acts as `replayEventsWithChanges`.
+   */
+  replayRawEvents(sk: ZswapSecretKeys, rawEvents: Uint8Array): ZswapLocalStateWithChanges;
+  /**
+   * Locally applies an offer to the current state, returning the updated state
+   */
+  apply<P extends Proofish>(secretKeys: ZswapSecretKeys, offer: ZswapOffer<P>): ZswapLocalState;
+  /**
+   * Locally applies an offer to the current state, returning both the updated state and the state changes.
+   */
+  applyWithChanges<P extends Proofish>(secretKeys: ZswapSecretKeys, offer: ZswapOffer<P>): ZswapLocalStateWithChanges;
+  /**
+   * Locally reverts pending outputs/spends from an offer known to have failed
+   * or which has been discarded.
+   */
+  applyFailed<P extends Proofish>(offer: ZswapOffer<P>): ZswapLocalState;
+  /**
+   * Locally reverts all pending outputs/spends from a transaction which has been discarded.
+   *
+   * Behaves as {@link applyFailed} for the entire transaction.
+   */
+  revertTransaction<S extends Signaturish, P extends Proofish, B extends Bindingish>(transaction: Transaction<S, P, B>): ZswapLocalState;
+  /**
+   * Clears pending outputs / spends that have passed their TTL without being included in
+   * a block.
+   *
+   * Note that as TTLs are *from a block perspective*, and there is some
+   * latency between the block and the wallet, the time passed in here should
+   * not be the current time, but incorporate a latency buffer.
+   *
+   * NOTE: This API endpoint is currently non-functional and works as a no-op.
+   */
+  clearPending(time: Date): ZswapLocalState;
+
+  /**
+   * Initiates a new spend of a specific coin, outputting the corresponding
+   * {@link ZswapInput}, and the updated state marking this coin as
+   * in-flight.
+   */
+  spend(secretKeys: ZswapSecretKeys, coin: QualifiedShieldedCoinInfo, segment: number | undefined, ttl?: Date): [ZswapLocalState, UnprovenInput];
+
+  /**
+   * Initiates a new spend of a new-yet-received output, outputting the
+   * corresponding {@link ZswapTransient}, and the updated state marking
+   * this coin as in-flight.
+   */
+  spendFromOutput(secretKeys: ZswapSecretKeys, coin: QualifiedShieldedCoinInfo, segment: number | undefined, output: UnprovenOutput, ttl?: Date): [ZswapLocalState, UnprovenTransient];
+
+  /**
+   * Adds a coin to the list of coins that are expected to be received
+   *
+   * This should be used if an output is creating a coin for this wallet, which
+   * does not contain a ciphertext to detect it. In this case, the wallet must
+   * know the commitment ahead of time to notice the receipt.
+   */
+  watchFor(coinPublicKey: CoinPublicKey, coin: ShieldedCoinInfo): ZswapLocalState;
+
+  serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): ZswapLocalState;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The set of *spendable* coins of this wallet
+   */
+  readonly coins: Set<QualifiedShieldedCoinInfo>;
+  /**
+   * The first free index in the internal coin commitments Merkle tree.
+   * This may be used to identify which merkle tree updates are necessary.
+   */
+  readonly firstFree: bigint;
+  /**
+   * The outputs that this wallet is expecting to receive in the future, with
+   * an optional TTL attached.
+   */
+  readonly pendingOutputs: Map<CoinCommitment, [ShieldedCoinInfo, Date | undefined]>;
+  /**
+   * The spends that this wallet is expecting to be finalized on-chain in the
+   * future. Each has an optional TTL attached.
+   */
+  readonly pendingSpends: Map<Nullifier, [QualifiedShieldedCoinInfo, Date | undefined]>;
+  /**
+   * The root of the commitment Merkle tree.
+   */
+  readonly merkleTreeRoot: bigint | undefined;
+}
+
+/**
+ * A shielded transaction input
+ */
+export class ZswapInput<P extends Proofish> {
+  private constructor();
+
+  static newContractOwned(coin: QualifiedShieldedCoinInfo, segment: number | undefined, contract: ContractAddress, state: ZswapChainState): UnprovenInput;
+
+  serialize(): Uint8Array;
+
+  static deserialize<P extends Proofish>(markerP: P['instance'], raw: Uint8Array): ZswapInput<P>;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The contract address receiving the input, if the sender is a contract
+   */
+  readonly contractAddress: ContractAddress | undefined;
+  /**
+   * The nullifier of the input
+   */
+  readonly nullifier: Nullifier;
+  /**
+   * The proof of this input
+   */
+  readonly proof: P;
+}
+
+/**
+ * A shielded transaction output
+ */
+export class ZswapOutput<P extends Proofish> {
+  private constructor();
+
+  /**
+   * Creates a new output, targeted to a user's coin public key.
+   *
+   * Optionally the output contains a ciphertext encrypted to the user's
+   * encryption public key, which may be omitted *only* if the {@link ShieldedCoinInfo}
+   * is transferred to the recipient another way
+   */
+  static new(coin: ShieldedCoinInfo, segment: number | undefined, target_cpk: CoinPublicKey, target_epk: EncPublicKey): UnprovenOutput;
+
+  /**
+   * Creates a new output, targeted to a smart contract
+   *
+   * A contract must *also* explicitly receive a coin created in this way for
+   * the output to be valid
+   */
+  static newContractOwned(coin: ShieldedCoinInfo, segment: number | undefined, contract: ContractAddress): UnprovenOutput;
+
+  serialize(): Uint8Array;
+
+  static deserialize<P extends Proofish>(markerP: P['instance'], raw: Uint8Array): ZswapOutput<P>;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The commitment of the output
+   */
+  readonly commitment: CoinCommitment;
+  /**
+   * The contract address receiving the output, if the recipient is a contract
+   */
+  readonly contractAddress: ContractAddress | undefined;
+  /**
+   * The proof of this output
+   */
+  readonly proof: P;
+}
+
+/**
+ * A shielded "transient"; an output that is immediately spent within the same
+ * transaction
+ */
+export class ZswapTransient<P extends Proofish> {
+  private constructor();
+
+  /**
+   * Creates a new contract-owned transient, from a given output and its coin.
+   *
+   * The {@link QualifiedShieldedCoinInfo} should have an `mt_index` of `0`
+   */
+  static newFromContractOwnedOutput(coin: QualifiedShieldedCoinInfo, segment: number | undefined, output: UnprovenOutput): UnprovenTransient;
+
+  serialize(): Uint8Array;
+
+  static deserialize<P extends Proofish>(markerP: P['instance'], raw: Uint8Array): ZswapTransient<P>;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The commitment of the transient
+   */
+  readonly commitment: CoinCommitment;
+  /**
+   * The contract address creating the transient, if applicable
+   */
+  readonly contractAddress: ContractAddress | undefined;
+  /**
+   * The nullifier of the transient
+   */
+  readonly nullifier: Nullifier;
+  /**
+   * The input proof of this transient
+   */
+  readonly inputProof: P;
+  /**
+   * The output proof of this transient
+   */
+  readonly outputProof: P;
+}
+
+export type ClaimKind = "Reward" | "CardanoBridge";
+
+/**
+ * A request to allocate rewards, authorized by the reward's recipient
+ */
+export class ClaimRewardsTransaction<S extends Signaturish> {
+  constructor(markerS: S['instance'], network_id: string, value: bigint, owner: SignatureVerifyingKey, nonce: Nonce, signature: S, kind?: ClaimKind);
+
+  static new(network_id: string, value: bigint, owner: SignatureVerifyingKey, nonce: Nonce, kind: ClaimKind): ClaimRewardsTransaction<SignatureErased>;
+
+  addSignature(signature: Signature): ClaimRewardsTransaction<SignatureEnabled>;
+
+  eraseSignatures(): ClaimRewardsTransaction<SignatureErased>;
+
+  serialize(): Uint8Array;
+
+  static deserialize<S extends Signaturish>(markerS: S['instance'], raw: Uint8Array): ClaimRewardsTransaction<S>;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The raw data any valid signature must be over to approve this transaction.
+   */
+  readonly dataToSign: Uint8Array;
+
+  /**
+   * The rewarded coin's value, in atomic units dependent on the currency
+   *
+   * Bounded to be a non-negative 64-bit integer
+   */
+  readonly value: bigint;
+
+  /**
+   * The signing key owning this coin.
+   */
+  readonly owner: SignatureVerifyingKey;
+
+  /**
+   * The rewarded coin's randomness, preventing it from colliding with other coins.
+   */
+  readonly nonce: Nonce;
+
+  /**
+   * The signature on this request.
+   */
+  readonly signature: S;
+
+  /**
+   * The kind of claim being made, either a `Reward` or a `CardanoBridge` claim.
+   */
+  readonly kind: ClaimKind
+}
+
+/**
+ * A full Zswap offer; the zswap part of a transaction
+ *
+ * Consists of sets of {@link ZswapInput}s, {@link ZswapOutput}s, and {@link ZswapTransient}s,
+ * as well as a {@link deltas} vector of the transaction value
+ */
+export class ZswapOffer<P extends Proofish> {
+  private constructor();
+
+  /**
+   * Creates a singleton offer, from an {@link ZswapInput} and its value
+   * vector
+   *
+   * The `type_` and `value` parameters are deprecated and will be ignored.
+   */
+  static fromInput<P extends Proofish>(input: ZswapInput<P>, type_?: RawTokenType, value?: bigint): ZswapOffer<P>;
+
+  /**
+   * Creates a singleton offer, from an {@link ZswapOutput} and its value
+   * vector
+   *
+   * The `type_` and `value` parameters are deprecated and will be ignored.
+   */
+  static fromOutput<P extends Proofish>(output: ZswapOutput<P>, type_?: RawTokenType, value?: bigint): ZswapOffer<P>;
+
+  /**
+   * Creates a singleton offer, from a {@link ZswapTransient}
+   */
+  static fromTransient<P extends Proofish>(transient: ZswapTransient<P>): ZswapOffer<P>;
+
+  /**
+   * Combine this offer with another
+   */
+  merge(other: ZswapOffer<P>): ZswapOffer<P>;
+
+  serialize(): Uint8Array;
+
+  static deserialize<P extends Proofish>(markerP: P['instance'], raw: Uint8Array): ZswapOffer<P>;
+
+  toString(compact?: boolean): string;
+
+  /**
+   * The value of this offer for each token type; note that this may be
+   * negative
+   *
+   * This is input coin values - output coin values, for value vectors
+   */
+  readonly deltas: Map<RawTokenType, bigint>;
+  /**
+   * The inputs this offer is composed of
+   */
+  readonly inputs: ZswapInput<P>[];
+  /**
+   * The outputs this offer is composed of
+   */
+  readonly outputs: ZswapOutput<P>[];
+  /**
+   * The transients this offer is composed of
+   */
+  readonly transients: ZswapTransient<P>[];
+}
+
+/**
+ * A privileged transaction issued by the system.
+ */
+export class SystemTransaction {
+  private constructor();
+
+  serialize(): Uint8Array;
+
+  static deserialize(raw: Uint8Array): SystemTransaction;
+
+  toString(compact?: boolean): string;
+}
+
+/**
+ * A transaction that has not yet been proven.
+ */
+export type UnprovenTransaction = Transaction<SignatureEnabled, PreProof, PreBinding>;
+
+/**
+ * A transaction that has been proven and finalized.
+ */
+export type FinalizedTransaction = Transaction<SignatureEnabled, Proof, Binding>;
+
+/**
+ * A transaction with proofs erased.
+ */
+export type ProofErasedTransaction = Transaction<Signaturish, NoProof, NoBinding>;