quantumcoin 7.0.8 → 7.0.10

package/README-SDK.md

@@ -392,6 +392,7 @@ User-facing wallet class.
 - `Wallet.fromEncryptedJsonSync(json: string, password: string, provider?: AbstractProvider): Wallet`
 - `Wallet.fromPhrase(phrase: string | string[], provider?: AbstractProvider): Wallet`
 - `Wallet.fromKeys(privateKey: Uint8Array | string, publicKey: Uint8Array | string, provider?: AbstractProvider): Wallet`
+- `Wallet.encryptSeedSync(seed: number[] | Uint8Array, password: string | Uint8Array): string` — encrypts raw seed bytes (64/72/96) into a wallet JSON string (version 5 pre-expansion format). The resulting JSON can be opened with `fromEncryptedJsonSync()` or Desktop/Mobile/Web/CLI wallet applications. Password must be at least 12 characters.
 
 **Instance methods**
 - `getAddress(): string`
@@ -399,6 +400,7 @@ User-facing wallet class.
 - `getTransactionCount(blockTag?: string): Promise<number>`
 - `encryptSync(password: string | Uint8Array): string`
 - `connect(provider: AbstractProvider): Wallet`
+- `getSigningContext(fullSign?: boolean | null): number` — returns the recommended signing context for this wallet (based on public key type). Setting `fullSign` to `true` may incur additional gas cost.
 
 **Example(s):**
 - `examples/wallet-offline.js`

package/README.md

@@ -58,6 +58,23 @@ const restored = Wallet.fromEncryptedJsonSync(encrypted, "mySecurePassword123");
 console.log(restored.address);
 ```
 
+### Encrypt a raw seed
+
+You can encrypt raw seed bytes (pre-expansion) into a portable wallet JSON (version 5 format) without first opening the wallet:
+
+```js
+const { Wallet } = require("quantumcoin");
+const { Initialize } = require("quantumcoin/config");
+
+await Initialize(null);
+
+// 64-byte seed (keyType 3), 72-byte (keyType 5), or 96-byte (legacy)
+const seed = [51,214,149,165, /* ...remaining bytes... */];
+const json = Wallet.encryptSeedSync(seed, "mySecurePassword123");
+const restored = Wallet.fromEncryptedJsonSync(json, "mySecurePassword123");
+console.log(restored.address);
+```
+
 ## Contracts (read-only)
 
 ```js

package/examples/package-lock.json

@@ -1,15 +1,15 @@
 {
   "name": "quantumcoinjs-sdk-examples",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "quantumcoinjs-sdk-examples",
-      "version": "1.0.0",
+      "version": "1.0.1",
       "license": "MIT",
       "dependencies": {
-        "quantum-coin-js-sdk": "1.0.32",
+        "quantum-coin-js-sdk": "1.0.33",
         "quantumcoin": "file:.."
       },
       "devDependencies": {
@@ -18,10 +18,10 @@
     },
     "..": {
       "name": "quantumcoin",
-      "version": "7.0.8",
+      "version": "7.0.10",
       "license": "MIT",
       "dependencies": {
-        "quantum-coin-js-sdk": "1.0.32",
+        "quantum-coin-js-sdk": "1.0.33",
         "seed-words": "^1.0.2"
       },
       "bin": {
@@ -201,7 +201,9 @@
       }
     },
     "node_modules/quantum-coin-js-sdk": {
-      "version": "1.0.32",
+      "version": "1.0.33",
+      "resolved": "https://registry.npmjs.org/quantum-coin-js-sdk/-/quantum-coin-js-sdk-1.0.33.tgz",
+      "integrity": "sha512-n4Q/PBj6yQ2mj3MpvNdLlBSoSxM9+q+yTDz/l/zuWxeob/unj1ZQgzir1Qh4U/Vu7eAbZmAhRORFP9ttfw3ToA==",
       "license": "MIT",
       "dependencies": {
         "seed-words": "1.0.2"

package/examples/package.json

@@ -1,6 +1,6 @@
 {
   "name": "quantumcoinjs-sdk-examples",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "QuantumCoin.js SDK Examples",
   "main": "example.js",
   "scripts": {
@@ -26,7 +26,7 @@
     "tsx": "^4.19.0"
   },
   "dependencies": {
-    "quantum-coin-js-sdk": "1.0.32",
+    "quantum-coin-js-sdk": "1.0.33",
     "quantumcoin": "file:.."
   }
 }

package/examples/wallet-offline.js

@@ -26,6 +26,15 @@ async function walletOffline() {
   const json = wallet.encryptSync("mySecurePassword123");
   console.log("Encrypted wallet JSON length:", json.length);
   logExample("wallet-offline.js", "encryptSync", { jsonLength: json.length });
+
+  // Encrypt a raw seed (pre-expansion format) and restore it
+  const seed = [51,214,149,165,206,96,227,5,173,247,83,219,210,2,221,2,4,48,117,55,88,109,241,204,31,62,23,128,47,21,168,247,28,118,30,185,229,255,17,27,34,107,225,138,254,156,55,9,253,255,142,148,234,189,232,43,173,84,159,108,8,35,58,77];
+  const seedJson = Wallet.encryptSeedSync(seed, "mySecurePassword123");
+  console.log("Seed-encrypted wallet JSON length:", seedJson.length);
+  const restored = Wallet.fromEncryptedJsonSync(seedJson, "mySecurePassword123");
+  console.log("Restored from seed address:", restored.address);
+  logExample("wallet-offline.js", "encryptSeedSync", { jsonLength: seedJson.length });
+  logAddress("restored", restored.address);
 }
 
 walletOffline().catch((e) => {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "quantumcoin",
-  "version": "7.0.8",
-  "description": "QuantumCoin SDK - a complete SDK for dapps",
+  "version": "7.0.10",
+  "description": "QuantumCoin.js - a post quantum cryptography SDK for QuantumCoin",
   "main": "index.js",
   "types": "src/index.d.ts",
   "typesVersions": {
@@ -90,6 +90,6 @@
   },
   "dependencies": {
     "seed-words": "^1.0.2",
-    "quantum-coin-js-sdk": "1.0.32"
+    "quantum-coin-js-sdk": "1.0.33"
   }
 }

package/src/wallet/wallet.d.ts

@@ -63,6 +63,13 @@ export class BaseWallet extends AbstractSigner {
  * Wallet - convenience methods around BaseWallet.
  */
 export class Wallet extends BaseWallet {
+    /**
+     * Returns the recommended signing context for this wallet.
+     * Setting fullSign to true may incur additional gas cost.
+     * @param {boolean|null=} fullSign  Defaults to false when null or omitted.
+     * @returns {number}
+     */
+    getSigningContext(fullSign?: boolean | null): number;
     /**
      * Creates a new random wallet.
      * @param {import("../providers/provider").AbstractProvider=} provider
@@ -141,6 +148,15 @@ export class Wallet extends BaseWallet {
      * @returns {string}
      */
     encryptSync(password: string | Uint8Array): string;
+    /**
+     * Encrypts raw seed bytes into a wallet JSON string (version 5 pre-expansion format).
+     * The resulting JSON can be opened with `Wallet.fromEncryptedJsonSync()` or
+     * Desktop/Mobile/Web/CLI wallet applications.
+     * @param {number[]|Uint8Array} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
+     * @param {string|Uint8Array} password  Passphrase (at least 12 characters)
+     * @returns {string}
+     */
+    static encryptSeedSync(seed: number[] | Uint8Array, password: string | Uint8Array): string;
     /**
      * Returns a new wallet connected to a provider.
      * @param {import("../providers/provider").AbstractProvider} provider

package/src/wallet/wallet.js

@@ -311,6 +311,44 @@ class Wallet extends BaseWallet {
     return json;
   }
 
+  /**
+   * Encrypts raw seed bytes into a wallet JSON string (version 5 pre-expansion format).
+   * The resulting JSON can be opened with `Wallet.fromEncryptedJsonSync()` or
+   * Desktop/Mobile/Web/CLI wallet applications.
+   * @param {number[]|Uint8Array} seed  Raw seed bytes: 64 (keyType 3), 72 (keyType 5), or 96 (legacy)
+   * @param {string|Uint8Array} password  Passphrase (at least 12 characters)
+   * @returns {string}
+   */
+  static encryptSeedSync(seed, password) {
+    _requireInitialized();
+    const seedArr = seed instanceof Uint8Array ? Array.from(seed) : seed;
+    assertArgument(Array.isArray(seedArr), "seed must be an array of numbers or Uint8Array", "seed", seed);
+    const allowedLengths = [64, 72, 96];
+    assertArgument(allowedLengths.includes(seedArr.length), "seed must be 64, 72, or 96 bytes", "seed", seedArr.length);
+    const pw = typeof password === "string" ? password : Buffer.from(arrayify(password)).toString("utf8");
+    const json = qcsdk.serializeSeedAsEncryptedWallet(seedArr, pw);
+    if (typeof json !== "string") throw makeError("serializeSeedAsEncryptedWallet failed", "UNKNOWN_ERROR", {});
+    return json;
+  }
+
+  /**
+   * Returns the recommended signing context for this wallet.
+   * Setting fullSign to true may incur additional gas cost.
+   * @param {boolean|null=} fullSign  Defaults to false when null or omitted.
+   * @returns {number}
+   */
+  getSigningContext(fullSign) {
+    const fs = fullSign ?? false;
+    const pubLen = this.signingKey.publicKeyBytes.length;
+    if (pubLen === 1408) {
+      return fs ? 2 : 0;
+    }
+    if (pubLen === 2688) {
+      return 1;
+    }
+    throw makeError("unsupported public key size", "UNSUPPORTED_OPERATION", { publicKeyLength: pubLen });
+  }
+
   /**
    * Returns a new wallet connected to a provider.
    * @param {import("../providers/provider").AbstractProvider} provider

package/test/e2e/signing-context-and-fee.e2e.test.js

@@ -92,11 +92,11 @@ describe("SigningContext and fee E2E", () => {
 
     // --- Phase 2: Send back with signingContext (36: null, 1; 32: null, 0, 2) ---
     const cases = [
-      { wallet: wallet36, signingContext: null, label: "36_null" },
-      { wallet: wallet36, signingContext: 1, label: "36_1" },
-      { wallet: wallet32, signingContext: null, label: "32_null" },
-      { wallet: wallet32, signingContext: 0, label: "32_0" },
-      { wallet: wallet32, signingContext: 2, label: "32_2" },
+      { wallet: wallet36, signingContext: wallet36.getSigningContext(), label: "36_null" },
+      { wallet: wallet36, signingContext: wallet36.getSigningContext(true), label: "36_1" },
+      { wallet: wallet32, signingContext: wallet32.getSigningContext(), label: "32_null" },
+      { wallet: wallet32, signingContext: wallet32.getSigningContext(), label: "32_0" },
+      { wallet: wallet32, signingContext: wallet32.getSigningContext(true), label: "32_2" },
     ];
 
     const expectedFees = {

package/test/e2e/signing-context-and-fee.e2e.test.ts

@@ -83,11 +83,11 @@ describe("SigningContext and fee E2E", () => {
     const sendBackValue = SEND_AMOUNT - qc.parseEther("10000");
 
     const cases = [
-      { wallet: wallet36, signingContext: null as number | null, label: "36_null" },
-      { wallet: wallet36, signingContext: 1, label: "36_1" },
-      { wallet: wallet32, signingContext: null as number | null, label: "32_null" },
-      { wallet: wallet32, signingContext: 0, label: "32_0" },
-      { wallet: wallet32, signingContext: 2, label: "32_2" },
+      { wallet: wallet36, signingContext: wallet36.getSigningContext(), label: "36_null" },
+      { wallet: wallet36, signingContext: wallet36.getSigningContext(true), label: "36_1" },
+      { wallet: wallet32, signingContext: wallet32.getSigningContext(), label: "32_null" },
+      { wallet: wallet32, signingContext: wallet32.getSigningContext(), label: "32_0" },
+      { wallet: wallet32, signingContext: wallet32.getSigningContext(true), label: "32_2" },
     ];
 
     const expectedFees: Record<string, bigint> = {

package/test/unit/address-wallet.test.js

@@ -560,5 +560,133 @@ describe("Address + Wallet (offline)", () => {
     assert.equal(w.address, addr5);
     assert.equal(qc.isAddress(w.address), true);
   });
+
+  // ---------------------------------------------------------------------------
+  // encryptSeedSync
+  // ---------------------------------------------------------------------------
+
+  it("encryptSeedSync: 32-word seed (64 bytes) roundtrip preserves address, privateKey, publicKey", async () => {
+    await Initialize(null);
+    const seedwords = require("seed-words");
+    const seedArr = seedwords.getSeedArrayFromWordList(TEST_SEED_WORDS_32);
+    assert.equal(seedArr.length, 64);
+    const ref = qc.Wallet.fromPhrase(TEST_SEED_WORDS_32);
+
+    const json = qc.Wallet.encryptSeedSync(Array.from(seedArr), PASSPHRASE_PHRASE);
+    assert.equal(typeof json, "string");
+    assert.ok(json.includes("address"));
+
+    const restored = qc.Wallet.fromEncryptedJsonSync(json, PASSPHRASE_PHRASE);
+    assert.equal(restored.address, ref.address);
+    assert.equal(restored.address, TEST_SEED_ADDRESS_32);
+    assert.equal(restored.privateKey, ref.privateKey);
+    assert.deepEqual(restored.signingKey.publicKeyBytes, ref.signingKey.publicKeyBytes);
+  });
+
+  it("encryptSeedSync: 36-word seed (72 bytes) roundtrip preserves address, privateKey, publicKey", async () => {
+    await Initialize(null);
+    const seedwords = require("seed-words");
+    const seedArr = seedwords.getSeedArrayFromWordList(TEST_SEED_WORDS_36);
+    assert.equal(seedArr.length, 72);
+    const ref = qc.Wallet.fromPhrase(TEST_SEED_WORDS_36);
+
+    const json = qc.Wallet.encryptSeedSync(Array.from(seedArr), PASSPHRASE_PHRASE);
+    assert.equal(typeof json, "string");
+    assert.ok(json.includes("address"));
+
+    const restored = qc.Wallet.fromEncryptedJsonSync(json, PASSPHRASE_PHRASE);
+    assert.equal(restored.address, ref.address);
+    assert.equal(restored.address, TEST_SEED_ADDRESS_36);
+    assert.equal(restored.privateKey, ref.privateKey);
+    assert.deepEqual(restored.signingKey.publicKeyBytes, ref.signingKey.publicKeyBytes);
+  });
+
+  it("encryptSeedSync: 48-word seed (96 bytes) roundtrip preserves address, privateKey, publicKey", async () => {
+    await Initialize(null);
+    const seedwords = require("seed-words");
+    const seedArr = seedwords.getSeedArrayFromWordList(TEST_SEED_WORDS);
+    assert.equal(seedArr.length, 96);
+    const ref = qc.Wallet.fromPhrase(TEST_SEED_WORDS);
+
+    const json = qc.Wallet.encryptSeedSync(Array.from(seedArr), PASSPHRASE_PHRASE);
+    assert.equal(typeof json, "string");
+    assert.ok(json.includes("address"));
+
+    const restored = qc.Wallet.fromEncryptedJsonSync(json, PASSPHRASE_PHRASE);
+    assert.equal(restored.address, ref.address);
+    assert.equal(restored.address, TEST_SEED_ADDRESS);
+    assert.equal(restored.privateKey, ref.privateKey);
+    assert.deepEqual(restored.signingKey.publicKeyBytes, ref.signingKey.publicKeyBytes);
+  });
+
+  it("encryptSeedSync accepts Uint8Array seed", async () => {
+    await Initialize(null);
+    const seedwords = require("seed-words");
+    const seedArr = seedwords.getSeedArrayFromWordList(TEST_SEED_WORDS_32);
+    const ref = qc.Wallet.fromPhrase(TEST_SEED_WORDS_32);
+
+    const json = qc.Wallet.encryptSeedSync(new Uint8Array(seedArr), PASSPHRASE_PHRASE);
+    const restored = qc.Wallet.fromEncryptedJsonSync(json, PASSPHRASE_PHRASE);
+    assert.equal(restored.address, ref.address);
+  });
+
+  it("encryptSeedSync rejects non-array seed input", async () => {
+    await Initialize(null);
+    assert.throws(() => qc.Wallet.encryptSeedSync("not an array", PASSPHRASE_PHRASE), /seed must be an array/);
+    assert.throws(() => qc.Wallet.encryptSeedSync(12345, PASSPHRASE_PHRASE), /seed must be an array/);
+    assert.throws(() => qc.Wallet.encryptSeedSync(null, PASSPHRASE_PHRASE), /seed must be an array/);
+  });
+
+  it("encryptSeedSync rejects wrong-length seed arrays", async () => {
+    await Initialize(null);
+    assert.throws(() => qc.Wallet.encryptSeedSync(new Array(32).fill(0), PASSPHRASE_PHRASE), /seed must be 64, 72, or 96 bytes/);
+    assert.throws(() => qc.Wallet.encryptSeedSync(new Array(48).fill(0), PASSPHRASE_PHRASE), /seed must be 64, 72, or 96 bytes/);
+    assert.throws(() => qc.Wallet.encryptSeedSync(new Array(100).fill(0), PASSPHRASE_PHRASE), /seed must be 64, 72, or 96 bytes/);
+    assert.throws(() => qc.Wallet.encryptSeedSync([], PASSPHRASE_PHRASE), /seed must be 64, 72, or 96 bytes/);
+  });
+
+  it("encryptSeedSync rejects password shorter than 12 characters", async () => {
+    await Initialize(null);
+    const seed = new Array(64).fill(1);
+    assert.throws(() => qc.Wallet.encryptSeedSync(seed, "short"), /serializeSeedAsEncryptedWallet failed/);
+  });
+
+  // ---------------------------------------------------------------------------
+  // getSigningContext
+  // ---------------------------------------------------------------------------
+
+  it("getSigningContext: 32-word wallet (pubKey 1408) returns 0 by default, 2 with fullSign", async () => {
+    await Initialize(null);
+    const w = qc.Wallet.fromPhrase(TEST_SEED_WORDS_32);
+    assert.strictEqual(w.getSigningContext(), 0);
+    assert.strictEqual(w.getSigningContext(null), 0);
+    assert.strictEqual(w.getSigningContext(false), 0);
+    assert.strictEqual(w.getSigningContext(true), 2);
+  });
+
+  it("getSigningContext: 48-word wallet (pubKey 1408) returns 0 by default, 2 with fullSign", async () => {
+    await Initialize(null);
+    const w = qc.Wallet.fromPhrase(TEST_SEED_WORDS);
+    assert.strictEqual(w.getSigningContext(), 0);
+    assert.strictEqual(w.getSigningContext(null), 0);
+    assert.strictEqual(w.getSigningContext(false), 0);
+    assert.strictEqual(w.getSigningContext(true), 2);
+  });
+
+  it("getSigningContext: 36-word wallet (pubKey 2688) returns 1 for all fullSign values", async () => {
+    await Initialize(null);
+    const w = qc.Wallet.fromPhrase(TEST_SEED_WORDS_36);
+    assert.strictEqual(w.getSigningContext(), 1);
+    assert.strictEqual(w.getSigningContext(null), 1);
+    assert.strictEqual(w.getSigningContext(false), 1);
+    assert.strictEqual(w.getSigningContext(true), 1);
+  });
+
+  it("getSigningContext: throws for unsupported public key size", async () => {
+    await Initialize(null);
+    const w = qc.Wallet.fromPhrase(TEST_SEED_WORDS_32);
+    w.signingKey.publicKeyBytes = new Uint8Array(100);
+    assert.throws(() => w.getSigningContext(), /unsupported public key size/);
+  });
 });
 

package/test/unit/address-wallet.test.ts

@@ -546,4 +546,132 @@ describe("Address + Wallet (offline)", () => {
     assert.equal(w.address, addr5);
     assert.equal(qc.isAddress(w.address), true);
   });
+
+  // ---------------------------------------------------------------------------
+  // encryptSeedSync
+  // ---------------------------------------------------------------------------
+
+  it("encryptSeedSync: 32-word seed (64 bytes) roundtrip preserves address, privateKey, publicKey", async () => {
+    await Initialize(null);
+    const seedwords = require("seed-words");
+    const seedArr = seedwords.getSeedArrayFromWordList(TEST_SEED_WORDS_32);
+    assert.equal(seedArr.length, 64);
+    const ref = qc.Wallet.fromPhrase(TEST_SEED_WORDS_32);
+
+    const json = qc.Wallet.encryptSeedSync(Array.from(seedArr), PASSPHRASE_PHRASE);
+    assert.equal(typeof json, "string");
+    assert.ok(json.includes("address"));
+
+    const restored = qc.Wallet.fromEncryptedJsonSync(json, PASSPHRASE_PHRASE);
+    assert.equal(restored.address, ref.address);
+    assert.equal(restored.address, TEST_SEED_ADDRESS_32);
+    assert.equal(restored.privateKey, ref.privateKey);
+    assert.deepEqual(restored.signingKey.publicKeyBytes, ref.signingKey.publicKeyBytes);
+  });
+
+  it("encryptSeedSync: 36-word seed (72 bytes) roundtrip preserves address, privateKey, publicKey", async () => {
+    await Initialize(null);
+    const seedwords = require("seed-words");
+    const seedArr = seedwords.getSeedArrayFromWordList(TEST_SEED_WORDS_36);
+    assert.equal(seedArr.length, 72);
+    const ref = qc.Wallet.fromPhrase(TEST_SEED_WORDS_36);
+
+    const json = qc.Wallet.encryptSeedSync(Array.from(seedArr), PASSPHRASE_PHRASE);
+    assert.equal(typeof json, "string");
+    assert.ok(json.includes("address"));
+
+    const restored = qc.Wallet.fromEncryptedJsonSync(json, PASSPHRASE_PHRASE);
+    assert.equal(restored.address, ref.address);
+    assert.equal(restored.address, TEST_SEED_ADDRESS_36);
+    assert.equal(restored.privateKey, ref.privateKey);
+    assert.deepEqual(restored.signingKey.publicKeyBytes, ref.signingKey.publicKeyBytes);
+  });
+
+  it("encryptSeedSync: 48-word seed (96 bytes) roundtrip preserves address, privateKey, publicKey", async () => {
+    await Initialize(null);
+    const seedwords = require("seed-words");
+    const seedArr = seedwords.getSeedArrayFromWordList(TEST_SEED_WORDS);
+    assert.equal(seedArr.length, 96);
+    const ref = qc.Wallet.fromPhrase(TEST_SEED_WORDS);
+
+    const json = qc.Wallet.encryptSeedSync(Array.from(seedArr), PASSPHRASE_PHRASE);
+    assert.equal(typeof json, "string");
+    assert.ok(json.includes("address"));
+
+    const restored = qc.Wallet.fromEncryptedJsonSync(json, PASSPHRASE_PHRASE);
+    assert.equal(restored.address, ref.address);
+    assert.equal(restored.address, TEST_SEED_ADDRESS);
+    assert.equal(restored.privateKey, ref.privateKey);
+    assert.deepEqual(restored.signingKey.publicKeyBytes, ref.signingKey.publicKeyBytes);
+  });
+
+  it("encryptSeedSync accepts Uint8Array seed", async () => {
+    await Initialize(null);
+    const seedwords = require("seed-words");
+    const seedArr = seedwords.getSeedArrayFromWordList(TEST_SEED_WORDS_32);
+    const ref = qc.Wallet.fromPhrase(TEST_SEED_WORDS_32);
+
+    const json = qc.Wallet.encryptSeedSync(new Uint8Array(seedArr), PASSPHRASE_PHRASE);
+    const restored = qc.Wallet.fromEncryptedJsonSync(json, PASSPHRASE_PHRASE);
+    assert.equal(restored.address, ref.address);
+  });
+
+  it("encryptSeedSync rejects non-array seed input", async () => {
+    await Initialize(null);
+    assert.throws(() => qc.Wallet.encryptSeedSync("not an array" as any, PASSPHRASE_PHRASE), /seed must be an array/);
+    assert.throws(() => qc.Wallet.encryptSeedSync(12345 as any, PASSPHRASE_PHRASE), /seed must be an array/);
+    assert.throws(() => qc.Wallet.encryptSeedSync(null as any, PASSPHRASE_PHRASE), /seed must be an array/);
+  });
+
+  it("encryptSeedSync rejects wrong-length seed arrays", async () => {
+    await Initialize(null);
+    assert.throws(() => qc.Wallet.encryptSeedSync(new Array(32).fill(0), PASSPHRASE_PHRASE), /seed must be 64, 72, or 96 bytes/);
+    assert.throws(() => qc.Wallet.encryptSeedSync(new Array(48).fill(0), PASSPHRASE_PHRASE), /seed must be 64, 72, or 96 bytes/);
+    assert.throws(() => qc.Wallet.encryptSeedSync(new Array(100).fill(0), PASSPHRASE_PHRASE), /seed must be 64, 72, or 96 bytes/);
+    assert.throws(() => qc.Wallet.encryptSeedSync([], PASSPHRASE_PHRASE), /seed must be 64, 72, or 96 bytes/);
+  });
+
+  it("encryptSeedSync rejects password shorter than 12 characters", async () => {
+    await Initialize(null);
+    const seed = new Array(64).fill(1);
+    assert.throws(() => qc.Wallet.encryptSeedSync(seed, "short"), /serializeSeedAsEncryptedWallet failed/);
+  });
+
+  // ---------------------------------------------------------------------------
+  // getSigningContext
+  // ---------------------------------------------------------------------------
+
+  it("getSigningContext: 32-word wallet (pubKey 1408) returns 0 by default, 2 with fullSign", async () => {
+    await Initialize(null);
+    const w = qc.Wallet.fromPhrase(TEST_SEED_WORDS_32);
+    assert.strictEqual(w.getSigningContext(), 0);
+    assert.strictEqual(w.getSigningContext(null), 0);
+    assert.strictEqual(w.getSigningContext(false), 0);
+    assert.strictEqual(w.getSigningContext(true), 2);
+  });
+
+  it("getSigningContext: 48-word wallet (pubKey 1408) returns 0 by default, 2 with fullSign", async () => {
+    await Initialize(null);
+    const w = qc.Wallet.fromPhrase(TEST_SEED_WORDS);
+    assert.strictEqual(w.getSigningContext(), 0);
+    assert.strictEqual(w.getSigningContext(null), 0);
+    assert.strictEqual(w.getSigningContext(false), 0);
+    assert.strictEqual(w.getSigningContext(true), 2);
+  });
+
+  it("getSigningContext: 36-word wallet (pubKey 2688) returns 1 for all fullSign values", async () => {
+    await Initialize(null);
+    const w = qc.Wallet.fromPhrase(TEST_SEED_WORDS_36);
+    assert.strictEqual(w.getSigningContext(), 1);
+    assert.strictEqual(w.getSigningContext(null), 1);
+    assert.strictEqual(w.getSigningContext(false), 1);
+    assert.strictEqual(w.getSigningContext(true), 1);
+  });
+
+  it("getSigningContext: throws for unsupported public key size", async () => {
+    await Initialize(null);
+    const w = qc.Wallet.fromPhrase(TEST_SEED_WORDS_32);
+    (w.signingKey as any).publicKeyBytes = new Uint8Array(100);
+    assert.throws(() => w.getSigningContext(), /unsupported public key size/);
+  });
 });