@nockbox/iris-wasm 0.1.2 → 0.2.0-alpha.1

package/iris_wasm.d.ts

@@ -1,47 +1,802 @@
 /* tslint:disable */
 /* eslint-disable */
-/**
- * Hash a noun (jam as input)
- */
-export function hashNoun(noun: Uint8Array): string;
 /**
  * Verify a signature with a public key
  */
 export function verifySignature(public_key_bytes: Uint8Array, signature: Signature, message: string): boolean;
-/**
- * Hash a public key to get its digest (for use in PKH)
- */
-export function hashPublicKey(public_key_bytes: Uint8Array): string;
 /**
  * Derive master key from seed bytes
  */
 export function deriveMasterKey(seed: Uint8Array): ExtendedKey;
 /**
- * Sign a message string with a private key
+ * Hash a u64 value
  */
-export function signMessage(private_key_bytes: Uint8Array, message: string): Signature;
+export function hashU64(value: bigint): string;
 /**
  * Derive master key from BIP39 mnemonic phrase
  */
 export function deriveMasterKeyFromMnemonic(mnemonic: string, passphrase?: string | null): ExtendedKey;
 /**
- * Hash a u64 value
+ * Hash a public key to get its digest (for use in PKH)
  */
-export function hashU64(value: bigint): string;
+export function hashPublicKey(public_key_bytes: Uint8Array): string;
+/**
+ * Sign a message string with a private key
+ */
+export function signMessage(private_key_bytes: Uint8Array, message: string): Signature;
+/**
+ * Hash a noun (jam as input)
+ */
+export function hashNoun(noun: Uint8Array): string;
+export function cue(jam: Uint8Array): Noun;
+export function jam(noun: Noun): Uint8Array;
+export function hex_to_digest(s: string): Digest;
+export function note_hash(note: Note): Digest;
+export function note_to_protobuf(note: Note): PbCom2Note;
+export function digest_to_hex(d: Digest): string;
+export function create_note_v0(origin_page: number, sig_m: bigint, sig_pubkeys: Uint8Array[], source_hash: Digest, is_coinbase: boolean, timelock: Timelock | null | undefined, assets: Nicks): Note;
+export function digest_from_protobuf(value: PbCom1Hash): Digest;
+export function digest_to_protobuf(d: Digest): PbCom1Hash;
+export function note_from_protobuf(value: PbCom2Note): Note;
+export function create_note_v1(version: Version, origin_page: number, name: Name, note_data: NoteData, assets: Nicks): Note;
 /**
  * The `ReadableStreamType` enum.
  *
  * *This API requires the following crate features to be activated: `ReadableStreamType`*
  */
 type ReadableStreamType = "bytes";
-export class Digest {
-  free(): void;
-  [Symbol.dispose](): void;
-  toProtobuf(): any;
-  static fromProtobuf(value: any): Digest;
-  constructor(value: string);
-  readonly value: string;
+export interface TxNotes {
+    notes: Note[];
+    spend_conditions: SpendCondition[];
+}
+
+export interface PbCom1TimeLockIntent {
+    value: PbCom1TimeLockIntentValue | undefined;
+}
+
+export interface PbCom1Input {
+    note: PbCom1Note | undefined;
+    spend: PbCom1Spend | undefined;
+}
+
+export interface PbCom1BlockHeightDelta {
+    value: string;
+}
+
+export interface PbCom1NamedInput {
+    name: PbCom1Name | undefined;
+    input: PbCom1Input | undefined;
+}
+
+/**
+ * pub struct Belt(pub u64);
+ */
+export interface PbCom1Belt {
+    value: string;
+}
+
+export interface PbCom1PageResponse {
+    /**
+     * Opaque cursor for fetching the next page. Empty when there are no more
+     * results.
+     */
+    next_page_token: string;
+}
+
+export interface PbCom1SignatureEntry {
+    /**
+     * serialized pubkey corresponding to the signer
+     */
+    schnorr_pubkey: PbCom1SchnorrPubkey | undefined;
+    signature: PbCom1SchnorrSignature | undefined;
+}
+
+/**
+ * Use this when you want to force the output to not have a timelock
+ */
+export interface PbCom1TimeLockRangeNeither {}
+
+export interface PbCom1Base58Pubkey {
+    key: string;
+}
+
+/**
+ * pub chal: \\[Belt; 8\\],
+ * pub sig: \\[Belt; 8\\],
+ */
+export interface PbCom1EightBelt {
+    belt_1: PbCom1Belt | undefined;
+    belt_2: PbCom1Belt | undefined;
+    belt_3: PbCom1Belt | undefined;
+    belt_4: PbCom1Belt | undefined;
+    belt_5: PbCom1Belt | undefined;
+    belt_6: PbCom1Belt | undefined;
+    belt_7: PbCom1Belt | undefined;
+    belt_8: PbCom1Belt | undefined;
+}
+
+export interface PbCom1BalanceEntry {
+    name: PbCom1Name | undefined;
+    note: PbCom1Note | undefined;
+}
+
+export interface PbCom1Source {
+    hash: string;
+    coinbase: boolean;
+}
+
+export interface PbCom1Signature {
+    entries: PbCom1SignatureEntry[];
+}
+
+/**
+ * Note: prefer using raw numeric fields in messages
+ * instead of these wrappers to simplify conversions.
+ * These remain defined for potential future use.
+ */
+export interface PbCom1NoteVersion {
+    value: string;
+}
+
+export interface PbCom1Note {
+    /**
+     * page-number when added to balance
+     */
+    origin_page: PbCom1BlockHeight | undefined;
+    /**
+     * enforced timelock
+     */
+    timelock: PbCom1TimeLockIntent | undefined;
+    /**
+     * nname (human/name label)
+     */
+    name: PbCom1Name | undefined;
+    /**
+     * spending condition
+     */
+    lock: PbCom1Lock | undefined;
+    /**
+     * provenance commitment
+     */
+    source: PbCom1Source | undefined;
+    /**
+     * coin amount (nicks)
+     */
+    assets: PbCom1Nicks | undefined;
+    /**
+     * note version (currently 0)
+     */
+    version: PbCom1NoteVersion | undefined;
+}
+
+export interface PbCom1SchnorrSignature {
+    chal: PbCom1EightBelt | undefined;
+    sig: PbCom1EightBelt | undefined;
+}
+
+/**
+ * min and max are relative to the note\'s creation page
+ */
+export interface PbCom1TimeLockRangeRelative {
+    min: PbCom1BlockHeightDelta | undefined;
+    max: PbCom1BlockHeightDelta | undefined;
+}
+
+export interface PbCom1WireTag {
+    value: PbCom1WireTagValue | undefined;
+}
+
+export interface PbCom1TimeLockRangeAbsoluteAndRelative {
+    absolute: PbCom1TimeLockRangeAbsolute | undefined;
+    relative: PbCom1TimeLockRangeRelative | undefined;
+}
+
+export interface PbCom1Lock {
+    /**
+     * threshold of keys required to spend the note
+     */
+    keys_required: number;
+    /**
+     * DEPRECATED: repeated string schnorr_pubkeys_b58 = 2;
+     *
+     * schnorr pubkeys (curve: cheetah)
+     */
+    schnorr_pubkeys: PbCom1SchnorrPubkey[];
+}
+
+export interface PbCom1BlockHeight {
+    value: string;
+}
+
+export interface PbCom1ErrorStatus {
+    code: number;
+    message: string;
+    /**
+     * additional error context
+     */
+    details: string | undefined;
+}
+
+/**
+ * min and max are absolute origin page numbers
+ */
+export interface PbCom1TimeLockRangeAbsolute {
+    min: PbCom1BlockHeight | undefined;
+    max: PbCom1BlockHeight | undefined;
+}
+
+/**
+ * Generic pagination parameters for list-style RPCs.
+ * These types are intended to be reused across public APIs.
+ *
+ * Contract:
+ * - The server may return fewer items than requested (client_page_items_limit is a hint).
+ * - page_token is an opaque cursor produced by the server; clients must treat
+ *    it as a black box. Servers may encode snapshot identity and last-key.
+ * - For consistent pagination, clients should include the returned page_token
+ *    in the next request without modification.
+ * - Servers may enforce a maximum client_page_items_limit and/or byte budget regardless of
+ *    client hints.
+ */
+export interface PbCom1PageRequest {
+    /**
+     * Maximum number of items to return. The server may return fewer items
+     * than requested. Clients should not rely on receiving exactly this count.
+     */
+    client_page_items_limit: number;
+    /**
+     * Opaque cursor returned by a previous call. When set, the server resumes
+     * the listing from the position described by the token.
+     * An empty token indicates the first page.
+     */
+    page_token: string;
+    /**
+     * Optional soft limit on the uncompressed bytes to return in a single page.
+     * The server may ignore or cap this value according to policy. This refers
+     * to the gRPC payload size after protobuf encoding and decompression.
+     */
+    max_bytes: number;
+}
+
+export interface PbCom1WalletBalanceData {
+    /**
+     * Page of full UTXO entries for the requested wallet. Entries are ordered
+     * by (Name.first, Name.last) to support consistent pagination.
+     *
+     * note name -> amount
+     */
+    notes: PbCom1BalanceEntry[];
+    /**
+     * Snapshot metadata where this page was computed. Clients should include
+     * the returned page token to continue paging against the same snapshot.
+     *
+     * block height where balance was computed
+     */
+    height: PbCom1BlockHeight | undefined;
+    /**
+     * block where balance was computed
+     */
+    block_id: PbCom1Hash | undefined;
+    /**
+     * Pagination cursor for fetching the next page in a paginated view.
+     * When empty, there are no further results for this snapshot.
+     */
+    page: PbCom1PageResponse | undefined;
+}
+
+export interface PbCom1Wire {
+    /**
+     * e.g., \"http\", \"file\", \"wallet\", \"grpc\
+     */
+    source: string;
+    /**
+     * wire format version
+     */
+    version: number;
+    /**
+     * operation-specific tags
+     */
+    tags: PbCom1WireTag[];
+}
+
+/**
+ * pub struct F6lt(pub \\[Belt; 6\\]);
+ */
+export interface PbCom1SixBelt {
+    belt_1: PbCom1Belt | undefined;
+    belt_2: PbCom1Belt | undefined;
+    belt_3: PbCom1Belt | undefined;
+    belt_4: PbCom1Belt | undefined;
+    belt_5: PbCom1Belt | undefined;
+    belt_6: PbCom1Belt | undefined;
+}
+
+export interface PbCom1OutputSource {
+    source: PbCom1Source | undefined;
+}
+
+export interface PbCom1Acknowledged {}
+
+/**
+ * pub struct SchnorrPubkey(pub CheetahPoint);
+ */
+export interface PbCom1SchnorrPubkey {
+    value: PbCom1CheetahPoint | undefined;
+}
+
+export interface PbCom1Base58Hash {
+    hash: string;
+}
+
+/**
+ * pub struct CheetahPoint {
+ *    pub x: F6lt,
+ *    pub y: F6lt,
+ *    pub inf: bool,
+ * }
+ */
+export interface PbCom1CheetahPoint {
+    x: PbCom1SixBelt | undefined;
+    y: PbCom1SixBelt | undefined;
+    inf: boolean;
+}
+
+/**
+ * pub struct Hash(pub \\[Belt; 5\\]);
+ * Use fixed fields to avoid variable-length vectors.
+ */
+export interface PbCom1Hash {
+    belt_1: PbCom1Belt | undefined;
+    belt_2: PbCom1Belt | undefined;
+    belt_3: PbCom1Belt | undefined;
+    belt_4: PbCom1Belt | undefined;
+    belt_5: PbCom1Belt | undefined;
+}
+
+export interface PbCom1Name {
+    /**
+     * First is the hash of whether the note has a timelock and the lock
+     */
+    first: string;
+    /**
+     * Last is the hash of the actual timelock and the source
+     */
+    last: string;
+}
+
+export interface PbCom1Seed {
+    output_source: PbCom1OutputSource | undefined;
+    recipient: PbCom1Lock | undefined;
+    timelock_intent: PbCom1TimeLockIntent | undefined;
+    gift: PbCom1Nicks | undefined;
+    parent_hash: string;
+}
+
+export interface PbCom1Nicks {
+    value: string;
+}
+
+export interface PbCom1Spend {
+    signature: PbCom1Signature | undefined;
+    seeds: PbCom1Seed[];
+    miner_fee_nicks: PbCom1Nicks | undefined;
+}
+
+export type PbCom1ErrorCode = "Unspecified" | "InvalidRequest" | "PeekFailed" | "PeekReturnedNoData" | "PokeFailed" | "NackappError" | "Timeout" | "InternalError" | "NotFound" | "PermissionDenied" | "InvalidWire" | "KernelError";
+
+/**
+ * the string key is the name of the input
+ * message RawTransaction { map<Name, Input> inputs = 1; }
+ */
+export interface PbCom1RawTransaction {
+    named_inputs: PbCom1NamedInput[];
+    timelock_range: PbCom1TimeLockRangeAbsolute | undefined;
+    total_fees: PbCom1Nicks | undefined;
+    id: string;
+}
+
+export interface PbCom2SpendCondition {
+    primitives: PbCom2LockPrimitive[];
+}
+
+export interface PbCom2Seed {
+    /**
+     * Absent when the seed originates from a coinbase output.
+     */
+    output_source: PbCom1Source | undefined;
+    lock_root: string;
+    note_data: PbCom2NoteData | undefined;
+    gift: PbCom1Nicks | undefined;
+    parent_hash: string;
+}
+
+export interface PbCom2MerkleProof {
+    root: string;
+    path: string[];
+}
+
+export interface PbCom2PkhSignatureEntry {
+    hash: string;
+    pubkey: PbCom1SchnorrPubkey | undefined;
+    signature: PbCom1SchnorrSignature | undefined;
+}
+
+export interface PbCom2SpendEntry {
+    name: PbCom1Name | undefined;
+    spend: PbCom2Spend | undefined;
+}
+
+export interface PbCom2BalanceEntry {
+    name: PbCom1Name | undefined;
+    note: PbCom2Note | undefined;
+}
+
+export interface PbCom2LockMerkleProof {
+    spend_condition: PbCom2SpendCondition | undefined;
+    axis: number;
+    proof: PbCom2MerkleProof | undefined;
+}
+
+export interface PbCom2WitnessSpend {
+    witness: PbCom2Witness | undefined;
+    seeds: PbCom2Seed[];
+    fee: PbCom1Nicks | undefined;
+}
+
+export interface PbCom2Spend {
+    spend_kind: PbCom2SpendSpendKind | undefined;
+}
+
+export interface PbCom2NoteDataEntry {
+    key: string;
+    /**
+     * jammed noun bytes
+     */
+    blob: number[];
+}
+
+export interface PbCom2LockTim {
+    rel: PbCom1TimeLockRangeRelative | undefined;
+    abs: PbCom1TimeLockRangeAbsolute | undefined;
+}
+
+export interface PbCom2HaxLock {
+    hashes: PbCom1Hash[];
+}
+
+export interface PbCom2HaxPreimage {
+    hash: PbCom1Hash | undefined;
+    /**
+     * jammed noun bytes
+     */
+    value: number[];
+}
+
+export interface PbCom2BurnLock {}
+
+export interface PbCom2PkhSignature {
+    entries: PbCom2PkhSignatureEntry[];
+}
+
+export interface PbCom2RawTransaction {
+    version: PbCom1NoteVersion | undefined;
+    id: string;
+    spends: PbCom2SpendEntry[];
+}
+
+export interface PbCom2Note {
+    note_version: PbCom2NoteNoteVersion | undefined;
+}
+
+export interface PbCom2NoteV1 {
+    version: PbCom1NoteVersion | undefined;
+    origin_page: PbCom1BlockHeight | undefined;
+    name: PbCom1Name | undefined;
+    note_data: PbCom2NoteData | undefined;
+    assets: PbCom1Nicks | undefined;
+}
+
+export interface PbCom2Balance {
+    notes: PbCom2BalanceEntry[];
+    height: PbCom1BlockHeight | undefined;
+    block_id: string;
+    page: PbCom1PageResponse | undefined;
+}
+
+export interface PbCom2NoteData {
+    entries: PbCom2NoteDataEntry[];
+}
+
+export interface PbCom2Witness {
+    lock_merkle_proof: PbCom2LockMerkleProof | undefined;
+    pkh_signature: PbCom2PkhSignature | undefined;
+    /**
+     * uint64 tim = 4; // reserved field, currently 0
+     */
+    hax: PbCom2HaxPreimage[];
+}
+
+export interface PbCom2PkhLock {
+    m: number;
+    hashes: string[];
+}
+
+export interface PbCom2LegacySpend {
+    signature: PbCom1Signature | undefined;
+    seeds: PbCom2Seed[];
+    fee: PbCom1Nicks | undefined;
+}
+
+export interface PbCom2LockPrimitive {
+    primitive: PbCom2LockPrimitivePrimitive | undefined;
+}
+
+export type PbPub2WalletGetBalanceRequestSelector = { Address: PbCom1Base58Pubkey } | { FirstName: PbCom1Base58Hash };
+
+export type PbCom1TimeLockIntentValue = { Absolute: PbCom1TimeLockRangeAbsolute } | { Relative: PbCom1TimeLockRangeRelative } | { AbsoluteAndRelative: PbCom1TimeLockRangeAbsoluteAndRelative } | { Neither: PbCom1TimeLockRangeNeither };
+
+export type PbCom2LockPrimitivePrimitive = { Pkh: PbCom2PkhLock } | { Tim: PbCom2LockTim } | { Hax: PbCom2HaxLock } | { Burn: PbCom2BurnLock };
+
+export type PbCom2SpendSpendKind = { Legacy: PbCom2LegacySpend } | { Witness: PbCom2WitnessSpend };
+
+export type PbCom2NoteNoteVersion = { Legacy: PbCom1Note } | { V1: PbCom2NoteV1 };
+
+export type PbCom1WireTagValue = { Text: string } | { Number: number };
+
+export interface PbPub2WalletGetBalanceResponse {
+    result: PbPub2WalletGetBalanceResponseResult | undefined;
+}
+
+export interface PbPub2TransactionAcceptedResponse {
+    result: PbPub2TransactionAcceptedResponseResult | undefined;
+}
+
+export interface PbPub2TransactionAcceptedRequest {
+    tx_id: PbCom1Base58Hash | undefined;
+}
+
+export interface PbPub2WalletSendTransactionResponse {
+    result: PbPub2WalletSendTransactionResponseResult | undefined;
+}
+
+export interface PbPub2WalletSendTransactionRequest {
+    tx_id: PbCom1Hash | undefined;
+    raw_tx: PbCom2RawTransaction | undefined;
+}
+
+export interface PbPub2WalletGetBalanceRequest {
+    page: PbCom1PageRequest | undefined;
+    selector: PbPub2WalletGetBalanceRequestSelector | undefined;
+}
+
+export type PbPub2TransactionAcceptedResponseResult = { Accepted: boolean } | { Error: PbCom1ErrorStatus };
+
+export type PbPub2WalletGetBalanceResponseResult = { Balance: PbCom2Balance } | { Error: PbCom1ErrorStatus };
+
+export type PbPub2WalletSendTransactionResponseResult = { Ack: PbCom1Acknowledged } | { Error: PbCom1ErrorStatus };
+
+export type NoteData = ZMap<string, Noun>;
+
+export type Hax = ZSet<Digest>;
+
+export type SpendsV1 = ZMap<Name, SpendV1>;
+
+export type SpendCondition = LockPrimitive[];
+
+export interface Pkh {
+    m: number;
+    hashes: ZSet<Digest>;
+}
+
+export interface Witness {
+    lock_merkle_proof: LockMerkleProof;
+    pkh_signature: PkhSignature;
+    hax_map: ZMap<Digest, Noun>;
+    tim: undefined;
+}
+
+export interface LockMetadata {
+    lock: SpendCondition;
+    include_data: boolean;
+}
+
+export interface Spend0V1 {
+    signature: LegacySignature;
+    seeds: SeedsV1;
+    fee: Nicks;
+}
+
+export interface WitnessData {
+    data: ZMap<Name, Witness>;
+}
+
+export type LockPrimitive = { Pkh: Pkh } | { Tim: LockTim } | { Hax: Hax } | "Brn";
+
+export interface LockMerkleProof {
+    spend_condition: SpendCondition;
+    axis: number;
+    proof: MerkleProof;
 }
+
+export interface Spend1V1 {
+    witness: Witness;
+    seeds: SeedsV1;
+    fee: Nicks;
+}
+
+export interface NockchainTx {
+    version: Version;
+    id: TxId;
+    spends: SpendsV1;
+    display: TransactionDisplay;
+    witness_data: WitnessData;
+}
+
+export type LockRoot = { Hash: Digest } | { Lock: SpendCondition };
+
+export type SeedsV1 = ZSet<SeedV1>;
+
+export interface MerkleProof {
+    root: Digest;
+    path: Digest[];
+}
+
+export type PkhSignature = ZMap<Digest, [PublicKey, Signature]>;
+
+export interface NoteV1 {
+    version: Version;
+    origin_page: BlockHeight;
+    name: Name;
+    note_data: NoteData;
+    assets: Nicks;
+}
+
+export interface RawTxV1 {
+    version: 1;
+    id: TxId;
+    spends: SpendsV1;
+}
+
+export type SpendV1 = { version: 0; spend: Spend0V1 } | { version: 1; spend: Spend1V1 };
+
+export type InputDisplay = { version: 0; p: ZMap<Name, Sig> } | { version: 1; p: ZMap<Name, SpendCondition> };
+
+export interface SeedV1 {
+    output_source: Source | undefined;
+    lock_root: LockRoot;
+    note_data: NoteData;
+    gift: Nicks;
+    parent_hash: Digest;
+}
+
+export interface TransactionDisplay {
+    inputs: InputDisplay;
+    outputs: ZMap<Digest, LockMetadata>;
+}
+
+export type MissingUnlocks = { Pkh: { num_sigs: number; sig_of: Digest[] } } | { Hax: { preimages_for: Digest[] } } | "Brn" | { Sig: { num_sigs: number; sig_of: PublicKey[] } };
+
+export type Balance = [Name, Note][];
+
+export interface BalanceUpdate {
+    height: BlockHeight;
+    block_id: Digest;
+    notes: Balance;
+}
+
+export type Version = 0 | 1 | 2;
+
+/**
+ * Timelock range (for both absolute and relative constraints)
+ */
+export interface TimelockRange {
+    min: BlockHeight | undefined;
+    max: BlockHeight | undefined;
+}
+
+/**
+ * 64-bit unsigned integer representing the number of assets.
+ */
+export type Nicks = string;
+
+export interface Source {
+    hash: Digest;
+    is_coinbase: boolean;
+}
+
+export interface Name {
+    first: Digest;
+    last: Digest;
+    _sig: number;
+}
+
+export type Note = NoteV0 | NoteV1;
+
+export interface Sig {
+    m: number;
+    pubkeys: ZSet<PublicKey>;
+}
+
+export interface RawTxV0 {
+    id: TxId;
+    inputs: Inputs;
+    timelock_range: TimelockRange;
+    total_fees: Nicks;
+}
+
+export interface Timelock {
+    rel: TimelockRange;
+    abs: TimelockRange;
+}
+
+export type Inputs = ZMap<Name, Input>;
+
+export type SeedsV0 = ZSet<SeedV0>;
+
+export interface NoteV0 {
+    inner: NoteInner;
+    name: Name;
+    sig: Sig;
+    source: Source;
+    assets: Nicks;
+}
+
+export interface SeedV0 {
+    output_source: Source | undefined;
+    recipient: Sig;
+    timelock_intent: TimelockIntent;
+    gift: Nicks;
+    parent_hash: Digest;
+}
+
+export interface Input {
+    note: NoteV0;
+    spend: SpendV0;
+}
+
+export interface SpendV0 {
+    signature: LegacySignature | undefined;
+    seeds: SeedsV0;
+    fee: Nicks;
+}
+
+export interface NoteInner {
+    version: Version;
+    origin_page: BlockHeight;
+    timelock: TimelockIntent;
+}
+
+export type LegacySignature = ZMap<PublicKey, Signature>;
+
+export interface TimelockIntent {
+    tim: Timelock | undefined;
+}
+
+export type RawTx = RawTxV0 | RawTxV1;
+
+export interface Signature {
+    c: Uint8Array;
+    s: Uint8Array;
+}
+
+export type PublicKey = CheetahPoint;
+
+export type Noun = string | [Noun];
+
+export type CheetahPoint = string;
+
+export type Digest = string;
+
+export type ZBase<E> = E[];
+
+export type ZMap<K, V> = ZBase<ZMapEntry<K, V>>;
+
+export type ZMapEntry<K, V> = [K, V];
+
+export type ZSet<T> = ZBase<ZSetEntry<T>>;
+
+export type ZSetEntry<T> = T;
+
 export class ExtendedKey {
   private constructor();
   free(): void;
@@ -60,7 +815,7 @@ export class GrpcClient {
   /**
    * Send a transaction
    */
-  sendTransaction(raw_tx: any): Promise<any>;
+  sendTransaction(raw_tx: PbCom2RawTransaction): Promise<string>;
   /**
    * Check if a transaction was accepted
    */
@@ -68,19 +823,13 @@ export class GrpcClient {
   /**
    * Get balance for a wallet address
    */
-  getBalanceByAddress(address: string): Promise<any>;
+  getBalanceByAddress(address: string): Promise<PbCom2Balance>;
   /**
    * Get balance for a first name
    */
-  getBalanceByFirstName(first_name: string): Promise<any>;
+  getBalanceByFirstName(first_name: string): Promise<PbCom2Balance>;
   constructor(endpoint: string);
 }
-export class Hax {
-  free(): void;
-  [Symbol.dispose](): void;
-  constructor(digests: Digest[]);
-  readonly digests: Digest[];
-}
 export class IntoUnderlyingByteSource {
   private constructor();
   free(): void;
@@ -106,538 +855,110 @@ export class IntoUnderlyingSource {
   pull(controller: ReadableStreamDefaultController): Promise<any>;
   cancel(): void;
 }
-export class LockPrimitive {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  toProtobuf(): any;
-  static fromProtobuf(value: any): LockPrimitive;
-  static newBrn(): LockPrimitive;
-  static newHax(hax: Hax): LockPrimitive;
-  static newPkh(pkh: Pkh): LockPrimitive;
-  static newTim(tim: LockTim): LockPrimitive;
-}
-export class LockRoot {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  static fromSpendCondition(cond: SpendCondition): LockRoot;
-  static fromHash(hash: Digest): LockRoot;
-  readonly hash: Digest;
-  readonly lock: SpendCondition | undefined;
-}
-export class LockTim {
-  free(): void;
-  [Symbol.dispose](): void;
-  toProtobuf(): any;
-  static fromProtobuf(value: any): LockTim;
-  constructor(rel: TimelockRange, abs: TimelockRange);
-  static coinbase(): LockTim;
-  readonly abs: TimelockRange;
-  readonly rel: TimelockRange;
-}
-export class Name {
-  free(): void;
-  [Symbol.dispose](): void;
-  toProtobuf(): any;
-  static fromProtobuf(value: any): Name;
-  constructor(first: string, last: string);
-  readonly last: string;
-  readonly first: string;
-}
-export class NockchainTx {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Convert to jammed transaction file for inspecting through CLI
-   */
-  toJam(): Uint8Array;
-  outputs(): Note[];
-  /**
-   * Convert from CLI-compatible jammed transaction file
-   */
-  static fromJam(jam: Uint8Array): NockchainTx;
-  toRawTx(): RawTx;
-  readonly id: Digest;
-  readonly name: string;
-  readonly version: Version;
-}
-export class Note {
-  free(): void;
-  [Symbol.dispose](): void;
-  toProtobuf(): any;
-  /**
-   * Create a WasmNote from a protobuf Note object (from get_balance response)
-   * Expects response.notes[i].note (handles version internally)
-   */
-  static fromProtobuf(pb_note: any): Note;
-  constructor(version: Version, origin_page: bigint, name: Name, note_data: NoteData, assets: bigint);
-  hash(): Digest;
-  readonly originPage: bigint;
-  readonly name: Name;
-  readonly assets: bigint;
-  readonly version: Version;
-  readonly noteData: NoteData;
-}
-export class NoteData {
-  free(): void;
-  [Symbol.dispose](): void;
-  toProtobuf(): any;
-  static fromProtobuf(value: any): NoteData;
-  constructor(entries: NoteDataEntry[]);
-  static empty(): NoteData;
-  static fromPkh(pkh: Pkh): NoteData;
-  readonly entries: NoteDataEntry[];
-}
-export class NoteDataEntry {
-  free(): void;
-  [Symbol.dispose](): void;
-  toProtobuf(): any;
-  static fromProtobuf(value: any): NoteDataEntry;
-  constructor(key: string, blob: Uint8Array);
-  readonly key: string;
-  readonly blob: Uint8Array;
-}
-export class Noun {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  static cue(jam: Uint8Array): Noun;
-  jam(): Uint8Array;
-  static fromJs(value: any): Noun;
-  toJs(): any;
-}
-export class Pkh {
-  free(): void;
-  [Symbol.dispose](): void;
-  toProtobuf(): any;
-  static fromProtobuf(value: any): Pkh;
-  constructor(m: bigint, hashes: string[]);
-  static single(hash: string): Pkh;
-  readonly m: bigint;
-  readonly hashes: string[];
-}
-export class RawTx {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  /**
-   * Convert to protobuf RawTransaction for sending via gRPC
-   */
-  toProtobuf(): any;
-  static fromProtobuf(value: any): RawTx;
-  toNockchainTx(): NockchainTx;
-  /**
-   * Convert to jammed transaction file for inspecting through CLI
-   */
-  toJam(): Uint8Array;
-  /**
-   * Calculate output notes from the transaction spends.
-   */
-  outputs(): Note[];
-  static fromJam(jam: Uint8Array): RawTx;
-  readonly id: Digest;
-  readonly name: string;
-  readonly version: Version;
-}
-export class Seed {
-  free(): void;
-  [Symbol.dispose](): void;
-  static newSinglePkh(pkh: Digest, gift: bigint, parent_hash: Digest, include_lock_data: boolean): Seed;
-  constructor(output_source: Source | null | undefined, lock_root: LockRoot, gift: bigint, note_data: NoteData, parent_hash: Digest);
-  parentHash: Digest;
-  get outputSource(): Source | undefined;
-  set outputSource(value: Source | null | undefined);
-  lockRoot: LockRoot;
-  noteData: NoteData;
-  gift: bigint;
-}
-export class Signature {
-  free(): void;
-  [Symbol.dispose](): void;
-  constructor(c: Uint8Array, s: Uint8Array);
-  readonly c: Uint8Array;
-  readonly s: Uint8Array;
-}
-export class Source {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  readonly isCoinbase: boolean;
-  readonly hash: Digest;
-}
 export class SpendBuilder {
   free(): void;
   [Symbol.dispose](): void;
-  /**
-   * Get current refund
-   */
-  curRefund(): Seed | undefined;
-  /**
-   * Checks whether note.assets = seeds + fee
-   *
-   * This function needs to return true for `TxBuilder::validate` to pass
-   */
+  curRefund(): SeedV1 | undefined;
   isBalanced(): boolean;
-  /**
-   * Attatch a preimage to this spend
-   */
   addPreimage(preimage_jam: Uint8Array): Digest | undefined;
-  /**
-   * Compute refund from any spare assets, given `refund_lock` was passed
-   */
   computeRefund(include_lock_data: boolean): void;
-  /**
-   * Manually invalidate signatures
-   *
-   * Each spend's fee+seeds are bound to one or more signatures. If they get changed, the
-   * signature becomes invalid. This builder automatically invalidates signatures upon relevant
-   * modifications, but this functionality is provided nonetheless.
-   */
   invalidateSigs(): void;
-  /**
-   * Get the list of missing "unlocks"
-   *
-   * An unlock is a spend condition to be satisfied. For instance, for a `Pkh` spend condition,
-   * if the transaction is unsigned, this function will return a Pkh type missing unlock, with
-   * the list of valid PKH's and number of signatures needed. This will not return PKHs that are
-   * already attatched to the spend (relevant for multisigs). For `Hax` spend condition, this
-   * will return any missing preimages. This function will return a list of not-yet-validated
-   * spend conditions.
-   */
-  missingUnlocks(): any[];
-  /**
-   * Set the fee of this spend
-   */
-  fee(fee: bigint): void;
+  missingUnlocks(): MissingUnlocks[];
+  fee(fee: Nicks): void;
   /**
    * Create a new `SpendBuilder` with a given note and spend condition
    */
-  constructor(note: Note, spend_condition: SpendCondition, refund_lock?: SpendCondition | null);
-  /**
-   * Add seed to this spend
-   *
-   * Seed is an output with a recipient (as defined by the spend condition).
-   *
-   * Nockchain transaction engine will take all seeds with matching lock from all spends in the
-   * transaction, and merge them into one output note.
-   */
-  seed(seed: Seed): void;
-  /**
-   * Sign the transaction with a given private key
-   */
+  constructor(note: Note, spend_condition?: SpendCondition | null, refund_lock?: SpendCondition | null);
+  seed(seed: SeedV1): void;
   sign(signing_key_bytes: Uint8Array): boolean;
 }
-export class SpendCondition {
-  free(): void;
-  [Symbol.dispose](): void;
-  firstName(): Digest;
-  toProtobuf(): any;
-  static fromProtobuf(value: any): SpendCondition;
-  constructor(primitives: LockPrimitive[]);
-  hash(): Digest;
-  static newPkh(pkh: Pkh): SpendCondition;
-}
-export class TimelockRange {
-  free(): void;
-  [Symbol.dispose](): void;
-  constructor(min?: bigint | null, max?: bigint | null);
-  readonly max: bigint | undefined;
-  readonly min: bigint | undefined;
-}
 export class TxBuilder {
   free(): void;
   [Symbol.dispose](): void;
   allSpends(): SpendBuilder[];
-  /**
-   * Appends `preimage_jam` to all spend conditions that expect this preimage.
-   */
   addPreimage(preimage_jam: Uint8Array): Digest | undefined;
-  /**
-   * Perform a simple-spend on this builder.
-   *
-   * It is HIGHLY recommended to not mix `simpleSpend` with other types of spends.
-   *
-   * This performs a fairly complex set of operations, in order to mimic behavior of nockchain
-   * CLI wallet's create-tx option. Note that we do not do 1-1 mapping of that functionality,
-   * most notably - if `recipient` is the same as `refund_pkh`, we will create 1 seed, while the
-   * CLI wallet will create 2.
-   *
-   * Another difference is that you should call `sign` and `validate` after calling this method.
-   *
-   * Internally, the transaction builder takes ALL of the `notes` provided, and stores them for
-   * fee adjustments. If there are multiple notes being used, our fee setup also differs from
-   * the CLI, because we first greedily spend the notes out, and then take fees from any
-   * remaining refunds.
-   *
-   * This function prioritizes using the least number of notes possible, because that lowers the
-   * fee used.
-   *
-   * You may choose to override the fee with `fee_override`, but do note that `validate` will
-   * fail, in case this fee is too small.
-   *
-   * `include_lock_data` can be used to include `%lock` key in note-data, with the
-   * `SpendCondition` used. However, note-data costs 1 << 15 nicks, which means, it can get
-   * expensive.
-   *
-   * Optional parameter `remove_unused_notes`, if set to false, will keep the notes in the
-   * transaction builder. This is meant to be used whenever additional operations are performed
-   * on the builder, such as additional spends, or `addPreimage` calls. All of these increase
-   * the required fee (which can be checked with `calcFee`), and unused notes can then be used
-   * to adjust fees with `setFeeAndBalanceRefund` or `recalcAndSetFee`. Once all operations are
-   * done, one should call `removeUnusedNotes` to ensure these notes are not used within the
-   * transaction.
-   */
-  simpleSpend(notes: Note[], spend_conditions: SpendCondition[], recipient: Digest, gift: bigint, fee_override: bigint | null | undefined, refund_pkh: Digest, include_lock_data: boolean): void;
-  /**
-   * Recalculate fee and set it, balancing things out with refunds
-   */
+  simpleSpend(notes: Note[], spend_conditions: SpendCondition[], recipient: Digest, gift: Nicks, fee_override: Nicks | null | undefined, refund_pkh: Digest, include_lock_data: boolean): void;
   recalcAndSetFee(include_lock_data: boolean): void;
-  /**
-   * Distributes `fee` across builder's spends, and balances refunds out
-   *
-   * `adjust_fee` parameter allows the fee to be slightly tweaked, whenever notes are added or
-   * removed to/from the builder's fee note pool. This is because using more or less notes
-   * impacts the exact fee being required. If the caller estimates fee and sets it, adding more
-   * notes will change the exact fee needed, and setting this parameter to true will allow one
-   * to not have to call this function multiple times.
-   */
-  setFeeAndBalanceRefund(fee: bigint, adjust_fee: boolean, include_lock_data: boolean): void;
+  setFeeAndBalanceRefund(fee: Nicks, adjust_fee: boolean, include_lock_data: boolean): void;
   /**
    * Create an empty transaction builder
    */
-  constructor(fee_per_word: bigint);
-  /**
-   * Sign the transaction with a private key.
-   *
-   * This will sign all spends that are still missing signature from
-   */
+  constructor(fee_per_word: Nicks);
   sign(signing_key_bytes: Uint8Array): void;
   build(): NockchainTx;
   /**
    * Append a `SpendBuilder` to this transaction
    */
   spend(spend: SpendBuilder): SpendBuilder | undefined;
-  /**
-   * Gets the current fee set on all spends.
-   */
-  curFee(): bigint;
+  curFee(): Nicks;
   /**
    * Reconstruct a builder from raw transaction and its input notes.
-   *
-   * To get the builder back, you must pass the notes and their corresponding spend conditions.
-   * If serializing the builder, call `WasmTxBuilder::all_notes`.
    */
   static fromTx(tx: RawTx, notes: Note[], spend_conditions: SpendCondition[]): TxBuilder;
-  /**
-   * Calculates the fee needed for the transaction.
-   *
-   * NOTE: if the transaction is unsigned, this function will estimate the fee needed, supposing
-   * all signatures are added. However, this heuristic is only accurate for one signature. In
-   * addition, this fee calculation does not estimate the size of missing preimages.
-   *
-   * So, first, add missing preimages, and only then calc the fee. If you're building a multisig
-   * transaction, this value might be incorrect.
-   */
-  calcFee(): bigint;
-  /**
-   * Validate the transaction.
-   */
+  calcFee(): Nicks;
   validate(): void;
   allNotes(): TxNotes;
 }
-export class TxNotes {
-  private constructor();
-  free(): void;
-  [Symbol.dispose](): void;
-  readonly spendConditions: SpendCondition[];
-  readonly notes: Note[];
-}
-export class Version {
-  free(): void;
-  [Symbol.dispose](): void;
-  static V0(): Version;
-  static V1(): Version;
-  static V2(): Version;
-  constructor(version: number);
-}
 
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
   readonly memory: WebAssembly.Memory;
-  readonly __wbg_digest_free: (a: number, b: number) => void;
-  readonly __wbg_hax_free: (a: number, b: number) => void;
-  readonly __wbg_lockprimitive_free: (a: number, b: number) => void;
-  readonly __wbg_lockroot_free: (a: number, b: number) => void;
-  readonly __wbg_locktim_free: (a: number, b: number) => void;
-  readonly __wbg_name_free: (a: number, b: number) => void;
-  readonly __wbg_nockchaintx_free: (a: number, b: number) => void;
-  readonly __wbg_note_free: (a: number, b: number) => void;
-  readonly __wbg_notedata_free: (a: number, b: number) => void;
-  readonly __wbg_notedataentry_free: (a: number, b: number) => void;
-  readonly __wbg_pkh_free: (a: number, b: number) => void;
-  readonly __wbg_rawtx_free: (a: number, b: number) => void;
-  readonly __wbg_seed_free: (a: number, b: number) => void;
-  readonly __wbg_source_free: (a: number, b: number) => void;
+  readonly __wbg_extendedkey_free: (a: number, b: number) => void;
+  readonly __wbg_grpcclient_free: (a: number, b: number) => void;
+  readonly deriveMasterKey: (a: number, b: number) => number;
+  readonly deriveMasterKeyFromMnemonic: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly extendedkey_chainCode: (a: number) => [number, number];
+  readonly extendedkey_deriveChild: (a: number, b: number) => [number, number, number];
+  readonly extendedkey_privateKey: (a: number) => [number, number];
+  readonly extendedkey_publicKey: (a: number) => [number, number];
+  readonly grpcclient_getBalanceByAddress: (a: number, b: number, c: number) => any;
+  readonly grpcclient_getBalanceByFirstName: (a: number, b: number, c: number) => any;
+  readonly grpcclient_new: (a: number, b: number) => number;
+  readonly grpcclient_sendTransaction: (a: number, b: any) => any;
+  readonly grpcclient_transactionAccepted: (a: number, b: number, c: number) => any;
+  readonly hashNoun: (a: number, b: number) => [number, number, number, number];
+  readonly hashPublicKey: (a: number, b: number) => [number, number, number, number];
+  readonly hashU64: (a: bigint) => [number, number];
+  readonly signMessage: (a: number, b: number, c: number, d: number) => [number, number, number];
+  readonly verifySignature: (a: number, b: number, c: any, d: number, e: number) => [number, number, number];
+  readonly cue: (a: number, b: number) => [number, number, number];
+  readonly jam: (a: any) => [number, number, number, number];
   readonly __wbg_spendbuilder_free: (a: number, b: number) => void;
-  readonly __wbg_spendcondition_free: (a: number, b: number) => void;
-  readonly __wbg_timelockrange_free: (a: number, b: number) => void;
   readonly __wbg_txbuilder_free: (a: number, b: number) => void;
-  readonly __wbg_txnotes_free: (a: number, b: number) => void;
-  readonly __wbg_version_free: (a: number, b: number) => void;
-  readonly digest_fromProtobuf: (a: any) => [number, number, number];
-  readonly digest_new: (a: number, b: number) => number;
-  readonly digest_toProtobuf: (a: number) => [number, number, number];
-  readonly digest_value: (a: number) => [number, number];
-  readonly hax_digests: (a: number) => [number, number];
-  readonly hax_new: (a: number, b: number) => number;
-  readonly lockprimitive_fromProtobuf: (a: any) => [number, number, number];
-  readonly lockprimitive_newBrn: () => number;
-  readonly lockprimitive_newHax: (a: number) => number;
-  readonly lockprimitive_newPkh: (a: number) => number;
-  readonly lockprimitive_newTim: (a: number) => number;
-  readonly lockprimitive_toProtobuf: (a: number) => [number, number, number];
-  readonly lockroot_fromHash: (a: number) => [number, number, number];
-  readonly lockroot_fromSpendCondition: (a: number) => [number, number, number];
-  readonly lockroot_hash: (a: number) => number;
-  readonly lockroot_lock: (a: number) => number;
-  readonly locktim_abs: (a: number) => number;
-  readonly locktim_coinbase: () => number;
-  readonly locktim_fromProtobuf: (a: any) => [number, number, number];
-  readonly locktim_new: (a: number, b: number) => number;
-  readonly locktim_rel: (a: number) => number;
-  readonly locktim_toProtobuf: (a: number) => [number, number, number];
-  readonly name_first: (a: number) => [number, number];
-  readonly name_fromProtobuf: (a: any) => [number, number, number];
-  readonly name_last: (a: number) => [number, number];
-  readonly name_new: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly name_toProtobuf: (a: number) => [number, number, number];
-  readonly nockchaintx_fromJam: (a: number, b: number) => [number, number, number];
-  readonly nockchaintx_id: (a: number) => number;
-  readonly nockchaintx_name: (a: number) => [number, number];
-  readonly nockchaintx_outputs: (a: number) => [number, number];
-  readonly nockchaintx_toJam: (a: number) => any;
-  readonly nockchaintx_toRawTx: (a: number) => number;
-  readonly nockchaintx_version: (a: number) => number;
-  readonly note_assets: (a: number) => bigint;
-  readonly note_fromProtobuf: (a: any) => [number, number, number];
-  readonly note_hash: (a: number) => [number, number, number];
-  readonly note_name: (a: number) => number;
-  readonly note_new: (a: number, b: bigint, c: number, d: number, e: bigint) => number;
-  readonly note_noteData: (a: number) => number;
-  readonly note_originPage: (a: number) => bigint;
-  readonly note_toProtobuf: (a: number) => [number, number, number];
-  readonly note_version: (a: number) => number;
-  readonly notedata_empty: () => number;
-  readonly notedata_entries: (a: number) => [number, number];
-  readonly notedata_fromPkh: (a: number) => [number, number, number];
-  readonly notedata_fromProtobuf: (a: any) => [number, number, number];
-  readonly notedata_new: (a: number, b: number) => number;
-  readonly notedata_toProtobuf: (a: number) => [number, number, number];
-  readonly notedataentry_blob: (a: number) => [number, number];
-  readonly notedataentry_fromProtobuf: (a: any) => [number, number, number];
-  readonly notedataentry_key: (a: number) => [number, number];
-  readonly notedataentry_new: (a: number, b: number, c: number, d: number) => number;
-  readonly notedataentry_toProtobuf: (a: number) => [number, number, number];
-  readonly pkh_fromProtobuf: (a: any) => [number, number, number];
-  readonly pkh_hashes: (a: number) => [number, number];
-  readonly pkh_m: (a: number) => bigint;
-  readonly pkh_new: (a: bigint, b: number, c: number) => number;
-  readonly pkh_single: (a: number, b: number) => number;
-  readonly pkh_toProtobuf: (a: number) => [number, number, number];
-  readonly rawtx_fromJam: (a: number, b: number) => [number, number, number];
-  readonly rawtx_fromProtobuf: (a: any) => [number, number, number];
-  readonly rawtx_id: (a: number) => number;
-  readonly rawtx_name: (a: number) => [number, number];
-  readonly rawtx_outputs: (a: number) => [number, number];
-  readonly rawtx_toJam: (a: number) => any;
-  readonly rawtx_toNockchainTx: (a: number) => number;
-  readonly rawtx_toProtobuf: (a: number) => [number, number, number];
-  readonly rawtx_version: (a: number) => number;
-  readonly seed_gift: (a: number) => bigint;
-  readonly seed_lockRoot: (a: number) => number;
-  readonly seed_new: (a: number, b: number, c: bigint, d: number, e: number) => number;
-  readonly seed_newSinglePkh: (a: number, b: bigint, c: number, d: number) => [number, number, number];
-  readonly seed_noteData: (a: number) => number;
-  readonly seed_outputSource: (a: number) => number;
-  readonly seed_parentHash: (a: number) => number;
-  readonly seed_set_gift: (a: number, b: bigint) => void;
-  readonly seed_set_lockRoot: (a: number, b: number) => void;
-  readonly seed_set_noteData: (a: number, b: number) => void;
-  readonly seed_set_outputSource: (a: number, b: number) => void;
-  readonly seed_set_parentHash: (a: number, b: number) => void;
-  readonly source_hash: (a: number) => number;
-  readonly source_isCoinbase: (a: number) => number;
+  readonly create_note_v0: (a: number, b: bigint, c: number, d: number, e: any, f: number, g: number, h: any) => [number, number, number];
+  readonly create_note_v1: (a: any, b: number, c: any, d: any, e: any) => [number, number, number];
+  readonly digest_from_protobuf: (a: any) => [number, number, number];
+  readonly digest_to_hex: (a: any) => [number, number];
+  readonly digest_to_protobuf: (a: any) => any;
+  readonly hex_to_digest: (a: number, b: number) => [number, number, number];
+  readonly note_from_protobuf: (a: any) => [number, number, number];
+  readonly note_hash: (a: any) => any;
+  readonly note_to_protobuf: (a: any) => any;
   readonly spendbuilder_addPreimage: (a: number, b: number, c: number) => [number, number, number];
   readonly spendbuilder_computeRefund: (a: number, b: number) => void;
-  readonly spendbuilder_curRefund: (a: number) => number;
-  readonly spendbuilder_fee: (a: number, b: bigint) => void;
+  readonly spendbuilder_curRefund: (a: number) => any;
+  readonly spendbuilder_fee: (a: number, b: any) => void;
   readonly spendbuilder_invalidateSigs: (a: number) => void;
   readonly spendbuilder_isBalanced: (a: number) => number;
   readonly spendbuilder_missingUnlocks: (a: number) => [number, number, number, number];
-  readonly spendbuilder_new: (a: number, b: number, c: number) => [number, number, number];
-  readonly spendbuilder_seed: (a: number, b: number) => [number, number];
+  readonly spendbuilder_new: (a: any, b: number, c: number) => [number, number, number];
+  readonly spendbuilder_seed: (a: number, b: any) => [number, number];
   readonly spendbuilder_sign: (a: number, b: number, c: number) => [number, number, number];
-  readonly spendcondition_firstName: (a: number) => [number, number, number];
-  readonly spendcondition_fromProtobuf: (a: any) => [number, number, number];
-  readonly spendcondition_hash: (a: number) => [number, number, number];
-  readonly spendcondition_new: (a: number, b: number) => number;
-  readonly spendcondition_newPkh: (a: number) => number;
-  readonly spendcondition_toProtobuf: (a: number) => [number, number, number];
-  readonly timelockrange_max: (a: number) => [number, bigint];
-  readonly timelockrange_min: (a: number) => [number, bigint];
-  readonly timelockrange_new: (a: number, b: bigint, c: number, d: bigint) => number;
   readonly txbuilder_addPreimage: (a: number, b: number, c: number) => [number, number, number];
-  readonly txbuilder_allNotes: (a: number) => number;
+  readonly txbuilder_allNotes: (a: number) => [number, number, number];
   readonly txbuilder_allSpends: (a: number) => [number, number];
   readonly txbuilder_build: (a: number) => [number, number, number];
-  readonly txbuilder_calcFee: (a: number) => bigint;
-  readonly txbuilder_curFee: (a: number) => bigint;
-  readonly txbuilder_fromTx: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
-  readonly txbuilder_new: (a: bigint) => number;
+  readonly txbuilder_calcFee: (a: number) => any;
+  readonly txbuilder_curFee: (a: number) => any;
+  readonly txbuilder_fromTx: (a: any, b: number, c: number, d: number, e: number) => [number, number, number];
+  readonly txbuilder_new: (a: any) => number;
   readonly txbuilder_recalcAndSetFee: (a: number, b: number) => [number, number];
-  readonly txbuilder_setFeeAndBalanceRefund: (a: number, b: bigint, c: number, d: number) => [number, number];
+  readonly txbuilder_setFeeAndBalanceRefund: (a: number, b: any, c: number, d: number) => [number, number];
   readonly txbuilder_sign: (a: number, b: number, c: number) => [number, number];
-  readonly txbuilder_simpleSpend: (a: number, b: number, c: number, d: number, e: number, f: number, g: bigint, h: number, i: bigint, j: number, k: number) => [number, number];
+  readonly txbuilder_simpleSpend: (a: number, b: number, c: number, d: number, e: number, f: any, g: any, h: number, i: any, j: number) => [number, number];
   readonly txbuilder_spend: (a: number, b: number) => number;
   readonly txbuilder_validate: (a: number) => [number, number];
-  readonly txnotes_notes: (a: number) => [number, number];
-  readonly txnotes_spendConditions: (a: number) => [number, number];
-  readonly version_V0: () => number;
-  readonly version_V1: () => number;
-  readonly version_V2: () => number;
-  readonly wasmseed_fromProtobuf: (a: any) => [number, number, number];
-  readonly wasmseed_toProtobuf: (a: number) => [number, number, number];
-  readonly version_new: (a: number) => number;
-  readonly __wbg_grpcclient_free: (a: number, b: number) => void;
-  readonly __wbg_noun_free: (a: number, b: number) => void;
-  readonly grpcclient_getBalanceByAddress: (a: number, b: number, c: number) => any;
-  readonly grpcclient_getBalanceByFirstName: (a: number, b: number, c: number) => any;
-  readonly grpcclient_new: (a: number, b: number) => number;
-  readonly grpcclient_sendTransaction: (a: number, b: any) => any;
-  readonly grpcclient_transactionAccepted: (a: number, b: number, c: number) => any;
-  readonly noun_cue: (a: number, b: number) => [number, number, number];
-  readonly noun_fromJs: (a: any) => [number, number, number];
-  readonly noun_jam: (a: number) => [number, number, number, number];
-  readonly noun_toJs: (a: number) => [number, number, number];
-  readonly __wbg_extendedkey_free: (a: number, b: number) => void;
-  readonly __wbg_signature_free: (a: number, b: number) => void;
-  readonly deriveMasterKey: (a: number, b: number) => number;
-  readonly deriveMasterKeyFromMnemonic: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly extendedkey_chainCode: (a: number) => [number, number];
-  readonly extendedkey_deriveChild: (a: number, b: number) => [number, number, number];
-  readonly extendedkey_privateKey: (a: number) => [number, number];
-  readonly extendedkey_publicKey: (a: number) => [number, number];
-  readonly hashNoun: (a: number, b: number) => [number, number, number, number];
-  readonly hashPublicKey: (a: number, b: number) => [number, number, number, number];
-  readonly hashU64: (a: bigint) => [number, number];
-  readonly signMessage: (a: number, b: number, c: number, d: number) => [number, number, number];
-  readonly signature_c: (a: number) => [number, number];
-  readonly signature_new: (a: number, b: number, c: number, d: number) => number;
-  readonly signature_s: (a: number) => [number, number];
-  readonly verifySignature: (a: number, b: number, c: number, d: number, e: number) => [number, number, number];
   readonly __wbg_intounderlyingsource_free: (a: number, b: number) => void;
   readonly intounderlyingsource_cancel: (a: number) => void;
   readonly intounderlyingsource_pull: (a: number, b: any) => any;
@@ -659,8 +980,8 @@ export interface InitOutput {
   readonly __wbindgen_exn_store: (a: number) => void;
   readonly __externref_table_alloc: () => number;
   readonly __wbindgen_externrefs: WebAssembly.Table;
-  readonly __externref_table_dealloc: (a: number) => void;
   readonly __wbindgen_free: (a: number, b: number, c: number) => void;
+  readonly __externref_table_dealloc: (a: number) => void;
   readonly __externref_drop_slice: (a: number, b: number) => void;
   readonly __wbindgen_start: () => void;
 }
@@ -685,3 +1006,7 @@ export function initSync(module: { module: SyncInitInput } | SyncInitInput): Ini
 * @returns {Promise<InitOutput>}
 */
 export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;
+
+export type TxId = string;
+export type BlockHeight = number;
+export type LockTim = Timelock;