@miden-sdk/miden-sdk 0.13.0-next.1

package/dist/crates/miden_client_web.d.ts

@@ -0,0 +1,1826 @@
+/* tslint:disable */
+/* eslint-disable */
+export enum AccountInterface {
+  BasicWallet = 0,
+}
+export enum AccountType {
+  FungibleFaucet = 0,
+  NonFungibleFaucet = 1,
+  RegularAccountImmutableCode = 2,
+  RegularAccountUpdatableCode = 3,
+}
+export enum InputNoteState {
+  Expected = 0,
+  Unverified = 1,
+  Committed = 2,
+  Invalid = 3,
+  ProcessingAuthenticated = 4,
+  ProcessingUnauthenticated = 5,
+  ConsumedAuthenticatedLocal = 6,
+  ConsumedUnauthenticatedLocal = 7,
+  ConsumedExternal = 8,
+}
+export enum NetworkId {
+  Mainnet = 0,
+  Testnet = 1,
+  Devnet = 2,
+}
+export enum NoteFilterTypes {
+  All = 0,
+  Consumed = 1,
+  Committed = 2,
+  Expected = 3,
+  Processing = 4,
+  List = 5,
+  Unique = 6,
+  Nullifiers = 7,
+  Unverified = 8,
+}
+export enum NoteType {
+  /**
+   * Notes with this type have only their hash published to the network.
+   */
+  Private = 2,
+  /**
+   * Notes with this type are shared with the network encrypted.
+   */
+  Encrypted = 3,
+  /**
+   * Notes with this type are fully shared with the network.
+   */
+  Public = 1,
+}
+export enum SigningInputsType {
+  TransactionSummary = 0,
+  Arbitrary = 1,
+  Blind = 2,
+}
+/**
+ * Specifies which procedures an account accepts, and by extension which notes it can consume.
+ */
+type AddressInterface = "BasicWallet";
+/**
+ * The `ReadableStreamType` enum.
+ *
+ * *This API requires the following crate features to be activated: `ReadableStreamType`*
+ */
+type ReadableStreamType = "bytes";
+export class Account {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  id(): AccountId;
+  commitment(): Word;
+  nonce(): Felt;
+  vault(): AssetVault;
+  storage(): AccountStorage;
+  code(): AccountCode;
+  isFaucet(): boolean;
+  isRegularAccount(): boolean;
+  isUpdatable(): boolean;
+  isPublic(): boolean;
+  isPrivate(): boolean;
+  isNetwork(): boolean;
+  isNew(): boolean;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): Account;
+  getPublicKeys(): Word[];
+}
+export class AccountArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: Account[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): Account;
+  replaceAt(index: number, elem: Account): void;
+  push(element: Account): void;
+  length(): number;
+}
+export class AccountBuilder {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(init_seed: Uint8Array);
+  accountType(account_type: AccountType): AccountBuilder;
+  storageMode(storage_mode: AccountStorageMode): AccountBuilder;
+  withComponent(account_component: AccountComponent): AccountBuilder;
+  withAuthComponent(account_component: AccountComponent): AccountBuilder;
+  withNoAuthComponent(): AccountBuilder;
+  withBasicWalletComponent(): AccountBuilder;
+  build(): AccountBuilderResult;
+}
+export class AccountBuilderResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly account: Account;
+  readonly seed: Word;
+}
+export class AccountCode {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  commitment(): Word;
+  hasProcedure(mast_root: Word): boolean;
+}
+export class AccountComponent {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static compile(account_code: string, builder: ScriptBuilder, storage_slots: StorageSlot[]): AccountComponent;
+  withSupportsAllTypes(): AccountComponent;
+  getProcedureHash(procedure_name: string): string;
+  getProcedures(): GetProceduresResultItem[];
+  static createAuthComponent(secret_key: SecretKey): AccountComponent;
+  static createAuthComponentFromCommitment(commitment: Word, auth_scheme_id: number): AccountComponent;
+  static fromPackage(_package: Package, storage_slots: StorageSlotArray): AccountComponent;
+}
+export class AccountDelta {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): AccountDelta;
+  id(): AccountId;
+  isEmpty(): boolean;
+  storage(): AccountStorageDelta;
+  vault(): AccountVaultDelta;
+  nonceDelta(): Felt;
+}
+export class AccountFile {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Serializes the `AccountFile` into a byte array
+   */
+  serialize(): Uint8Array;
+  /**
+   * Deserializes a byte array into an `AccountFile`
+   */
+  static deserialize(bytes: Uint8Array): AccountFile;
+}
+export class AccountHeader {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  commitment(): Word;
+  id(): AccountId;
+  nonce(): Felt;
+  vaultCommitment(): Word;
+  storageCommitment(): Word;
+  codeCommitment(): Word;
+}
+export class AccountId {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromHex(hex: string): AccountId;
+  isFaucet(): boolean;
+  isRegularAccount(): boolean;
+  isPublic(): boolean;
+  isPrivate(): boolean;
+  isNetwork(): boolean;
+  toString(): string;
+  /**
+   * Will turn the Account ID into its bech32 string representation. To avoid a potential
+   * wrongful encoding, this function will expect only IDs for either mainnet ("mm"),
+   * testnet ("mtst") or devnet ("mdev"). To use a custom bech32 prefix, see
+   * `Self::to_bech_32_custom`.
+   */
+  toBech32(network_id: NetworkId, account_interface: AccountInterface): string;
+  /**
+   * Turn this Account ID into its bech32 string representation. This method accepts a custom
+   * network ID.
+   */
+  toBech32Custom(custom_network_id: string, account_interface: AccountInterface): string;
+  prefix(): Felt;
+  suffix(): Felt;
+}
+export class AccountIdArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: AccountId[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): AccountId;
+  replaceAt(index: number, elem: AccountId): void;
+  push(element: AccountId): void;
+  length(): number;
+}
+export class AccountStorage {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  commitment(): Word;
+  getItem(index: number): Word | undefined;
+  getMapItem(index: number, key: Word): Word | undefined;
+  /**
+   * Get all key-value pairs from the map slot at `index`.
+   * Returns `undefined` if the slot isn't a map or `index` is out of bounds (0-255).
+   * Returns `[]` if the map exists but is empty.
+   */
+  getMapEntries(index: number): JsStorageMapEntry[] | undefined;
+}
+export class AccountStorageDelta {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): AccountStorageDelta;
+  isEmpty(): boolean;
+  values(): Word[];
+}
+export class AccountStorageMode {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static private(): AccountStorageMode;
+  static public(): AccountStorageMode;
+  static network(): AccountStorageMode;
+  static tryFromStr(s: string): AccountStorageMode;
+  asStr(): string;
+}
+export class AccountStorageRequirements {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor();
+  static fromSlotAndKeysArray(slots_and_keys: SlotAndKeys[]): AccountStorageRequirements;
+}
+export class AccountVaultDelta {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): AccountVaultDelta;
+  isEmpty(): boolean;
+  fungible(): FungibleAssetDelta;
+  addedFungibleAssets(): FungibleAsset[];
+  removedFungibleAssets(): FungibleAsset[];
+}
+export class Address {
+  private constructor();
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromAccountId(account_id: AccountId, _interface?: string | null): Address;
+  static fromBech32(bech32: string): Address;
+  interface(): AddressInterface;
+  accountId(): AccountId;
+  toNoteTag(): NoteTag;
+  toBech32(network_id: NetworkId): string;
+}
+export class AdviceInputs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  stack(): Felt[];
+  mappedValues(key: Word): Felt[] | undefined;
+}
+export class AdviceMap {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor();
+  insert(key: Word, value: FeltArray): Felt[] | undefined;
+}
+export class AssetVault {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  root(): Word;
+  getBalance(faucet_id: AccountId): bigint;
+  fungibleAssets(): FungibleAsset[];
+}
+export class AuthSecretKey {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  getRpoFalcon512PublicKeyAsWord(): Word;
+  getRpoFalcon512SecretKeyAsFelts(): Felt[];
+  getEcdsaK256KeccakPublicKeyAsWord(): Word;
+  getEcdsaK256KeccakSecretKeyAsFelts(): Felt[];
+}
+export class BasicFungibleFaucetComponent {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromAccount(account: Account): BasicFungibleFaucetComponent;
+  symbol(): TokenSymbol;
+  decimals(): number;
+  maxSupply(): Felt;
+}
+export class BlockHeader {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  version(): number;
+  commitment(): Word;
+  subCommitment(): Word;
+  prevBlockCommitment(): Word;
+  blockNum(): number;
+  chainCommitment(): Word;
+  accountRoot(): Word;
+  nullifierRoot(): Word;
+  noteRoot(): Word;
+  txCommitment(): Word;
+  txKernelCommitment(): Word;
+  proofCommitment(): Word;
+  timestamp(): number;
+}
+export class ConsumableNoteRecord {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(input_note_record: InputNoteRecord, note_consumability: NoteConsumability[]);
+  inputNoteRecord(): InputNoteRecord;
+  noteConsumability(): NoteConsumability[];
+}
+/**
+ * Represents a network endpoint for connecting to Miden nodes.
+ *
+ * An endpoint consists of a protocol (http/https), host, and optional port.
+ * Provides convenient constructors for common network configurations.
+ */
+export class Endpoint {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Creates an endpoint from a URL string.
+   *
+   * @param url - The URL string (e.g., <https://localhost:57291>)
+   * @throws throws an error if the URL is invalid
+   */
+  constructor(url: string);
+  /**
+   * Returns the endpoint for the Miden testnet.
+   */
+  static testnet(): Endpoint;
+  /**
+   * Returns the endpoint for the Miden devnet.
+   */
+  static devnet(): Endpoint;
+  /**
+   * Returns the endpoint for a local Miden node.
+   *
+   * Uses <http://localhost:57291>
+   */
+  static localhost(): Endpoint;
+  /**
+   * Returns the string representation of the endpoint.
+   */
+  toString(): string;
+  /**
+   * Returns the protocol of the endpoint.
+   */
+  readonly protocol: string;
+  /**
+   * Returns the host of the endpoint.
+   */
+  readonly host: string;
+  /**
+   * Returns the port of the endpoint.
+   */
+  readonly port: number | undefined;
+}
+export class ExecutedTransaction {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  id(): TransactionId;
+  accountId(): AccountId;
+  initialAccountHeader(): AccountHeader;
+  finalAccountHeader(): AccountHeader;
+  inputNotes(): InputNotes;
+  outputNotes(): OutputNotes;
+  txArgs(): TransactionArgs;
+  blockHeader(): BlockHeader;
+  accountDelta(): AccountDelta;
+}
+export class Felt {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(value: bigint);
+  asInt(): bigint;
+  toString(): string;
+}
+export class FeltArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: Felt[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): Felt;
+  replaceAt(index: number, elem: Felt): void;
+  push(element: Felt): void;
+  length(): number;
+}
+/**
+ * Represents a note fetched from a Miden node via RPC.
+ */
+export class FetchedNote {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Create a note with an optional `InputNote`.
+   */
+  constructor(note_id: NoteId, metadata: NoteMetadata, input_note?: InputNote | null);
+  /**
+   * The unique identifier of the note.
+   */
+  readonly noteId: NoteId;
+  /**
+   * The note's metadata, including sender, tag, and other properties.
+   * Available for both private and public notes.
+   */
+  readonly metadata: NoteMetadata;
+  /**
+   * The full [`InputNote`] with inclusion proof.
+   *
+   * For public notes, it contains the complete note data and inclusion proof.
+   * For private notes, it will be ``None`.
+   */
+  readonly inputNote: InputNote | undefined;
+  readonly noteType: NoteType;
+}
+export class FlattenedU8Vec {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  data(): Uint8Array;
+  lengths(): Uint32Array;
+  num_inner_vecs(): number;
+}
+export class ForeignAccount {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static public(account_id: AccountId, storage_requirements: AccountStorageRequirements): ForeignAccount;
+  storage_slot_requirements(): AccountStorageRequirements;
+  account_id(): AccountId;
+}
+export class ForeignAccountArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: ForeignAccount[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): ForeignAccount;
+  replaceAt(index: number, elem: ForeignAccount): void;
+  push(element: ForeignAccount): void;
+  length(): number;
+}
+export class FungibleAsset {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(faucet_id: AccountId, amount: bigint);
+  faucetId(): AccountId;
+  amount(): bigint;
+  intoWord(): Word;
+}
+export class FungibleAssetDelta {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): FungibleAssetDelta;
+  isEmpty(): boolean;
+  amount(faucet_id: AccountId): bigint | undefined;
+  numAssets(): number;
+  assets(): FungibleAssetDeltaItem[];
+}
+export class FungibleAssetDeltaItem {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly faucetId: AccountId;
+  readonly amount: bigint;
+}
+export class GetProceduresResultItem {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly digest: Word;
+  readonly isAuth: boolean;
+}
+export class InputNote {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  id(): NoteId;
+  note(): Note;
+  commitment(): Word;
+  proof(): NoteInclusionProof | undefined;
+  location(): NoteLocation | undefined;
+}
+export class InputNoteRecord {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  id(): NoteId;
+  state(): InputNoteState;
+  details(): NoteDetails;
+  metadata(): NoteMetadata | undefined;
+  commitment(): Word | undefined;
+  inclusionProof(): NoteInclusionProof | undefined;
+  consumerTransactionId(): string | undefined;
+  nullifier(): string;
+  isAuthenticated(): boolean;
+  isConsumed(): boolean;
+  isProcessing(): boolean;
+  toInputNote(): InputNote;
+}
+export class InputNotes {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  commitment(): Word;
+  numNotes(): number;
+  isEmpty(): boolean;
+  getNote(index: number): InputNote;
+  notes(): InputNote[];
+}
+export class IntoUnderlyingByteSource {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  start(controller: ReadableByteStreamController): void;
+  pull(controller: ReadableByteStreamController): Promise<any>;
+  cancel(): void;
+  readonly type: ReadableStreamType;
+  readonly autoAllocateChunkSize: number;
+}
+export class IntoUnderlyingSink {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  write(chunk: any): Promise<any>;
+  close(): Promise<any>;
+  abort(reason: any): Promise<any>;
+}
+export class IntoUnderlyingSource {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  pull(controller: ReadableStreamDefaultController): Promise<any>;
+  cancel(): void;
+}
+/**
+ * Represents an update to a single account's state.
+ */
+export class JsAccountUpdate {
+  private constructor();
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * The merkle root of the account's storage trie.
+   */
+  storageRoot: string;
+  /**
+   * Serialized storage slot data for this account.
+   */
+  storageSlots: JsStorageSlot[];
+  /**
+   * Serialized storage map entries for this account.
+   */
+  storageMapEntries: JsStorageMapEntry[];
+  /**
+   * The merkle root of the account's asset vault.
+   */
+  assetVaultRoot: string;
+  /**
+   * The account's asset vault.
+   */
+  assets: JsVaultAsset[];
+  /**
+   * ID for this account.
+   */
+  accountId: string;
+  /**
+   * The merkle root of the account's executable code.
+   */
+  codeRoot: string;
+  /**
+   * Whether this account update has been committed.
+   */
+  committed: boolean;
+  /**
+   * The account's transaction nonce as a string.
+   */
+  nonce: string;
+  /**
+   * The cryptographic commitment representing this account's current state.
+   */
+  accountCommitment: string;
+  /**
+   * Optional seed data for the account.
+   */
+  get accountSeed(): Uint8Array | undefined;
+  /**
+   * Optional seed data for the account.
+   */
+  set accountSeed(value: Uint8Array | null | undefined);
+}
+/**
+ * An object that contains data for a sync update,
+ * which will be received by the applyStateSync JS function.
+ * under sync.js
+ */
+export class JsStateSyncUpdate {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * The block number for this update, stored as a string since it will be
+   * persisted in `IndexedDB`.
+   */
+  blockNum: string;
+  /**
+   * The new block headers for this state update, serialized into a flattened byte array.
+   */
+  flattenedNewBlockHeaders: FlattenedU8Vec;
+  /**
+   * The block numbers corresponding to each header in `flattened_new_block_headers`.
+   * This vec should have the same length as the number of headers, with each index
+   * representing the block number for the header at that same index.
+   */
+  newBlockNums: string[];
+  /**
+   * Flattened byte array containing partial blockchain peaks used for merkle tree
+   * verification.
+   */
+  flattenedPartialBlockChainPeaks: FlattenedU8Vec;
+  /**
+   * For each block in this update, stores a boolean (as u8) indicating whether
+   * that block contains notes relevant to this client. Index i corresponds to
+   * the ith block, with 1 meaning relevant and 0 meaning not relevant.
+   */
+  blockHasRelevantNotes: Uint8Array;
+  /**
+   * Serialized IDs for new authentication nodes required to verify block headers.
+   */
+  serializedNodeIds: string[];
+  /**
+   * The actual authentication node data corresponding to the IDs above.
+   */
+  serializedNodes: string[];
+  /**
+   * IDs of note tags that should be removed from the client's local state.
+   */
+  committedNoteIds: string[];
+  /**
+   * Input notes for this state update in serialized form.
+   */
+  serializedInputNotes: SerializedInputNoteData[];
+  /**
+   * Output notes created in this state update in serialized form.
+   */
+  serializedOutputNotes: SerializedOutputNoteData[];
+  /**
+   * Account state updates included in this sync.
+   */
+  accountUpdates: JsAccountUpdate[];
+  /**
+   * Transaction data for transactions included in this update.
+   */
+  transactionUpdates: SerializedTransactionData[];
+}
+/**
+ * A JavaScript representation of a storage map entry in an account.
+ */
+export class JsStorageMapEntry {
+  private constructor();
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * The root of the storage map entry.
+   */
+  root: string;
+  /**
+   * The key of the storage map entry.
+   */
+  key: string;
+  /**
+   * The value of the storage map entry.
+   */
+  value: string;
+}
+/**
+ * A JavaScript representation of a storage slot in an account.
+ */
+export class JsStorageSlot {
+  private constructor();
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Commitment of the whole account storage
+   */
+  commitment: string;
+  /**
+   * The index of the storage slot.
+   */
+  slotIndex: number;
+  /**
+   * The value stored in the storage slot.
+   */
+  slotValue: string;
+  /**
+   * The type of the storage slot.
+   */
+  slotType: number;
+}
+/**
+ * An object that contains a serialized vault asset
+ */
+export class JsVaultAsset {
+  private constructor();
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * The merkle root of the vault's assets.
+   */
+  root: string;
+  /**
+   * The vault key associated with the asset.
+   */
+  vaultKey: string;
+  /**
+   * Asset's faucet ID prefix.
+   */
+  faucetIdPrefix: string;
+  /**
+   * Word representing the asset.
+   */
+  asset: string;
+}
+export class Library {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+export class MerklePath {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  depth(): number;
+  nodes(): Word[];
+  computeRoot(index: bigint, node: Word): Word;
+  verify(index: bigint, node: Word, root: Word): boolean;
+}
+export class Note {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(note_assets: NoteAssets, note_metadata: NoteMetadata, note_recipient: NoteRecipient);
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): Note;
+  id(): NoteId;
+  commitment(): Word;
+  metadata(): NoteMetadata;
+  recipient(): NoteRecipient;
+  assets(): NoteAssets;
+  script(): NoteScript;
+  static createP2IDNote(sender: AccountId, target: AccountId, assets: NoteAssets, note_type: NoteType, aux: Felt): Note;
+  static createP2IDENote(sender: AccountId, target: AccountId, assets: NoteAssets, reclaim_height: number | null | undefined, timelock_height: number | null | undefined, note_type: NoteType, aux: Felt): Note;
+}
+export class NoteAndArgs {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(note: Note, args?: Word | null);
+}
+export class NoteAndArgsArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: NoteAndArgs[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): NoteAndArgs;
+  replaceAt(index: number, elem: NoteAndArgs): void;
+  push(element: NoteAndArgs): void;
+  length(): number;
+}
+export class NoteAssets {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(assets_array?: FungibleAsset[] | null);
+  push(asset: FungibleAsset): void;
+  fungibleAssets(): FungibleAsset[];
+}
+export class NoteConsumability {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  accountId(): AccountId;
+  consumableAfterBlock(): number | undefined;
+}
+export class NoteDetails {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(note_assets: NoteAssets, note_recipient: NoteRecipient);
+  id(): NoteId;
+  assets(): NoteAssets;
+  recipient(): NoteRecipient;
+}
+export class NoteDetailsAndTag {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(note_details: NoteDetails, tag: NoteTag);
+  readonly noteDetails: NoteDetails;
+  readonly tag: NoteTag;
+}
+export class NoteDetailsAndTagArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: NoteDetailsAndTag[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): NoteDetailsAndTag;
+  replaceAt(index: number, elem: NoteDetailsAndTag): void;
+  push(element: NoteDetailsAndTag): void;
+  length(): number;
+}
+export class NoteExecutionHint {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static none(): NoteExecutionHint;
+  static always(): NoteExecutionHint;
+  static afterBlock(block_num: number): NoteExecutionHint;
+  static onBlockSlot(epoch_len: number, slot_len: number, slot_offset: number): NoteExecutionHint;
+  static fromParts(tag: number, payload: number): NoteExecutionHint;
+  canBeConsumed(block_num: number): boolean;
+}
+export class NoteExecutionMode {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static newLocal(): NoteExecutionMode;
+  static newNetwork(): NoteExecutionMode;
+  toString(): string;
+}
+/**
+ * A serialized representation of a note.
+ */
+export class NoteFile {
+  private constructor();
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns this `NoteFile`'s types.
+   */
+  noteType(): string;
+  /**
+   * Turn a notefile into its byte representation.
+   */
+  serialize(): Uint8Array;
+  /**
+   * Given a valid byte representation of a `NoteFile`,
+   * return it as a struct.
+   */
+  static deserialize(bytes: Uint8Array): NoteFile;
+  static fromInputNote(note: InputNote): NoteFile;
+  static fromOutputNote(note: OutputNote): NoteFile;
+  static fromNoteDetails(note_details: NoteDetails): NoteFile;
+  static fromNoteId(note_details: NoteId): NoteFile;
+}
+export class NoteFilter {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(note_type: NoteFilterTypes, note_ids?: NoteId[] | null);
+}
+export class NoteHeader {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  id(): NoteId;
+  metadata(): NoteMetadata;
+  commitment(): Word;
+}
+export class NoteId {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(recipient_digest: Word, asset_commitment_digest: Word);
+  static fromHex(hex: string): NoteId;
+  toString(): string;
+}
+export class NoteIdAndArgs {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(note_id: NoteId, args?: Word | null);
+}
+export class NoteIdAndArgsArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: NoteIdAndArgs[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): NoteIdAndArgs;
+  replaceAt(index: number, elem: NoteIdAndArgs): void;
+  push(element: NoteIdAndArgs): void;
+  length(): number;
+}
+export class NoteInclusionProof {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  location(): NoteLocation;
+  notePath(): MerklePath;
+}
+export class NoteInputs {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(felt_array: FeltArray);
+  values(): Felt[];
+}
+export class NoteLocation {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  blockNum(): number;
+  nodeIndexInBlock(): number;
+}
+export class NoteMetadata {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(sender: AccountId, note_type: NoteType, note_tag: NoteTag, note_execution_hint: NoteExecutionHint, aux?: Felt | null);
+  sender(): AccountId;
+  tag(): NoteTag;
+  noteType(): NoteType;
+}
+export class NoteRecipient {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(serial_num: Word, note_script: NoteScript, inputs: NoteInputs);
+  digest(): Word;
+  serialNum(): Word;
+  script(): NoteScript;
+  inputs(): NoteInputs;
+}
+export class NoteRecipientArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: NoteRecipient[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): NoteRecipient;
+  replaceAt(index: number, elem: NoteRecipient): void;
+  push(element: NoteRecipient): void;
+  length(): number;
+}
+export class NoteScript {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Print the MAST source for this script.
+   */
+  toString(): string;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): NoteScript;
+  static p2id(): NoteScript;
+  static p2ide(): NoteScript;
+  static swap(): NoteScript;
+  root(): Word;
+  /**
+   * Creates a `NoteScript` from the given `Package`.
+   * Throws if the package is invalid.
+   */
+  static fromPackage(_package: Package): NoteScript;
+}
+export class NoteTag {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromAccountId(account_id: AccountId): NoteTag;
+  static forPublicUseCase(use_case_id: number, payload: number, execution: NoteExecutionMode): NoteTag;
+  static forLocalUseCase(use_case_id: number, payload: number): NoteTag;
+  isSingleTarget(): boolean;
+  executionMode(): NoteExecutionMode;
+  asU32(): number;
+}
+export class OutputNote {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static full(note: Note): OutputNote;
+  static partial(partial_note: PartialNote): OutputNote;
+  static header(note_header: NoteHeader): OutputNote;
+  assets(): NoteAssets | undefined;
+  id(): NoteId;
+  recipientDigest(): Word | undefined;
+  metadata(): NoteMetadata;
+  shrink(): OutputNote;
+  intoFull(): Note | undefined;
+}
+export class OutputNoteArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: OutputNote[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): OutputNote;
+  replaceAt(index: number, elem: OutputNote): void;
+  push(element: OutputNote): void;
+  length(): number;
+}
+export class OutputNotes {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  commitment(): Word;
+  numNotes(): number;
+  isEmpty(): boolean;
+  getNote(index: number): OutputNote;
+  notes(): OutputNote[];
+}
+export class OutputNotesArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: OutputNotes[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): OutputNotes;
+  replaceAt(index: number, elem: OutputNotes): void;
+  push(element: OutputNotes): void;
+  length(): number;
+}
+export class Package {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): Package;
+  /**
+   * Returns the underlying library of a `Package`.
+   * Fails if the package is not a library.
+   */
+  asLibrary(): Library;
+  /**
+   * Returns the underlying program of a `Package`.
+   * Fails if the package is not a program.
+   */
+  asProgram(): Program;
+}
+export class PartialNote {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  id(): NoteId;
+  metadata(): NoteMetadata;
+  recipientDigest(): Word;
+  assets(): NoteAssets;
+}
+export class Program {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+}
+/**
+ * WASM wrapper around the native [`ProvenTransaction`].
+ */
+export class ProvenTransaction {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Serializes the proven transaction into bytes.
+   */
+  serialize(): Uint8Array;
+  /**
+   * Deserializes a proven transaction from bytes.
+   */
+  static deserialize(bytes: Uint8Array): ProvenTransaction;
+  /**
+   * Returns the transaction ID.
+   */
+  id(): TransactionId;
+  /**
+   * Returns the account ID the transaction was executed against.
+   */
+  accountId(): AccountId;
+  /**
+   * Returns the reference block number used during execution.
+   */
+  refBlockNumber(): number;
+  /**
+   * Returns the block number at which the transaction expires.
+   */
+  expirationBlockNumber(): number;
+  /**
+   * Returns notes created by this transaction.
+   */
+  outputNotes(): OutputNotes;
+  /**
+   * Returns the commitment of the reference block.
+   */
+  refBlockCommitment(): Word;
+  /**
+   * Returns the nullifiers of the consumed input notes.
+   */
+  nullifiers(): Word[];
+}
+export class PublicKey {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): PublicKey;
+  verify(message: Word, signature: Signature): boolean;
+  toCommitment(): Word;
+  static recoverFrom(message: Word, signature: Signature): PublicKey;
+  verifyData(signing_inputs: SigningInputs, signature: Signature): boolean;
+}
+/**
+ * RPC Client for interacting with Miden nodes directly.
+ */
+export class RpcClient {
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Creates a new RPC client instance.
+   *
+   * @param endpoint - Endpoint to connect to.
+   */
+  constructor(endpoint: Endpoint);
+  /**
+   * Fetches notes by their IDs from the connected Miden node.
+   *
+   * @param note_ids - Array of [`NoteId`] objects to fetch
+   * @returns Promise that resolves to  different data depending on the note type:
+   * - Private notes: Returns only `note_id` and `metadata`. The `input_note` field will be
+   *   `null`.
+   * - Public notes: Returns the full `input_note` with inclusion proof, alongside metadata and
+   *   ID.
+   */
+  getNotesById(note_ids: NoteId[]): Promise<FetchedNote[]>;
+  /**
+   * Fetches a note script by its root hash from the connected Miden node.
+   *
+   * @param `script_root` The root hash of the note script to fetch
+   * @returns Promise that resolves to the `NoteScript`
+   */
+  getNoteScriptByRoot(script_root: Word): Promise<NoteScript>;
+}
+export class Rpo256 {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static hashElements(felt_array: FeltArray): Word;
+}
+export class ScriptBuilder {
+  private constructor();
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Given a module path (something like `my_lib::module`) and source code, this will
+   * statically link it for use with scripts to be built with this builder.
+   */
+  linkModule(module_path: string, module_code: string): void;
+  /**
+   * Statically links the given library.
+   *
+   * Static linking means the library code is copied into the script code.
+   * Use this for most libraries that are not available on-chain.
+   *
+   * Receives as argument the library to link.
+   */
+  linkStaticLibrary(library: Library): void;
+  /**
+   * This is useful to dynamically link the [`Library`] of a foreign account
+   * that is invoked using foreign procedure invocation (FPI). Its code is available
+   * on-chain and so it does not have to be copied into the script code.
+   *
+   * For all other use cases not involving FPI, link the library statically.
+   * Receives as argument the library to be linked.
+   */
+  linkDynamicLibrary(library: Library): void;
+  /**
+   * Given a Transaction Script's source code, compiles it with the available
+   * modules under this builder. Returns the compiled script.
+   */
+  compileTxScript(tx_script: string): TransactionScript;
+  /**
+   * Given a Note Script's source code, compiles it with the available
+   * modules under this builder. Returns the compiled script.
+   */
+  compileNoteScript(program: string): NoteScript;
+  /**
+   * Given a Library Path, and a source code, turn it into a Library.
+   * E.g. A path library can be `miden::my_contract`. When turned into a library,
+   * this can be used from another script with an import statement, following the
+   * previous example: `use.miden::my_contract'.
+   */
+  buildLibrary(library_path: string, source_code: string): Library;
+}
+export class SecretKey {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static rpoFalconWithRNG(seed?: Uint8Array | null): SecretKey;
+  static ecdsaWithRNG(seed?: Uint8Array | null): SecretKey;
+  publicKey(): PublicKey;
+  sign(message: Word): Signature;
+  signData(signing_inputs: SigningInputs): Signature;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): SecretKey;
+}
+export class SerializedInputNoteData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  noteId: string;
+  noteAssets: Uint8Array;
+  serialNumber: Uint8Array;
+  inputs: Uint8Array;
+  noteScriptRoot: string;
+  noteScript: Uint8Array;
+  nullifier: string;
+  stateDiscriminant: number;
+  state: Uint8Array;
+  createdAt: string;
+}
+export class SerializedOutputNoteData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  noteId: string;
+  noteAssets: Uint8Array;
+  recipientDigest: string;
+  metadata: Uint8Array;
+  get nullifier(): string | undefined;
+  set nullifier(value: string | null | undefined);
+  expectedHeight: number;
+  stateDiscriminant: number;
+  state: Uint8Array;
+}
+export class SerializedTransactionData {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  id: string;
+  details: Uint8Array;
+  get scriptRoot(): Uint8Array | undefined;
+  set scriptRoot(value: Uint8Array | null | undefined);
+  get txScript(): Uint8Array | undefined;
+  set txScript(value: Uint8Array | null | undefined);
+  blockNum: string;
+  statusVariant: number;
+  status: Uint8Array;
+}
+export class Signature {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): Signature;
+  toPreparedSignature(message: Word): Felt[];
+}
+export class SigningInputs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static newTransactionSummary(summary: TransactionSummary): SigningInputs;
+  static newArbitrary(felts: Felt[]): SigningInputs;
+  static newBlind(word: Word): SigningInputs;
+  transactionSummaryPayload(): TransactionSummary;
+  arbitraryPayload(): FeltArray;
+  blindPayload(): Word;
+  toCommitment(): Word;
+  toElements(): FeltArray;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): SigningInputs;
+  readonly variantType: SigningInputsType;
+}
+export class SlotAndKeys {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(storage_slot_index: number, storage_map_keys: Word[]);
+  storage_slot_index(): number;
+  storage_map_keys(): Word[];
+}
+export class StorageMap {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor();
+  insert(key: Word, value: Word): Word;
+}
+export class StorageSlot {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static fromValue(value: Word): StorageSlot;
+  static emptyValue(): StorageSlot;
+  static map(storage_map: StorageMap): StorageSlot;
+}
+export class StorageSlotArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: StorageSlot[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): StorageSlot;
+  replaceAt(index: number, elem: StorageSlot): void;
+  push(element: StorageSlot): void;
+  length(): number;
+}
+export class SyncSummary {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  blockNum(): number;
+  committedNotes(): NoteId[];
+  consumedNotes(): NoteId[];
+  updatedAccounts(): AccountId[];
+  committedTransactions(): TransactionId[];
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): SyncSummary;
+}
+export class TestUtils {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static createMockAccountId(): AccountId;
+  static createMockSerializedLibraryPackage(): Uint8Array;
+  static createMockSerializedProgramPackage(): Uint8Array;
+}
+export class TokenSymbol {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(symbol: string);
+  toString(): string;
+}
+export class TransactionArgs {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  txScript(): TransactionScript | undefined;
+  getNoteArgs(note_id: NoteId): Word | undefined;
+  adviceInputs(): AdviceInputs;
+}
+export class TransactionFilter {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static all(): TransactionFilter;
+  static ids(ids: TransactionId[]): TransactionFilter;
+  static uncommitted(): TransactionFilter;
+  static expiredBefore(block_num: number): TransactionFilter;
+}
+export class TransactionId {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  asElements(): Felt[];
+  asBytes(): Uint8Array;
+  toHex(): string;
+  inner(): Word;
+}
+export class TransactionProver {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static newLocalProver(): TransactionProver;
+  static newRemoteProver(endpoint: string): TransactionProver;
+  serialize(): string;
+  static deserialize(prover_type: string, endpoint?: string | null): TransactionProver;
+  endpoint(): string | undefined;
+}
+export class TransactionRecord {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  id(): TransactionId;
+  accountId(): AccountId;
+  initAccountState(): Word;
+  finalAccountState(): Word;
+  inputNoteNullifiers(): Word[];
+  outputNotes(): OutputNotes;
+  blockNum(): number;
+  transactionStatus(): TransactionStatus;
+  creationTimestamp(): bigint;
+}
+export class TransactionRequest {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): TransactionRequest;
+  expectedOutputOwnNotes(): Note[];
+  expectedFutureNotes(): NoteDetailsAndTag[];
+  scriptArg(): Word | undefined;
+  authArg(): Word | undefined;
+}
+export class TransactionRequestBuilder {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor();
+  withUnauthenticatedInputNotes(notes: NoteAndArgsArray): TransactionRequestBuilder;
+  withAuthenticatedInputNotes(notes: NoteIdAndArgsArray): TransactionRequestBuilder;
+  withOwnOutputNotes(notes: OutputNoteArray): TransactionRequestBuilder;
+  withCustomScript(script: TransactionScript): TransactionRequestBuilder;
+  withExpectedOutputRecipients(recipients: NoteRecipientArray): TransactionRequestBuilder;
+  withExpectedFutureNotes(note_details_and_tag: NoteDetailsAndTagArray): TransactionRequestBuilder;
+  extendAdviceMap(advice_map: AdviceMap): TransactionRequestBuilder;
+  withForeignAccounts(foreign_accounts: ForeignAccountArray): TransactionRequestBuilder;
+  withScriptArg(script_arg: Word): TransactionRequestBuilder;
+  withAuthArg(auth_arg: Word): TransactionRequestBuilder;
+  build(): TransactionRequest;
+}
+/**
+ * WASM wrapper around the native [`TransactionResult`].
+ */
+export class TransactionResult {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  /**
+   * Returns the ID of the transaction.
+   */
+  id(): TransactionId;
+  /**
+   * Returns the executed transaction.
+   */
+  executedTransaction(): ExecutedTransaction;
+  /**
+   * Returns notes that are expected to be created as a result of follow-up executions.
+   */
+  futureNotes(): NoteDetailsAndTag[];
+  /**
+   * Serializes the transaction result into bytes.
+   */
+  serialize(): Uint8Array;
+  /**
+   * Deserializes a transaction result from bytes.
+   */
+  static deserialize(bytes: Uint8Array): TransactionResult;
+}
+export class TransactionScript {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  root(): Word;
+  /**
+   * Creates a `NoteScript` from the given `Package`.
+   * Throws if the package is invalid.
+   */
+  static fromPackage(_package: Package): TransactionScript;
+}
+export class TransactionScriptInputPair {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(word: Word, felts: FeltArray);
+  word(): Word;
+  felts(): FeltArray;
+}
+export class TransactionScriptInputPairArray {
+/**
+** Return copy of self without private attributes.
+*/
+  toJSON(): Object;
+/**
+* Return stringified version of self.
+*/
+  toString(): string;
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(elements?: TransactionScriptInputPair[] | null);
+  /**
+   * Get element at index, will always return a clone to avoid aliasing issues.
+   */
+  get(index: number): TransactionScriptInputPair;
+  replaceAt(index: number, elem: TransactionScriptInputPair): void;
+  push(element: TransactionScriptInputPair): void;
+  length(): number;
+}
+export class TransactionStatus {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  static pending(): TransactionStatus;
+  static committed(block_num: number, commit_timestamp: bigint): TransactionStatus;
+  static discarded(cause: string): TransactionStatus;
+  isPending(): boolean;
+  isCommitted(): boolean;
+  isDiscarded(): boolean;
+  getBlockNum(): number | undefined;
+  getCommitTimestamp(): bigint | undefined;
+}
+export class TransactionStoreUpdate {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  executedTransaction(): ExecutedTransaction;
+  submissionHeight(): number;
+  createdNotes(): OutputNotes;
+  accountDelta(): AccountDelta;
+  futureNotes(): NoteDetailsAndTag[];
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): TransactionStoreUpdate;
+}
+export class TransactionSummary {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): TransactionSummary;
+  accountDelta(): AccountDelta;
+  inputNotes(): InputNotes;
+  outputNotes(): OutputNotes;
+  salt(): Word;
+}
+export class WebClient {
+  free(): void;
+  [Symbol.dispose](): void;
+  getAccounts(): Promise<AccountHeader[]>;
+  getAccount(account_id: AccountId): Promise<Account | undefined>;
+  getAccountAuthByPubKey(pub_key: Word): Promise<AuthSecretKey>;
+  insertAccountAddress(account_id: AccountId, address: Address): Promise<void>;
+  removeAccountAddress(account_id: AccountId, address: Address): Promise<void>;
+  exportNoteFile(note_id: string, export_type: string): Promise<NoteFile>;
+  /**
+   * Retrieves the entire underlying web store and returns it as a `JsValue`
+   *
+   * Meant to be used in conjunction with the `force_import_store` method
+   */
+  exportStore(): Promise<any>;
+  exportAccountFile(account_id: AccountId): Promise<AccountFile>;
+  importAccountFile(account_file: AccountFile): Promise<any>;
+  importPublicAccountFromSeed(init_seed: Uint8Array, mutable: boolean, auth_scheme_id: number): Promise<Account>;
+  importAccountById(account_id: AccountId): Promise<any>;
+  importNoteFile(note_file: NoteFile): Promise<NoteId>;
+  forceImportStore(store_dump: any): Promise<any>;
+  /**
+   * Creates a new client with a mock RPC API. Useful for testing purposes and proof-of-concept
+   * applications as it uses a mock chain that simulates the behavior of a real node.
+   */
+  createMockClient(seed?: Uint8Array | null, serialized_mock_chain?: Uint8Array | null, serialized_mock_note_transport_node?: Uint8Array | null): Promise<any>;
+  /**
+   * Returns the inner serialized mock chain if it exists.
+   */
+  serializeMockChain(): Uint8Array;
+  /**
+   * Returns the inner serialized mock note transport node if it exists.
+   */
+  serializeMockNoteTransportNode(): Uint8Array;
+  proveBlock(): void;
+  usesMockChain(): boolean;
+  newWallet(storage_mode: AccountStorageMode, mutable: boolean, auth_scheme_id: number, init_seed?: Uint8Array | null): Promise<Account>;
+  newFaucet(storage_mode: AccountStorageMode, non_fungible: boolean, token_symbol: string, decimals: number, max_supply: bigint, auth_scheme_id: number): Promise<Account>;
+  newAccount(account: Account, overwrite: boolean): Promise<void>;
+  addAccountSecretKeyToWebStore(secret_key: SecretKey): Promise<void>;
+  /**
+   * Executes a transaction specified by the request against the specified account,
+   * proves it, submits it to the network, and updates the local database.
+   *
+   * If the transaction utilizes foreign account data, there is a chance that the client doesn't
+   * have the required block header in the local database. In these scenarios, a sync to
+   * the chain tip is performed, and the required block header is retrieved.
+   */
+  submitNewTransaction(account_id: AccountId, transaction_request: TransactionRequest): Promise<TransactionId>;
+  /**
+   * Executes a transaction specified by the request against the specified account but does not
+   * submit it to the network nor update the local database. The returned [`TransactionResult`]
+   * retains the execution artifacts needed to continue with the transaction lifecycle.
+   *
+   * If the transaction utilizes foreign account data, there is a chance that the client doesn't
+   * have the required block header in the local database. In these scenarios, a sync to
+   * the chain tip is performed, and the required block header is retrieved.
+   */
+  executeTransaction(account_id: AccountId, transaction_request: TransactionRequest): Promise<TransactionResult>;
+  /**
+   * Generates a transaction proof using either the provided prover or the client's default
+   * prover if none is supplied.
+   */
+  proveTransaction(transaction_result: TransactionResult, prover?: TransactionProver | null): Promise<ProvenTransaction>;
+  submitProvenTransaction(proven_transaction: ProvenTransaction, transaction_result: TransactionResult): Promise<number>;
+  applyTransaction(transaction_result: TransactionResult, submission_height: number): Promise<TransactionStoreUpdate>;
+  newMintTransactionRequest(target_account_id: AccountId, faucet_id: AccountId, note_type: NoteType, amount: bigint): TransactionRequest;
+  newSendTransactionRequest(sender_account_id: AccountId, target_account_id: AccountId, faucet_id: AccountId, note_type: NoteType, amount: bigint, recall_height?: number | null, timelock_height?: number | null): TransactionRequest;
+  newConsumeTransactionRequest(list_of_note_ids: string[]): TransactionRequest;
+  newSwapTransactionRequest(sender_account_id: AccountId, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint, note_type: NoteType, payback_note_type: NoteType): TransactionRequest;
+  /**
+   * Send a private note via the note transport layer
+   */
+  sendPrivateNote(note: Note, address: Address): Promise<void>;
+  /**
+   * Fetch private notes from the note transport layer
+   *
+   * Uses an internal pagination mechanism to avoid fetching duplicate notes.
+   */
+  fetchPrivateNotes(): Promise<void>;
+  /**
+   * Fetch all private notes from the note transport layer
+   *
+   * Fetches all notes stored in the transport layer, with no pagination.
+   * Prefer using [`WebClient::fetch_private_notes`] for a more efficient, on-going,
+   * fetching mechanism.
+   */
+  fetchAllPrivateNotes(): Promise<void>;
+  getInputNotes(filter: NoteFilter): Promise<InputNoteRecord[]>;
+  getInputNote(note_id: string): Promise<InputNoteRecord | undefined>;
+  getOutputNotes(filter: NoteFilter): Promise<any>;
+  getOutputNote(note_id: string): Promise<any>;
+  getConsumableNotes(account_id?: AccountId | null): Promise<ConsumableNoteRecord[]>;
+  /**
+   * Retrieves the setting value for `key`, or `None` if it hasn’t been set.
+   */
+  getSetting(key: string): Promise<any | undefined>;
+  /**
+   * Sets a setting key-value in the store. It can then be retrieved using `get_setting`.
+   */
+  setSetting(key: string, value: any): Promise<void>;
+  /**
+   * Deletes a setting key-value from the store.
+   */
+  removeSetting(key: string): Promise<void>;
+  /**
+   * Returns all the existing setting keys from the store.
+   */
+  listSettingKeys(): Promise<string[]>;
+  syncState(): Promise<SyncSummary>;
+  getSyncHeight(): Promise<number>;
+  static buildSwapTag(note_type: NoteType, offered_asset_faucet_id: AccountId, offered_asset_amount: bigint, requested_asset_faucet_id: AccountId, requested_asset_amount: bigint): NoteTag;
+  addTag(tag: string): Promise<void>;
+  removeTag(tag: string): Promise<void>;
+  listTags(): Promise<any>;
+  getTransactions(transaction_filter: TransactionFilter): Promise<TransactionRecord[]>;
+  constructor();
+  /**
+   * Creates a new client with the given node URL and optional seed.
+   * If `node_url` is `None`, it defaults to the testnet endpoint.
+   */
+  createClient(node_url?: string | null, node_note_transport_url?: string | null, seed?: Uint8Array | null): Promise<any>;
+  /**
+   * Creates a new client with the given node URL, optional seed, and external keystore
+   * callbacks. If `node_url` is `None`, it defaults to the testnet endpoint.
+   */
+  createClientWithExternalKeystore(node_url?: string | null, node_note_transport_url?: string | null, seed?: Uint8Array | null, get_key_cb?: Function | null, insert_key_cb?: Function | null, sign_cb?: Function | null): Promise<any>;
+  createScriptBuilder(): ScriptBuilder;
+}
+export class Word {
+  free(): void;
+  [Symbol.dispose](): void;
+  constructor(u64_vec: BigUint64Array);
+  /**
+   * Creates a Word from a hex string.
+   * Fails if the provided string is not a valid hex representation of a Word.
+   */
+  static fromHex(hex: string): Word;
+  static newFromFelts(felt_vec: Felt[]): Word;
+  toHex(): string;
+  serialize(): Uint8Array;
+  static deserialize(bytes: Uint8Array): Word;
+  toU64s(): BigUint64Array;
+  toFelts(): Felt[];
+}