@stellar/typescript-wallet-sdk 5.0.0 → 5.1.0

package/test/recovery.test.ts

@@ -1,7 +1,13 @@
 import axios from "axios";
 import { xdr } from "@stellar/stellar-sdk";
 
-import { SigningKeypair, Wallet } from "../src";
+import { AccountService, Recovery, SigningKeypair, Wallet } from "../src";
+import {
+  DuplicateAccountSignerError,
+  DuplicateRecoverySignerError,
+  RecoverySignerEqualsDeviceKeyError,
+  SignerKeyEqualsMasterKeyError,
+} from "../src/walletSdk/Exceptions";
 
 const testingAccountKp = SigningKeypair.fromSecret(
   "SDZZHNNOHOLFCAQ7XZZREXTXFTEPPT3L527WB2LVYCXODEDGTT6KBUSL",
@@ -17,29 +23,32 @@ const sponsorAccountKp = SigningKeypair.fromSecret(
 
 let wallet: Wallet;
 
-describe("Recovery / Register Signers", () => {
-  beforeAll(async () => {
-    wallet = Wallet.TestNet();
-    const stellar = wallet.stellar();
-
-    // make sure testing accounts exist
-    try {
-      await stellar.server.loadAccount(testingAccountKp.publicKey);
-    } catch (e) {
-      await axios.get(
-        "https://friendbot.stellar.org/?addr=" + testingAccountKp.publicKey,
-      );
-    }
+// Shared by every suite in this file. Kept at file scope rather than inside one
+// describe so that running either suite on its own — e.g. with a -t filter —
+// still gets a wallet and funded accounts.
+beforeAll(async () => {
+  wallet = Wallet.TestNet();
+  const stellar = wallet.stellar();
 
-    try {
-      await stellar.server.loadAccount(sponsorAccountKp.publicKey);
-    } catch (e) {
-      await axios.get(
-        "https://friendbot.stellar.org/?addr=" + sponsorAccountKp.publicKey,
-      );
-    }
-  }, 60000);
+  // make sure testing accounts exist
+  try {
+    await stellar.server.loadAccount(testingAccountKp.publicKey);
+  } catch (e) {
+    await axios.get(
+      "https://friendbot.stellar.org/?addr=" + testingAccountKp.publicKey,
+    );
+  }
 
+  try {
+    await stellar.server.loadAccount(sponsorAccountKp.publicKey);
+  } catch (e) {
+    await axios.get(
+      "https://friendbot.stellar.org/?addr=" + sponsorAccountKp.publicKey,
+    );
+  }
+}, 60000);
+
+describe("Recovery / Register Signers", () => {
   it("defaults work", async () => {
     const transaction = await wallet
       .recovery({ servers: {} })
@@ -105,3 +114,230 @@ describe("Recovery / Register Signers", () => {
     expect(transaction.operations.length).toBe(5);
   });
 });
+
+describe("Recovery / Signer set validation", () => {
+  const deviceKp = SigningKeypair.fromSecret(
+    "SC2VAILFM6DTF7MLDKFMK2RWQ4YTOYSKLMMXVNSRPYZ3VIA6L5WNCK4C",
+  );
+
+  const recoverySigner1Kp = SigningKeypair.fromSecret(
+    "SB42ZOPNSEGUGXBX4VE7ZQ6C5RRVX3JD3NU6V37QTWNPC4VF2LA2EXUF",
+  );
+
+  const recoverySigner2Kp = SigningKeypair.fromSecret(
+    "SANCUS65KI66LSQI2REKJODIWISJVJKYONMCFP4DF76IUFDCNHKVFHFD",
+  );
+
+  const threshold = { low: 10, medium: 10, high: 10 };
+
+  // Stand in for the SEP-30 enrolment round trip so these tests exercise the
+  // validation alone, with no recovery server or SEP-10 auth involved.
+  const mockEnrollment = (
+    signers: { serverKey: string; signerKey: string }[],
+  ) =>
+    jest
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      .spyOn(Recovery.prototype as any, "enrollWithRecoveryServer")
+      .mockResolvedValue(signers);
+
+  const recoverableWalletConfig = () => ({
+    accountAddress: testingAccountKp,
+    deviceAddress: deviceKp,
+    accountThreshold: threshold,
+    accountIdentity: {},
+    signerWeight: { device: 10, recoveryServer: 5 },
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("registerRecoveryServerSigners", () => {
+    it("rejects a signer set containing the same address twice", async () => {
+      await expect(
+        wallet.recovery({ servers: {} }).registerRecoveryServerSigners(
+          testingAccountKp,
+          [
+            { address: recoverySigner1Kp, weight: 5 },
+            { address: recoverySigner1Kp, weight: 5 },
+            { address: deviceKp, weight: 10 },
+          ],
+          threshold,
+        ),
+      ).rejects.toThrow(DuplicateAccountSignerError);
+    });
+
+    it("names the duplicated address", async () => {
+      await expect(
+        wallet.recovery({ servers: {} }).registerRecoveryServerSigners(
+          testingAccountKp,
+          [
+            { address: recoverySigner1Kp, weight: 5 },
+            { address: recoverySigner1Kp, weight: 5 },
+          ],
+          threshold,
+        ),
+      ).rejects.toThrow(recoverySigner1Kp.publicKey);
+    });
+
+    it("rejects a signer equal to the account being locked", async () => {
+      await expect(
+        wallet.recovery({ servers: {} }).registerRecoveryServerSigners(
+          testingAccountKp,
+          [
+            { address: testingAccountKp, weight: 5 },
+            { address: deviceKp, weight: 10 },
+          ],
+          threshold,
+        ),
+      ).rejects.toThrow(SignerKeyEqualsMasterKeyError);
+    });
+
+    it("validates before reaching the network", async () => {
+      const getInfo = jest.spyOn(AccountService.prototype, "getInfo");
+
+      await expect(
+        wallet.recovery({ servers: {} }).registerRecoveryServerSigners(
+          testingAccountKp,
+          [
+            { address: recoverySigner1Kp, weight: 5 },
+            { address: recoverySigner1Kp, weight: 5 },
+          ],
+          threshold,
+        ),
+      ).rejects.toThrow(DuplicateAccountSignerError);
+
+      expect(getInfo).not.toHaveBeenCalled();
+    });
+
+    it("accepts a distinct signer set", async () => {
+      const transaction = await wallet
+        .recovery({ servers: {} })
+        .registerRecoveryServerSigners(
+          testingAccountKp,
+          [
+            { address: recoverySigner1Kp, weight: 5 },
+            { address: recoverySigner2Kp, weight: 5 },
+            { address: deviceKp, weight: 10 },
+          ],
+          threshold,
+        );
+
+      expect(transaction.toXDR()).toBeTruthy();
+    });
+  });
+
+  describe("createRecoverableWallet", () => {
+    it("rejects two servers returning the same signer key", async () => {
+      mockEnrollment([
+        { serverKey: "server1", signerKey: recoverySigner1Kp.publicKey },
+        { serverKey: "server2", signerKey: recoverySigner1Kp.publicKey },
+      ]);
+
+      await expect(
+        wallet
+          .recovery({ servers: {} })
+          .createRecoverableWallet(recoverableWalletConfig()),
+      ).rejects.toThrow(DuplicateRecoverySignerError);
+    });
+
+    it("names both offending servers and the shared key", async () => {
+      mockEnrollment([
+        { serverKey: "server1", signerKey: recoverySigner1Kp.publicKey },
+        { serverKey: "server2", signerKey: recoverySigner1Kp.publicKey },
+      ]);
+
+      const error = await wallet
+        .recovery({ servers: {} })
+        .createRecoverableWallet(recoverableWalletConfig())
+        .catch((e) => e);
+
+      expect(error.message).toContain("server1");
+      expect(error.message).toContain("server2");
+      expect(error.message).toContain(recoverySigner1Kp.publicKey);
+    });
+
+    it("rejects a server returning the device key", async () => {
+      mockEnrollment([
+        { serverKey: "server1", signerKey: recoverySigner1Kp.publicKey },
+        { serverKey: "server2", signerKey: deviceKp.publicKey },
+      ]);
+
+      await expect(
+        wallet
+          .recovery({ servers: {} })
+          .createRecoverableWallet(recoverableWalletConfig()),
+      ).rejects.toThrow(RecoverySignerEqualsDeviceKeyError);
+    });
+
+    it("rejects a server returning the account key", async () => {
+      mockEnrollment([
+        { serverKey: "server1", signerKey: recoverySigner1Kp.publicKey },
+        { serverKey: "server2", signerKey: testingAccountKp.publicKey },
+      ]);
+
+      await expect(
+        wallet
+          .recovery({ servers: {} })
+          .createRecoverableWallet(recoverableWalletConfig()),
+      ).rejects.toThrow(SignerKeyEqualsMasterKeyError);
+    });
+
+    it("installs one distinct signer per server plus the device", async () => {
+      mockEnrollment([
+        { serverKey: "server1", signerKey: recoverySigner1Kp.publicKey },
+        { serverKey: "server2", signerKey: recoverySigner2Kp.publicKey },
+      ]);
+
+      const { transaction, signers } = await wallet
+        .recovery({ servers: {} })
+        .createRecoverableWallet(recoverableWalletConfig());
+
+      expect(signers).toEqual([
+        recoverySigner1Kp.publicKey,
+        recoverySigner2Kp.publicKey,
+      ]);
+
+      // This is the assertion that would have caught the original bug: the
+      // signer set reaching the ledger must have the cardinality we intended,
+      // because SetOptions overwrites rather than accumulates.
+      const signerAddresses = transaction.operations
+        .filter((op) => op.type === "setOptions" && op.signer)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .map((op: any) => op.signer.ed25519PublicKey);
+
+      expect(new Set(signerAddresses).size).toBe(3);
+      expect(signerAddresses).toEqual(
+        expect.arrayContaining([
+          recoverySigner1Kp.publicKey,
+          recoverySigner2Kp.publicKey,
+          deviceKp.publicKey,
+        ]),
+      );
+    });
+
+    it("produces the weight profile the integration test asserts on-chain", async () => {
+      mockEnrollment([
+        { serverKey: "server1", signerKey: recoverySigner1Kp.publicKey },
+        { serverKey: "server2", signerKey: recoverySigner2Kp.publicKey },
+      ]);
+
+      const { transaction } = await wallet
+        .recovery({ servers: {} })
+        .createRecoverableWallet(recoverableWalletConfig());
+
+      // Mirrors test/integration/recovery.test.ts, which asserts the submitted
+      // account ends up with signer weights [0, 5, 5, 10]. Guards against the
+      // new validation false-rejecting a correct two-server enrolment.
+      const weights = transaction.operations
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .filter((op: any) => op.type === "setOptions" && op.signer)
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        .map((op: any) => op.signer.weight)
+        .concat(0) // the locked master key
+        .sort((a: number, b: number) => a - b);
+
+      expect(weights).toEqual([0, 5, 5, 10]);
+    });
+  });
+});

package/test/sep38.test.ts

@@ -11,7 +11,7 @@ describe("SEP-38", () => {
     anchor = wallet.anchor({ homeDomain: "testanchor.stellar.org" });
     sep38 = anchor.sep38();
     accountKp = accountKp = wallet.stellar().account().createKeypair();
-  }, 10000);
+  }, 30000);
 
   it("should get Sep-38 anchor info", async () => {
     const resp = await sep38.info();

package/test/sep6.test.ts

@@ -16,7 +16,7 @@ describe("SEP-6", () => {
     await axios.get(
       "https://friendbot.stellar.org/?addr=" + accountKp.publicKey,
     );
-  }, 10000);
+  }, 30000);
 
   it("should get anchor info", async () => {
     const resp = await sep6.info();
@@ -172,7 +172,7 @@ describe("SEP-6", () => {
     resp = await anchor.sep6().getTransactionBy({ authToken, id });
 
     expect(resp.id).toEqual(id);
-  }, 10000);
+  }, 30000);
 
   let txId;
 

package/test/stellar.test.ts

@@ -45,7 +45,7 @@ describe("Stellar", () => {
     } catch (e) {
       await stellar.fundTestnetAccount(kp.publicKey);
     }
-  }, 10000);
+  }, 30000);
 
   it("should create and submit a transaction", async () => {
     const now = Math.floor(Date.now() / 1000) - 5;
@@ -130,7 +130,7 @@ describe("Stellar", () => {
     const feeBumpTx = stellar.makeFeeBump({ feeAddress: kp, transaction });
     kp.sign(feeBumpTx);
     await stellar.submitTransaction(feeBumpTx);
-  }, 10000);
+  }, 30000);
 
   it("should be able to give a signing keypair", async () => {
     // mock 1 failed response and then 1 successful to test retry
@@ -242,7 +242,7 @@ describe("Stellar", () => {
       (b) => (b as Horizon.HorizonApi.BalanceLineAsset).asset_code === "USDC",
     );
     expect(balance).toBeFalsy();
-  }, 20000);
+  }, 30000);
 
   it("should import and sign a transaction from xdr", () => {
     const txnXdr =
@@ -373,7 +373,7 @@ describe("Stellar", () => {
           .build();
         expect(txn).toBeTruthy();
       }
-    }, 20000);
+    }, 30000);
 
     it("should throw if tx not in pending_user_transfer_start status", async () => {
       const walletTransaction = {
@@ -402,7 +402,7 @@ describe("Stellar", () => {
           .transferWithdrawalTransaction(walletTransaction, asset)
           .build();
       }).toThrowError(WithdrawalTxNotPendingUserTransferStartError);
-    }, 5000);
+    }, 30000);
 
     it("should throw if tx is missing withdraw_anchor_account", async () => {
       const walletTransaction = {
@@ -430,7 +430,7 @@ describe("Stellar", () => {
           .transferWithdrawalTransaction(walletTransaction, asset)
           .build();
       }).toThrowError(WithdrawalTxMissingDestinationError);
-    }, 5000);
+    }, 30000);
 
     it("should throw if tx is missing withdraw_memo_type", async () => {
       const walletTransaction = {
@@ -459,7 +459,7 @@ describe("Stellar", () => {
           .transferWithdrawalTransaction(walletTransaction, asset)
           .build();
       }).toThrowError(WithdrawalTxMissingMemoError);
-    }, 5000);
+    }, 30000);
 
     it("should throw if tx is missing withdraw_memo", async () => {
       const walletTransaction = {
@@ -488,7 +488,7 @@ describe("Stellar", () => {
           .transferWithdrawalTransaction(walletTransaction, asset)
           .build();
       }).toThrowError(WithdrawalTxMissingMemoError);
-    }, 5000);
+    }, 30000);
   });
 });
 
@@ -509,7 +509,7 @@ describe("SponsoringBuilder", () => {
     await axios.get(
       "https://friendbot.stellar.org/?addr=" + txnSourceKp.publicKey,
     );
-  }, 15000);
+  }, 30000);
 
   it("should sponsor creating an account", async () => {
     const wal = Wallet.TestNet();
@@ -535,7 +535,7 @@ describe("SponsoringBuilder", () => {
       newKp.publicKey,
     )) as any;
     expect(sponsoredLoaded.num_sponsored).toBe(2);
-  }, 15000);
+  }, 30000);
 
   it("should sponsor adding trustlines", async () => {
     const txBuilder = await stellar.transaction({
@@ -560,7 +560,7 @@ describe("SponsoringBuilder", () => {
       sponsorKp.publicKey,
     )) as any;
     expect(sponsorLoaded.num_sponsoring).toBe(3);
-  }, 15000);
+  }, 30000);
 
   it("should allow sponsoring and regular operations in same transaction", async () => {
     const txBuilder = await stellar.transaction({
@@ -588,7 +588,7 @@ describe("SponsoringBuilder", () => {
       sponsorKp.publicKey,
     )) as any;
     expect(sponsorLoaded.num_sponsoring).toBe(3);
-  }, 15000);
+  }, 30000);
   it("should sponsor account modification", async () => {
     const txBuilder = await stellar.transaction({
       sourceAddress: txnSourceKp,
@@ -610,7 +610,7 @@ describe("SponsoringBuilder", () => {
       sourceLoaded.signers.find((signer) => signer.key === otherKp.publicKey)
         .weight,
     ).toBe(2);
-  }, 15000);
+  }, 30000);
 });
 
 describe("Asset", () => {

package/test/transaction.test.ts

@@ -293,7 +293,7 @@ describe("Path Payment", () => {
       sourceKp.sign(txn);
       await stellar.submitTransaction(txn);
     }
-  }, 20000);
+  }, 30000);
 
   it("should use path payment send", async () => {
     const txBuilder = await stellar.transaction({
@@ -309,7 +309,7 @@ describe("Path Payment", () => {
       })
       .build();
     expect(txn.operations[0].type).toBe("pathPaymentStrictSend");
-  }, 15000);
+  }, 30000);
 
   it("should use path payment receive", async () => {
     const txBuilder = await stellar.transaction({
@@ -325,7 +325,7 @@ describe("Path Payment", () => {
       })
       .build();
     expect(txn.operations[0].type).toBe("pathPaymentStrictReceive");
-  }, 15000);
+  }, 30000);
 
   it("should swap", async () => {
     const txBuilder = await stellar.transaction({
@@ -337,7 +337,7 @@ describe("Path Payment", () => {
     sourceKp.sign(txn);
     const success = await stellar.submitTransaction(txn);
     expect(success).toBe(true);
-  }, 15000);
+  }, 30000);
 });
 
 describe("Path Payment bounds", () => {

package/test/wallet.test.ts

@@ -2054,7 +2054,7 @@ describe("AuthHeaderSigner", () => {
     });
 
     expect(authToken).toBeTruthy();
-  }, 15000);
+  }, 30000);
 
   it("should match example implementation generated JWT", async () => {
     const generatedAuthToken =