@midnames/sdk 1.0.3 → 1.0.5

package/node_modules/@midnames/ns/node_modules/@midnight-ntwrk/ledger-v8/ledger-v8.d.ts

@@ -1,3079 +0,0 @@
-/**
- * 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 35-byte string
- */
-export type ContractAddress = string;
-/**
- * A user public key address, as a hex-encoded 35-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 35-byte string
- */
-export type UnshieldedTokenType = { tag: 'unshielded', raw: RawTokenType };
-/**
- * Shielded token type (or color), as a hex-encoded 35-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 35-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 35-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;
-/**
- * A hex-encoded signature BIP-340 verifying key, with a 3-byte version prefix
- */
-export type SignatureVerifyingKey = string;
-/**
- * A hex-encoded signature BIP-340 signing key, with a 3-byte version prefix
- */
-export type SigningKey = string;
-/**
- * A hex-encoded signature BIP-340 signature, with a 3-byte version prefix
- */
-export type Signature = 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';
-/**
- * An individual result of observing the results of a non-verifying VM program
- * execution
- */
-export type GatherResult = { tag: 'read', content: AlignedValue } |
-  { tag: 'log', content: 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}.
- */
-export function sampleSigningKey(): 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,
-): Uint8Array;
-
-/**
- * Takes a bigint modulus the proof systems scalar field
- */
-export function bigIntModFr(x: bigint): bigint;
-
-/**
- * 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): ContractState;
-
-  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): 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';
-}
-
-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;
-}
-
-/**
- * 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 DustState {
-  constructor();
-  serialize(): Uint8Array;
-  static deserialize(raw: Uint8Array): DustState;
-  toString(compact?: boolean): string;
-  readonly utxo: DustUtxoState;
-  readonly generation: DustGenerationState;
-}
-
-export class DustStateChanges {
-  private constructor();
-  /**
-   * The source of the state change, as a hex-encoded string
-   */
-  readonly source: string;
-  /**
-   * 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;
-  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;
-  serialize(): Uint8Array;
-  static deserialize(raw: Uint8Array): DustLocalState;
-  toString(compact?: boolean): string;
-  readonly utxos: QualifiedDustOutput[];
-  readonly params: DustParameters;
-  readonly syncTime: Date;
-}
-
-/**
- * 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;
-
-  /**
-   * 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
-  );
-  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
-   */
-  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
-  );
-
-  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: Signature[]): UnshieldedOffer<SignatureEnabled>;
-
-  addSignatures(signatures: Signature[]): UnshieldedOffer<S>;
-
-  eraseSignatures(): UnshieldedOffer<SignatureErased>;
-
-  toString(compact?: boolean): string;
-
-  readonly inputs: UtxoSpend[];
-  readonly outputs: UtxoOutput[];
-  readonly signatures: Signature[];
-}
-
-/**
- * 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;
-
-/**
- * The version associated with a {@link ContractOperation}
- */
-export class ContractOperationVersion {
-  constructor(version: 'v3');
-
-  readonly version: 'v3';
-
-  toString(compact?: boolean): string;
-}
-
-/**
- * A versioned verifier key to be associated with a {@link ContractOperation}.
- */
-export class ContractOperationVersionedVerifierKey {
-  constructor(version: 'v3', rawVk: Uint8Array);
-
-  readonly version: 'v3';
-  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;
-}
-
-/**
- * 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>;
-};
-
-/**
- * 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>;
-
-  /**
-   * 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;
-
-/**
- * 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).
-   */
-  postBlockUpdate(tblock: Date): 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 {
-  private constructor();
-  /**
-   * The source of the state change, as a hex-encoded string
-   */
-  readonly source: string;
-  /**
-   * 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;
-
-  /**
-   * 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;
-  /**
-   * Locally applies an offer to the current state, returning the updated state
-   */
-  apply<P extends Proofish>(secretKeys: ZswapSecretKeys, offer: ZswapOffer<P>): ZswapLocalState;
-  /**
-   * 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]>;
-}
-
-/**
- * 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>;