@unlink-xyz/core 0.1.2 → 0.1.3-canary.0877bfe

package/dist/utils/validators.d.ts

@@ -1,22 +1,16 @@
+import { type Chain } from "../keys/address.js";
+import { WithdrawalNoteInput } from "../transactions/types/index.js";
 export declare const SNARK_SCALAR_FIELD = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
 export declare function ensurePositiveInt(label: string, value: number): void;
 export declare function ensureChainId(chainId: number): void;
 /** Guards master public key strings against empty values. */
 export declare function ensureMpk(mpk: string): void;
 export declare function ensureBigIntString(label: string, value: string): void;
-export declare function ensureAddress(label: string, value: string): void;
+export declare function ensureAddress(label: string, value: string): `0x${string}`;
 /** Confirms the bigint resides in the SNARK scalar field range. */
 export declare function ensureFieldElement(label: string, value: bigint): void;
 /** Validates withdrawal note public data before encoding calldata. */
-export declare function ensureWithdrawalInput(label: string, withdrawal: {
-    npk: bigint;
-    amount: bigint;
-    token: string;
-}): {
-    npk: bigint;
-    amount: bigint;
-    token: string;
-};
+export declare function ensureWithdrawalInput(label: string, withdrawal: WithdrawalNoteInput | undefined): WithdrawalNoteInput | undefined;
 /** Validates note parameters before producing a Poseidon commitment. */
 export declare function ensureNoteCommitmentInput(label: string, note: {
     npk: bigint;
@@ -27,4 +21,21 @@ export declare function ensureNoteCommitmentInput(label: string, note: {
     amount: bigint;
     token: string;
 };
+/**
+ * Parsed ZK address containing the master public key, viewing public key,
+ * and optional chain info.
+ */
+export type ParsedZkAddress = {
+    masterPublicKey: bigint;
+    viewingPublicKey: Uint8Array;
+    chain?: Chain;
+};
+/**
+ * Parses a Bech32m ZK address (0zk1...) into its components.
+ *
+ * @param value - The Bech32m address string
+ * @returns Parsed address with masterPublicKey, viewingPublicKey, and optional chain
+ * @throws ValidationError if the address is invalid
+ */
+export declare function parseZkAddress(value: string): ParsedZkAddress;
 //# sourceMappingURL=validators.d.ts.map

package/dist/utils/validators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../utils/validators.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,kBAAkB,iFAC0E,CAAC;AAE1G,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAI7D;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,QAI5C;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,QAIpC;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAU9D;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAIzD;AAED,mEAAmE;AACnE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAO9D;AAED,sEAAsE;AACtE,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;SAAvC,MAAM;YAAU,MAAM;WAAS,MAAM;EAWzD;AAED,wEAAwE;AACxE,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;SAAvC,MAAM;YAAU,MAAM;WAAS,MAAM;EAWnD"}
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../utils/validators.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,gCAAgC,CAAC;AAGrE,eAAO,MAAM,kBAAkB,iFAC0E,CAAC;AAE1G,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAI7D;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,QAI5C;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,QAIpC;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAU9D;AAID,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,KAAK,MAAM,EAAE,CAOzE;AAED,mEAAmE;AACnE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAS9D;AAED,sEAAsE;AACtE,wBAAgB,qBAAqB,CACnC,KAAK,EAAE,MAAM,EACb,UAAU,EAAE,mBAAmB,GAAG,SAAS,mCAc5C;AAED,wEAAwE;AACxE,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;SAAvC,MAAM;YAAU,MAAM;WAAS,MAAM;EAWnD;AAED;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,eAAe,EAAE,MAAM,CAAC;IACxB,gBAAgB,EAAE,UAAU,CAAC;IAC7B,KAAK,CAAC,EAAE,KAAK,CAAC;CACf,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,eAAe,CAe7D"}

package/dist/utils/validators.js

@@ -1,20 +1,21 @@
-import { CoreError } from "../errors.js";
+import { ValidationError } from "../errors.js";
+import { decodeAddress } from "../keys/address.js";
 import { assertNonNegative } from "./bigint.js";
 export const SNARK_SCALAR_FIELD = 21888242871839275222246405745257275088548364400416034343698204186575808495617n;
 export function ensurePositiveInt(label, value) {
     if (!Number.isInteger(value) || value < 0) {
-        throw new CoreError(`${label} must be a non-negative integer`);
+        throw new ValidationError(`${label} must be a non-negative integer`);
     }
 }
 export function ensureChainId(chainId) {
     if (!Number.isInteger(chainId) || chainId <= 0) {
-        throw new CoreError("chainId must be a positive integer");
+        throw new ValidationError("chainId must be a positive integer");
     }
 }
 /** Guards master public key strings against empty values. */
 export function ensureMpk(mpk) {
     if (typeof mpk !== "string" || mpk.length === 0) {
-        throw new CoreError("note mpk must be a non-empty string");
+        throw new ValidationError("note mpk must be a non-empty string");
     }
 }
 export function ensureBigIntString(label, value) {
@@ -23,34 +24,38 @@ export function ensureBigIntString(label, value) {
         parsed = BigInt(value);
     }
     catch {
-        throw new CoreError(`${label} must be a base-10 bigint string`);
+        throw new ValidationError(`${label} must be a base-10 bigint string`);
     }
     if (parsed < 0n) {
-        throw new CoreError(`${label} must be non-negative`);
+        throw new ValidationError(`${label} must be non-negative`);
     }
 }
 const ADDRESS_REGEX = /^0x[0-9a-fA-F]{40}$/;
 export function ensureAddress(label, value) {
     if (typeof value !== "string" || !ADDRESS_REGEX.test(value)) {
-        throw new CoreError(`${label} must be a 0x-prefixed hex address`);
+        throw new ValidationError(`${label} must be a 0x-prefixed hex address, received: ${value}`);
     }
+    return value.toLowerCase();
 }
 /** Confirms the bigint resides in the SNARK scalar field range. */
 export function ensureFieldElement(label, value) {
     if (value < 0n) {
-        throw new CoreError(`${label} must be a non-negative field element`);
+        throw new ValidationError(`${label} must be a non-negative field element`);
     }
     if (value >= SNARK_SCALAR_FIELD) {
-        throw new CoreError(`${label} must be less than the SNARK scalar field`);
+        throw new ValidationError(`${label} must be less than the SNARK scalar field`);
     }
 }
 /** Validates withdrawal note public data before encoding calldata. */
 export function ensureWithdrawalInput(label, withdrawal) {
+    if (!withdrawal) {
+        return undefined;
+    }
     assertNonNegative(`${label}.npk`, withdrawal.npk);
     ensureFieldElement(`${label}.npk`, withdrawal.npk);
     assertNonNegative(`${label}.amount`, withdrawal.amount);
     // if (withdrawal.amount === 0n) {
-    //   throw new CoreError(`${label}.amount must be greater than zero`);
+    //   throw new ValidationError(`${label}.amount must be greater than zero`);
     // }
     ensureFieldElement(`${label}.amount`, withdrawal.amount);
     ensureAddress(`${label}.token`, withdrawal.token);
@@ -62,9 +67,30 @@ export function ensureNoteCommitmentInput(label, note) {
     ensureFieldElement(`${label}.npk`, note.npk);
     assertNonNegative(`${label}.amount`, note.amount);
     if (note.amount === 0n) {
-        throw new CoreError(`${label}.amount must be greater than zero`);
+        throw new ValidationError(`${label}.amount must be greater than zero`);
     }
     ensureFieldElement(`${label}.amount`, note.amount);
     ensureAddress(`${label}.token`, note.token);
     return note;
 }
+/**
+ * Parses a Bech32m ZK address (0zk1...) into its components.
+ *
+ * @param value - The Bech32m address string
+ * @returns Parsed address with masterPublicKey, viewingPublicKey, and optional chain
+ * @throws ValidationError if the address is invalid
+ */
+export function parseZkAddress(value) {
+    const trimmed = value.trim();
+    try {
+        const decoded = decodeAddress(trimmed);
+        return {
+            masterPublicKey: decoded.masterPublicKey,
+            viewingPublicKey: decoded.viewingPublicKey,
+            chain: decoded.chain,
+        };
+    }
+    catch (err) {
+        throw new ValidationError(`Invalid ZK address (expected 0zk1... format): ${err instanceof Error ? err.message : "unknown error"}`);
+    }
+}

package/dist/vitest.config.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
+//# sourceMappingURL=vitest.config.d.ts.map

package/dist/vitest.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vitest.config.d.ts","sourceRoot":"","sources":["../vitest.config.ts"],"names":[],"mappings":";AAEA,wBAWG"}

package/dist/vitest.config.js

@@ -0,0 +1,13 @@
+import { defineConfig } from "vitest/config";
+export default defineConfig({
+    test: {
+        globals: true,
+        setupFiles: ["./vitest.setup.ts"],
+        server: {
+            deps: {
+                // Transform CJS deps to support ESM named imports
+                inline: ["circomlibjs"],
+            },
+        },
+    },
+});

package/package.json

@@ -1,35 +1,52 @@
 {
   "name": "@unlink-xyz/core",
-  "version": "0.1.2",
+  "version": "0.1.3-canary.0877bfe",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "browser": {
+        "import": "./dist/browser/index.js",
+        "types": "./dist/index.d.ts"
+      },
+      "default": {
+        "import": "./dist/index.js",
+        "types": "./dist/index.d.ts"
+      }
+    },
+    "./utils/async.js": {
+      "import": "./dist/utils/async.js",
+      "types": "./dist/utils/async.d.ts"
     }
   },
+  "files": [
+    "dist"
+  ],
   "publishConfig": {
-    "access": "public"
+    "access": "restricted"
   },
   "scripts": {
-    "build": "tsc -p tsconfig.json",
+    "build": "tsc -p tsconfig.json && tsup --config tsup.browser.config.ts",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier . --write",
     "format:check": "prettier . --check",
     "test": "tsc -p tsconfig.json && vitest run --test-timeout 0",
-    "setup:artifacts": "./setup-artifacts.sh"
+    "setup:artifacts": "bash ./scripts/setup-artifacts.sh",
+    "clean": "rm -rf dist *.tsbuildinfo",
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@noble/ed25519": "3.0.0",
     "@noble/hashes": "2.0.0",
-    "@railgun-community/circomlibjs": "0.0.8",
     "@scure/base": "2.0.0",
     "@scure/bip39": "2.0.1",
     "@types/snarkjs": "^0.7.9",
+    "@zk-kit/eddsa-poseidon": "^1.1.0",
     "@zk-kit/imt": "2.0.0-beta.8",
+    "buffer": "^6.0.3",
+    "circomlibjs": "^0.1.7",
     "ethereum-cryptography": "3.2.0",
     "ethers": "6.15.0",
     "ky": "^1.14.0",
@@ -38,13 +55,13 @@
     "uuid": "^13.0.0"
   },
   "devDependencies": {
-    "@eslint/eslintrc": "^3.1.0",
+    "@esbuild-plugins/node-globals-polyfill": "^0.2.3",
+    "@esbuild-plugins/node-modules-polyfill": "^0.2.2",
     "@types/node": "^22.0.0",
-    "@typescript-eslint/eslint-plugin": "^7.18.0",
-    "@typescript-eslint/parser": "^7.18.0",
-    "eslint": "^8.57.1",
+    "eslint": "^9.19.0",
     "fake-indexeddb": "6.2.4",
     "prettier": "^3.5.3",
+    "tsup": "^8.3.5",
     "typescript": "^5.9.2",
     "vitest": "4.0.1"
   }

package/.eslintrc.json

@@ -1,4 +0,0 @@
-{
-  "root": true,
-  "extends": ["../../.eslintrc.base.json"]
-}

package/account/zkAccount.test.ts

@@ -1,316 +0,0 @@
-import { describe, expect, it } from "vitest";
-
-import { Mnemonic } from "../key-derivation/bip39.js";
-import { ByteUtils } from "../key-derivation/bytes.js";
-import {
-  deriveNodesFromSeed,
-  WalletNode,
-} from "../key-derivation/wallet-node.js";
-import { createMemoryStorage } from "../storage/memory.js";
-import {
-  deriveZkAccount,
-  deriveZkAccountFromMnemonic,
-  generateMasterSeed,
-  importMasterMnemonic,
-  loadMasterMnemonic,
-  loadMasterSeed,
-  MASTER_MNEMONIC_KEY,
-  MASTER_SEED_KEY,
-  MASTER_SEED_LENGTH,
-  storeMasterMnemonic,
-  type MasterSeedCrypto,
-} from "./zkAccount.js";
-
-describe("deriveZkAccount", () => {
-  const seed = Uint8Array.from(
-    { length: MASTER_SEED_LENGTH },
-    (_, i) => i & 0xff,
-  );
-
-  it("derives wallet key material", async () => {
-    const account = await deriveZkAccount(seed, 0);
-
-    expect(account.spendingKeyPair.privateKey).toHaveLength(32);
-    expect(typeof account.spendingKeyPair.pubkey[0]).toBe("bigint");
-    expect(typeof account.spendingKeyPair.pubkey[1]).toBe("bigint");
-
-    expect(account.viewingKeyPair.privateKey).toHaveLength(32);
-    expect(account.viewingKeyPair.pubkey).toHaveLength(32);
-
-    expect(account.nullifyingKey).toBeTypeOf("bigint");
-
-    const expectedNullifyingKey = await deriveNodesFromSeed(
-      seed,
-      0,
-    ).viewing.getNullifyingKey();
-    expect(account.nullifyingKey).toBe(expectedNullifyingKey);
-
-    const expectedMPK = WalletNode.getMasterPublicKey(
-      account.spendingKeyPair.pubkey,
-      account.nullifyingKey,
-    );
-    expect(account.masterPublicKey).toBe(expectedMPK);
-  });
-
-  it("derives distinct accounts per index", async () => {
-    const first = await deriveZkAccount(seed, 0);
-    const second = await deriveZkAccount(seed, 1);
-
-    expect(first.spendingKeyPair.privateKey).not.toEqual(
-      second.spendingKeyPair.privateKey,
-    );
-    expect(first.viewingKeyPair.privateKey).not.toEqual(
-      second.viewingKeyPair.privateKey,
-    );
-    expect(first.nullifyingKey).not.toEqual(second.nullifyingKey);
-    expect(first.masterPublicKey).not.toEqual(second.masterPublicKey);
-  });
-
-  it("rejects negative indices", async () => {
-    await expect(deriveZkAccount(seed, -1)).rejects.toThrow(
-      "accountIndex must be a non-negative integer",
-    );
-  });
-
-  it("rejects non-integer indices", async () => {
-    await expect(deriveZkAccount(seed, Number.NaN)).rejects.toThrow(
-      "accountIndex must be a non-negative integer",
-    );
-    await expect(deriveZkAccount(seed, 0.25)).rejects.toThrow(
-      "accountIndex must be a non-negative integer",
-    );
-  });
-
-  it("rejects seeds that are not 64 bytes", async () => {
-    const shortSeed = Uint8Array.from({ length: 32 }, () => 1);
-    await expect(deriveZkAccount(shortSeed, 0)).rejects.toThrow(
-      "master seed must be 64 bytes",
-    );
-  });
-
-  it("derives the same keys when using mnemonic helper", async () => {
-    const entropy = Uint8Array.from({ length: 32 }, (_, i) => (i * 19) & 0xff);
-    const mnemonic = Mnemonic.fromEntropy(ByteUtils.bytesToHex(entropy));
-    const seedFromMnemonic = ByteUtils.hexStringToBytes(
-      Mnemonic.toSeed(mnemonic),
-    );
-
-    const fromSeed = await deriveZkAccount(seedFromMnemonic, 2);
-    const fromMnemonic = await deriveZkAccountFromMnemonic(mnemonic, 2);
-
-    expect(fromMnemonic).toEqual(fromSeed);
-  });
-});
-
-describe("generateMasterSeed", () => {
-  const fixtureEntropy = Uint8Array.from(
-    { length: 32 },
-    (_, i) => (i * 13) & 0xff,
-  );
-  const fixtureMnemonic = Mnemonic.fromEntropy(
-    ByteUtils.bytesToHex(fixtureEntropy),
-  );
-  const fixtureSeed = ByteUtils.hexStringToBytes(
-    Mnemonic.toSeed(fixtureMnemonic),
-  );
-
-  function rngFixture(): (n: number) => Uint8Array {
-    return (n) => {
-      expect(n).toBe(32);
-      return new Uint8Array(fixtureEntropy);
-    };
-  }
-
-  it("creates and persists a new seed when none exists", async () => {
-    const storage = createMemoryStorage();
-
-    const seed = await generateMasterSeed({
-      storage,
-      rng: rngFixture(),
-      mnemonicPassphrase: "",
-    });
-
-    expect(seed).toEqual(fixtureSeed);
-    const stored = await storage.get(MASTER_SEED_KEY);
-    expect(stored).not.toBeNull();
-    expect(stored).toEqual(fixtureSeed);
-
-    const mnemonic = await loadMasterMnemonic(storage);
-    expect(mnemonic).toEqual(fixtureMnemonic);
-  });
-
-  it("returns existing seed without invoking rng", async () => {
-    const storage = createMemoryStorage();
-    await storage.put(MASTER_SEED_KEY, fixtureSeed);
-
-    const seed = await generateMasterSeed({
-      storage,
-      rng: () => {
-        throw new Error("rng should not be called when seed exists");
-      },
-    });
-
-    expect(seed).toEqual(fixtureSeed);
-  });
-
-  it("overwrites when requested", async () => {
-    const storage = createMemoryStorage();
-    const existing = Uint8Array.from(
-      { length: MASTER_SEED_LENGTH },
-      (_, i) => (i * 3) & 0xff,
-    );
-    await storage.put(MASTER_SEED_KEY, existing);
-    const replacementEntropy = Uint8Array.from(
-      { length: 32 },
-      (_, i) => (i * 7) & 0xff,
-    );
-    const replacementMnemonic = Mnemonic.fromEntropy(
-      ByteUtils.bytesToHex(replacementEntropy),
-    );
-    const replacementSeed = ByteUtils.hexStringToBytes(
-      Mnemonic.toSeed(replacementMnemonic),
-    );
-
-    const seed = await generateMasterSeed({
-      storage,
-      rng: (n) => {
-        expect(n).toBe(32);
-        return new Uint8Array(replacementEntropy);
-      },
-      overwrite: true,
-      mnemonicPassphrase: "",
-    });
-
-    expect(seed).toEqual(replacementSeed);
-    const stored = await storage.get(MASTER_SEED_KEY);
-    expect(stored).toEqual(replacementSeed);
-    const mnemonic = await loadMasterMnemonic(storage);
-    expect(mnemonic).toEqual(replacementMnemonic);
-  });
-
-  it("applies custom crypto hooks", async () => {
-    const storage = createMemoryStorage();
-
-    const crypto: MasterSeedCrypto = {
-      encrypt(seed) {
-        return seed.map((byte) => byte ^ 0xff);
-      },
-      decrypt(payload) {
-        return payload.map((byte) => byte ^ 0xff);
-      },
-    };
-
-    const seed = await generateMasterSeed({
-      storage,
-      rng: rngFixture(),
-      crypto,
-      mnemonicPassphrase: "",
-    });
-
-    expect(seed).toEqual(fixtureSeed);
-    const roundTrip = await loadMasterSeed(storage, crypto);
-    expect(roundTrip).toEqual(fixtureSeed);
-
-    const storedMnemonic = await storage.get(MASTER_MNEMONIC_KEY);
-    expect(storedMnemonic).toEqual(
-      textEncode(fixtureMnemonic).map((byte) => byte ^ 0xff),
-    );
-
-    const mnemonicRoundTrip = await loadMasterMnemonic(storage, crypto);
-    expect(mnemonicRoundTrip).toEqual(fixtureMnemonic);
-  });
-
-  it("returns null when no seed is stored", async () => {
-    const storage = createMemoryStorage();
-
-    const result = await loadMasterSeed(storage);
-
-    expect(result).toBeNull();
-  });
-
-  it("throws if rng returns incorrect length", async () => {
-    const storage = createMemoryStorage();
-
-    await expect(
-      generateMasterSeed({
-        storage,
-        rng: () => new Uint8Array(16),
-        mnemonicPassphrase: "",
-      }),
-    ).rejects.toThrow(/mnemonic entropy must be 32 bytes/);
-  });
-
-  it("reconstitutes seed from stored mnemonic when seed missing", async () => {
-    const storage = createMemoryStorage();
-    await storeMnemonicFixture(storage, fixtureMnemonic);
-
-    const seed = await generateMasterSeed({
-      storage,
-      rng: rngFixture(),
-      mnemonicPassphrase: "",
-    });
-
-    expect(seed).toEqual(fixtureSeed);
-    const stored = await storage.get(MASTER_SEED_KEY);
-    expect(stored).toEqual(fixtureSeed);
-  });
-});
-
-describe("importMasterMnemonic", () => {
-  const mnemonic =
-    "legal winner thank year wave sausage worth useful legal winner thank yellow";
-  const seed = ByteUtils.hexStringToBytes(Mnemonic.toSeed(mnemonic));
-
-  it("imports mnemonic and stores derived seed", async () => {
-    const storage = createMemoryStorage();
-
-    const derived = await importMasterMnemonic({ storage, mnemonic });
-
-    expect(derived).toEqual(seed);
-    const storedSeed = await loadMasterSeed(storage);
-    expect(storedSeed).toEqual(seed);
-    const storedMnemonic = await loadMasterMnemonic(storage);
-    expect(storedMnemonic).toEqual(mnemonic);
-  });
-
-  it("refuses to overwrite without flag", async () => {
-    const storage = createMemoryStorage();
-    await importMasterMnemonic({ storage, mnemonic });
-
-    await expect(importMasterMnemonic({ storage, mnemonic })).rejects.toThrow(
-      /already exists/,
-    );
-  });
-
-  it("overwrites when requested", async () => {
-    const storage = createMemoryStorage();
-    await importMasterMnemonic({ storage, mnemonic });
-
-    const alternate =
-      "letter advice cage absurd amount doctor acoustic avoid letter advice cage above";
-    const alternateSeed = ByteUtils.hexStringToBytes(
-      Mnemonic.toSeed(alternate),
-    );
-
-    const derived = await importMasterMnemonic({
-      storage,
-      mnemonic: alternate,
-      overwrite: true,
-    });
-
-    expect(derived).toEqual(alternateSeed);
-    const storedMnemonic = await loadMasterMnemonic(storage);
-    expect(storedMnemonic).toEqual(alternate);
-  });
-});
-
-function textEncode(value: string): Uint8Array {
-  return new TextEncoder().encode(value);
-}
-
-async function storeMnemonicFixture(
-  storage: ReturnType<typeof createMemoryStorage>,
-  mnemonic: string,
-) {
-  await storeMasterMnemonic(storage, mnemonic);
-}