@miradexio/client 0.1.0

package/dist/wire/thorchain.zod.d.ts

@@ -0,0 +1,224 @@
+import { z } from 'zod';
+export declare const ThornodeInboundAddressSchema: z.ZodObject<{
+    chain: z.ZodString;
+    address: z.ZodString;
+    router: z.ZodOptional<z.ZodString>;
+    halted: z.ZodBoolean;
+    pub_key: z.ZodOptional<z.ZodString>;
+    global_trading_paused: z.ZodOptional<z.ZodBoolean>;
+    chain_trading_paused: z.ZodOptional<z.ZodBoolean>;
+    chain_lp_actions_paused: z.ZodOptional<z.ZodBoolean>;
+    gas_rate: z.ZodOptional<z.ZodString>;
+    gas_rate_units: z.ZodOptional<z.ZodString>;
+    outbound_fee: z.ZodOptional<z.ZodString>;
+    outbound_tx_size: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    chain: string;
+    halted: boolean;
+    router?: string | undefined;
+    pub_key?: string | undefined;
+    global_trading_paused?: boolean | undefined;
+    chain_trading_paused?: boolean | undefined;
+    chain_lp_actions_paused?: boolean | undefined;
+    gas_rate?: string | undefined;
+    gas_rate_units?: string | undefined;
+    outbound_fee?: string | undefined;
+    outbound_tx_size?: string | undefined;
+}, {
+    address: string;
+    chain: string;
+    halted: boolean;
+    router?: string | undefined;
+    pub_key?: string | undefined;
+    global_trading_paused?: boolean | undefined;
+    chain_trading_paused?: boolean | undefined;
+    chain_lp_actions_paused?: boolean | undefined;
+    gas_rate?: string | undefined;
+    gas_rate_units?: string | undefined;
+    outbound_fee?: string | undefined;
+    outbound_tx_size?: string | undefined;
+}>;
+export type ThornodeInboundAddress = z.infer<typeof ThornodeInboundAddressSchema>;
+export declare const ThornodeInboundAddressesSchema: z.ZodArray<z.ZodObject<{
+    chain: z.ZodString;
+    address: z.ZodString;
+    router: z.ZodOptional<z.ZodString>;
+    halted: z.ZodBoolean;
+    pub_key: z.ZodOptional<z.ZodString>;
+    global_trading_paused: z.ZodOptional<z.ZodBoolean>;
+    chain_trading_paused: z.ZodOptional<z.ZodBoolean>;
+    chain_lp_actions_paused: z.ZodOptional<z.ZodBoolean>;
+    gas_rate: z.ZodOptional<z.ZodString>;
+    gas_rate_units: z.ZodOptional<z.ZodString>;
+    outbound_fee: z.ZodOptional<z.ZodString>;
+    outbound_tx_size: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    chain: string;
+    halted: boolean;
+    router?: string | undefined;
+    pub_key?: string | undefined;
+    global_trading_paused?: boolean | undefined;
+    chain_trading_paused?: boolean | undefined;
+    chain_lp_actions_paused?: boolean | undefined;
+    gas_rate?: string | undefined;
+    gas_rate_units?: string | undefined;
+    outbound_fee?: string | undefined;
+    outbound_tx_size?: string | undefined;
+}, {
+    address: string;
+    chain: string;
+    halted: boolean;
+    router?: string | undefined;
+    pub_key?: string | undefined;
+    global_trading_paused?: boolean | undefined;
+    chain_trading_paused?: boolean | undefined;
+    chain_lp_actions_paused?: boolean | undefined;
+    gas_rate?: string | undefined;
+    gas_rate_units?: string | undefined;
+    outbound_fee?: string | undefined;
+    outbound_tx_size?: string | undefined;
+}>, "many">;
+/**
+ * `/thorchain/vaults/asgard` returns every Asgard vault, not just the
+ * current primary. During THORChain churn there are typically two active
+ * vaults per chain — the new "ActiveVault" and the "RetiringVault" that's
+ * still accepting late deposits. Both need to be treated as legitimate
+ * destinations for an in-flight swap. We only consume `status` and
+ * `addresses`; other fields are ignored.
+ */
+export declare const AsgardVaultAddressSchema: z.ZodObject<{
+    chain: z.ZodString;
+    address: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    address: string;
+    chain: string;
+}, {
+    address: string;
+    chain: string;
+}>;
+export type AsgardVaultAddress = z.infer<typeof AsgardVaultAddressSchema>;
+export declare const AsgardVaultSchema: z.ZodObject<{
+    status: z.ZodString;
+    addresses: z.ZodArray<z.ZodObject<{
+        chain: z.ZodString;
+        address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        chain: string;
+    }, {
+        address: string;
+        chain: string;
+    }>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    status: z.ZodString;
+    addresses: z.ZodArray<z.ZodObject<{
+        chain: z.ZodString;
+        address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        chain: string;
+    }, {
+        address: string;
+        chain: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    status: z.ZodString;
+    addresses: z.ZodArray<z.ZodObject<{
+        chain: z.ZodString;
+        address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        chain: string;
+    }, {
+        address: string;
+        chain: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>;
+export type AsgardVault = z.infer<typeof AsgardVaultSchema>;
+export declare const AsgardVaultsResponseSchema: z.ZodArray<z.ZodObject<{
+    status: z.ZodString;
+    addresses: z.ZodArray<z.ZodObject<{
+        chain: z.ZodString;
+        address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        chain: string;
+    }, {
+        address: string;
+        chain: string;
+    }>, "many">;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    status: z.ZodString;
+    addresses: z.ZodArray<z.ZodObject<{
+        chain: z.ZodString;
+        address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        chain: string;
+    }, {
+        address: string;
+        chain: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    status: z.ZodString;
+    addresses: z.ZodArray<z.ZodObject<{
+        chain: z.ZodString;
+        address: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        address: string;
+        chain: string;
+    }, {
+        address: string;
+        chain: string;
+    }>, "many">;
+}, z.ZodTypeAny, "passthrough">>, "many">;
+export declare const ThornodeQuoteSchema: z.ZodObject<{
+    expected_amount_out: z.ZodString;
+    inbound_address: z.ZodOptional<z.ZodString>;
+    memo: z.ZodOptional<z.ZodString>;
+    fees: z.ZodOptional<z.ZodObject<{
+        asset: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        affiliate: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        outbound: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        liquidity: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+        total: z.ZodOptional<z.ZodOptional<z.ZodString>>;
+    }, "strip", z.ZodTypeAny, {
+        liquidity?: string | undefined;
+        asset?: string | undefined;
+        affiliate?: string | undefined;
+        outbound?: string | undefined;
+        total?: string | undefined;
+    }, {
+        liquidity?: string | undefined;
+        asset?: string | undefined;
+        affiliate?: string | undefined;
+        outbound?: string | undefined;
+        total?: string | undefined;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    expected_amount_out: string;
+    fees?: {
+        liquidity?: string | undefined;
+        asset?: string | undefined;
+        affiliate?: string | undefined;
+        outbound?: string | undefined;
+        total?: string | undefined;
+    } | undefined;
+    inbound_address?: string | undefined;
+    memo?: string | undefined;
+}, {
+    expected_amount_out: string;
+    fees?: {
+        liquidity?: string | undefined;
+        asset?: string | undefined;
+        affiliate?: string | undefined;
+        outbound?: string | undefined;
+        total?: string | undefined;
+    } | undefined;
+    inbound_address?: string | undefined;
+    memo?: string | undefined;
+}>;
+export type ThornodeQuote = z.infer<typeof ThornodeQuoteSchema>;
+//# sourceMappingURL=thorchain.zod.d.ts.map

package/dist/wire/thorchain.zod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thorchain.zod.d.ts","sourceRoot":"","sources":["../../src/wire/thorchain.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAavC,CAAC;AAEH,MAAM,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,4BAA4B,CAAC,CAAC;AAElF,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAAwC,CAAC;AAEpF;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;EAGnC,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAE1E,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAKd,CAAC;AAEjB,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,eAAO,MAAM,0BAA0B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAA6B,CAAC;AAErE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAc9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/wire/thorchain.zod.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export const ThornodeInboundAddressSchema = z.object({
+    chain: z.string(),
+    address: z.string(),
+    router: z.string().optional(),
+    halted: z.boolean(),
+    pub_key: z.string().optional(),
+    global_trading_paused: z.boolean().optional(),
+    chain_trading_paused: z.boolean().optional(),
+    chain_lp_actions_paused: z.boolean().optional(),
+    gas_rate: z.string().optional(),
+    gas_rate_units: z.string().optional(),
+    outbound_fee: z.string().optional(),
+    outbound_tx_size: z.string().optional(),
+});
+export const ThornodeInboundAddressesSchema = z.array(ThornodeInboundAddressSchema);
+/**
+ * `/thorchain/vaults/asgard` returns every Asgard vault, not just the
+ * current primary. During THORChain churn there are typically two active
+ * vaults per chain — the new "ActiveVault" and the "RetiringVault" that's
+ * still accepting late deposits. Both need to be treated as legitimate
+ * destinations for an in-flight swap. We only consume `status` and
+ * `addresses`; other fields are ignored.
+ */
+export const AsgardVaultAddressSchema = z.object({
+    chain: z.string(),
+    address: z.string(),
+});
+export const AsgardVaultSchema = z
+    .object({
+    status: z.string(),
+    addresses: z.array(AsgardVaultAddressSchema),
+})
+    .passthrough();
+export const AsgardVaultsResponseSchema = z.array(AsgardVaultSchema);
+export const ThornodeQuoteSchema = z.object({
+    expected_amount_out: z.string(),
+    inbound_address: z.string().optional(),
+    memo: z.string().optional(),
+    fees: z
+        .object({
+        asset: z.string().optional(),
+        affiliate: z.string().optional(),
+        outbound: z.string().optional(),
+        liquidity: z.string().optional(),
+        total: z.string().optional(),
+    })
+        .partial()
+        .optional(),
+});
+//# sourceMappingURL=thorchain.zod.js.map

package/dist/wire/thorchain.zod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"thorchain.zod.js","sourceRoot":"","sources":["../../src/wire/thorchain.zod.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAAC,CAAC,MAAM,CAAC;IACnD,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;IACnB,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC7B,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE;IACnB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC9B,qBAAqB,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC7C,oBAAoB,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC5C,uBAAuB,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;IAC/C,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC/B,cAAc,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACrC,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACnC,gBAAgB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACxC,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,8BAA8B,GAAG,CAAC,CAAC,KAAK,CAAC,4BAA4B,CAAC,CAAC;AAEpF;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC/C,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE;IACjB,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE;CACpB,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC;KAC/B,MAAM,CAAC;IACN,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,SAAS,EAAE,CAAC,CAAC,KAAK,CAAC,wBAAwB,CAAC;CAC7C,CAAC;KACD,WAAW,EAAE,CAAC;AAIjB,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,iBAAiB,CAAC,CAAC;AAErE,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE;IAC/B,eAAe,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IACtC,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;IAC3B,IAAI,EAAE,CAAC;SACJ,MAAM,CAAC;QACN,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC5B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAChC,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAC/B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;QAChC,KAAK,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;KAC7B,CAAC;SACD,OAAO,EAAE;SACT,QAAQ,EAAE;CACd,CAAC,CAAC"}

package/package.json

@@ -0,0 +1,128 @@
+{
+  "name": "@miradexio/client",
+  "version": "0.1.0",
+  "description": "Headless crypto swap SDK — BTC/XMR atomic swaps, THORChain, Chainflip, NEAR Intents. Works in Node.js, browsers, React Native, and bots.",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./portable": {
+      "types": "./dist/portable.d.ts",
+      "import": "./dist/portable.js"
+    },
+    "./api": {
+      "types": "./dist/api/index.d.ts",
+      "import": "./dist/api/index.js"
+    },
+    "./atomic-swap": {
+      "types": "./dist/atomic-swap/index.d.ts",
+      "import": "./dist/atomic-swap/index.js"
+    },
+    "./atomic-swap/presign": {
+      "types": "./dist/atomic-swap/presign.d.ts",
+      "import": "./dist/atomic-swap/presign.js"
+    },
+    "./atomic-swap/refund": {
+      "types": "./dist/atomic-swap/refund.d.ts",
+      "import": "./dist/atomic-swap/refund.js"
+    },
+    "./atomic-swap/monero-sweep": {
+      "types": "./dist/atomic-swap/monero-sweep/index.d.ts",
+      "import": "./dist/atomic-swap/monero-sweep/index.js"
+    },
+    "./verification": {
+      "types": "./dist/verification/index.d.ts",
+      "import": "./dist/verification/index.js"
+    },
+    "./verification/thorchain": {
+      "types": "./dist/verification/thorchain.d.ts",
+      "import": "./dist/verification/thorchain.js"
+    },
+    "./verification/chainflip": {
+      "types": "./dist/verification/chainflip.d.ts",
+      "import": "./dist/verification/chainflip.js"
+    },
+    "./verification/near-intents": {
+      "types": "./dist/verification/near-intents.d.ts",
+      "import": "./dist/verification/near-intents.js"
+    },
+    "./lib/bitcoin/tx-verify": {
+      "types": "./dist/lib/bitcoin/tx-verify.d.ts",
+      "import": "./dist/lib/bitcoin/tx-verify.js"
+    },
+    "./lib/monero/verify-lock": {
+      "types": "./dist/lib/monero/verify-lock.d.ts",
+      "import": "./dist/lib/monero/verify-lock.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build:wasm": "bash miradex-rust/scripts/build-wasm.sh && pnpm run pin-wasm",
+    "build:all": "pnpm run build:wasm && pnpm run build",
+    "pin-wasm": "node scripts/pin-wasm.mjs",
+    "verify-wasm": "node scripts/verify-wasm.mjs",
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "pnpm run build:all"
+  },
+  "keywords": [
+    "crypto",
+    "swap",
+    "atomic-swap",
+    "btc",
+    "xmr",
+    "monero",
+    "bitcoin",
+    "thorchain",
+    "chainflip",
+    "near-intents",
+    "sdk",
+    "headless",
+    "cross-chain"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/miradxio/miradex-client"
+  },
+  "homepage": "https://github.com/miradxio/miradex-client",
+  "bugs": {
+    "url": "https://github.com/miradxio/miradex-client/issues"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "files": [
+    "dist/",
+    "wasm/"
+  ],
+  "dependencies": {
+    "@noble/ed25519": "^3.0.1",
+    "@noble/hashes": "^2.0.1",
+    "@scure/base": "^2.0.0",
+    "bip32": "^4.0.0",
+    "bip39": "^3.1.0",
+    "bitcoinjs-lib": "^7.0.1",
+    "ecpair": "^3.0.1",
+    "eventemitter3": "^5.0.4",
+    "miradex-rust": "file:./wasm/miradex-rust",
+    "tiny-secp256k1": "^2.2.4",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "fast-check": "^4.6.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.9"
+  }
+}

package/wasm/miradex-rust/README.md

@@ -0,0 +1,74 @@
+# miradex-rust
+
+Rust source for the BTC/XMR atomic-swap cryptographic primitives used by
+[`@miradex/client`](..). Builds to a WebAssembly module that is consumed by
+the TypeScript SDK at runtime.
+
+This crate is the source of truth. The shipped binary lives at
+`../wasm/miradex-rust/` and is checked into the repo so that ordinary
+contributors do not need a Rust toolchain to work on `@miradex/client`.
+
+## Build the wasm
+
+From the `miradex-client/` package root (one level up):
+
+```
+pnpm run build:wasm
+```
+
+That runs `miradex-rust/scripts/build-wasm.sh` and then `pin-wasm`, which
+re-hashes the resulting binary into `src/wasm-pins.ts`.
+
+## Reproducing the published binary
+
+Anyone with these tools can rebuild bit-identically and verify the SHA256
+they get matches the one pinned in `src/wasm-pins.ts`:
+
+| Tool | Pinned version | Source |
+| --- | --- | --- |
+| Rust | `1.90.0` (channel) | `miradex-rust/rust-toolchain.toml` |
+| `wasm-pack` | `0.14.0` | `cargo install wasm-pack --version 0.14.0` |
+| `binaryen` (`wasm-opt`) | `version_119` | https://github.com/WebAssembly/binaryen/releases/tag/version_119 |
+| `jq` | any 1.x | system package |
+
+Steps:
+
+```
+# 1. Toolchain (rust-toolchain.toml auto-installs on first cargo invocation)
+cargo install wasm-pack --version 0.14.0
+
+# 2. Install binaryen (Linux example; macOS users: brew install binaryen)
+curl -L https://github.com/WebAssembly/binaryen/releases/download/version_119/binaryen-version_119-x86_64-linux.tar.gz \
+  | tar xz -C /tmp
+sudo cp /tmp/binaryen-version_119/bin/wasm-opt /usr/local/bin/
+
+# 3. Clone, build, verify
+git clone <repo>
+cd miradex-client
+pnpm install
+pnpm run build:wasm        # rebuilds wasm + repins SHA256
+pnpm run verify-wasm       # exits 0 if the freshly-built binary matches the pin
+```
+
+If `verify-wasm` exits 0, the committed binary at
+`../wasm/miradex-rust/miradex_rust_bg.wasm` is bit-identical to what this
+source produces in this toolchain.
+
+If you suspect drift between source and the binary committed to git, run
+`pnpm run verify-wasm` *without* first rebuilding — it compares the
+already-committed binary to the already-committed pin.
+
+## Caveats on bit-reproducibility
+
+- `Cargo.lock` is committed; do not delete it before building.
+- `wasm-pack` patch versions can change the cdylib layout. Match the version
+  in the table above.
+- `wasm-opt` produces different output across binaryen releases. Match the
+  pinned `binaryen` release.
+- macOS / Linux produce identical wasm output for these crates in practice.
+
+## What this crate exports
+
+`#[wasm_bindgen]` exports in `src/lib.rs` are mirrored in
+`packages/miradex-client/src/lib/crypto/types.ts`. Adding a new export means
+updating both.

package/wasm/miradex-rust/miradex_rust.d.ts

@@ -0,0 +1,149 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/**
+ * Compute the commitment mask for an output.
+ */
+export function compute_commitment_mask(view_key_hex: string, tx_public_key_hex: string, output_index: bigint): string;
+
+/**
+ * Decrypt a RingCT amount for an output.
+ */
+export function decrypt_amount(view_key_hex: string, tx_public_key_hex: string, output_index: bigint, encrypted_amount_hex: string): bigint;
+
+/**
+ * Decrypt an adaptor-encrypted signature with the decryption scalar.
+ */
+export function decrypt_signature(scalar_hex: string, encsig_hex: string): string;
+
+/**
+ * Derive key images for a set of outputs using the combined spend key.
+ */
+export function derive_key_images(outputs_json: string, view_key_hex: string, spend_key_hex: string): string;
+
+/**
+ * Add two ed25519 scalars modulo the group order.
+ */
+export function ed25519_scalar_add(scalar_a_hex: string, scalar_b_hex: string): string;
+
+/**
+ * Produce an adaptor-encrypted signature under the given encryption point.
+ */
+export function encsign_digest(b_hex: string, encryption_key_hex: string, digest_hex: string): string;
+
+/**
+ * Generate a fresh BTC/XMR swap key bundle with DLEQ proof.
+ */
+export function generate_client_keys(): string;
+
+/**
+ * Derive a BTC/XMR key bundle from caller-supplied seed material.
+ */
+export function generate_client_keys_from_seed(s_b_hex: string, v_b_hex: string, b_hex: string): string;
+
+export function init_panic_hook(): void;
+
+/**
+ * Recover the adaptor scalar given the decrypted signature and the encsig.
+ */
+export function recover_adaptor_scalar(sig_hex: string, encsig_hex: string, encryption_key_hex: string): string;
+
+/**
+ * Convert a secp256k1 scalar (big-endian) to an ed25519 scalar (little-endian).
+ */
+export function secp256k1_scalar_to_ed25519(secp_scalar_hex: string): string;
+
+/**
+ * Select decoys for a CLSAG ring using wallet2's gamma distribution.
+ *
+ * The JSON input may optionally include `unlock_window_blocks` to override
+ * wallet2's `DEFAULT_LOCK_WINDOW` (10). Use 60 (coinbase lock) on chains
+ * dominated by coinbase outputs (regtest, conservative configurations).
+ */
+export function select_decoys(real_output_index: bigint, cumulative_distribution_json: string, ring_size: number): string;
+
+/**
+ * Sign a 32-byte digest with a secp256k1 secret key. Returns 64-byte compact.
+ */
+export function sign_digest(b_hex: string, digest_hex: string): string;
+
+/**
+ * Sign a Monero sweep transaction.
+ */
+export function sign_sweep_tx(construction_data_json: string, spend_key_hex: string, view_key_hex: string): string;
+
+/**
+ * Verify a commitment matches expected mask + amount.
+ */
+export function verify_commitment(view_key_hex: string, tx_public_key_hex: string, output_index: bigint, amount: bigint, on_chain_commitment_hex: string): boolean;
+
+/**
+ * Verify a DLEQ proof binding a secp256k1 key to an ed25519 key.
+ */
+export function verify_dleq_proof(s_bitcoin_hex: string, s_monero_hex: string, proof_hex: string): boolean;
+
+/**
+ * Verify an adaptor-encrypted signature is valid for the triple.
+ */
+export function verify_encsig(verification_key_hex: string, encryption_key_hex: string, digest_hex: string, encsig_hex: string): boolean;
+
+/**
+ * Crate version string — used by consumers to verify pin drift.
+ */
+export function version(): string;
+
+export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
+
+export interface InitOutput {
+    readonly memory: WebAssembly.Memory;
+    readonly compute_commitment_mask: (a: number, b: number, c: number, d: number, e: number, f: bigint) => void;
+    readonly decrypt_amount: (a: number, b: number, c: number, d: number, e: number, f: bigint, g: number, h: number) => void;
+    readonly decrypt_signature: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly derive_key_images: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly ed25519_scalar_add: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly encsign_digest: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly generate_client_keys: (a: number) => void;
+    readonly generate_client_keys_from_seed: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly init_panic_hook: () => void;
+    readonly recover_adaptor_scalar: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly secp256k1_scalar_to_ed25519: (a: number, b: number, c: number) => void;
+    readonly select_decoys: (a: number, b: bigint, c: number, d: number, e: number) => void;
+    readonly sign_digest: (a: number, b: number, c: number, d: number, e: number) => void;
+    readonly sign_sweep_tx: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly verify_commitment: (a: number, b: number, c: number, d: number, e: number, f: bigint, g: bigint, h: number, i: number) => void;
+    readonly verify_dleq_proof: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
+    readonly verify_encsig: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number, i: number) => void;
+    readonly version: (a: number) => void;
+    readonly rustsecp256k1_v0_9_2_context_create: (a: number) => number;
+    readonly rustsecp256k1_v0_9_2_context_destroy: (a: number) => void;
+    readonly rustsecp256k1_v0_9_2_default_error_callback_fn: (a: number, b: number) => void;
+    readonly rustsecp256k1_v0_9_2_default_illegal_callback_fn: (a: number, b: number) => void;
+    readonly __wbindgen_export: (a: number) => void;
+    readonly __wbindgen_export2: (a: number, b: number, c: number) => void;
+    readonly __wbindgen_export3: (a: number, b: number) => number;
+    readonly __wbindgen_export4: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly __wbindgen_start: () => void;
+}
+
+export type SyncInitInput = BufferSource | WebAssembly.Module;
+
+/**
+ * Instantiates the given `module`, which can either be bytes or
+ * a precompiled `WebAssembly.Module`.
+ *
+ * @param {{ module: SyncInitInput }} module - Passing `SyncInitInput` directly is deprecated.
+ *
+ * @returns {InitOutput}
+ */
+export function initSync(module: { module: SyncInitInput } | SyncInitInput): InitOutput;
+
+/**
+ * If `module_or_path` is {RequestInfo} or {URL}, makes a request and
+ * for everything else, calls `WebAssembly.instantiate` directly.
+ *
+ * @param {{ module_or_path: InitInput | Promise<InitInput> }} module_or_path - Passing `InitInput` directly is deprecated.
+ *
+ * @returns {Promise<InitOutput>}
+ */
+export default function __wbg_init (module_or_path?: { module_or_path: InitInput | Promise<InitInput> } | InitInput | Promise<InitInput>): Promise<InitOutput>;