@stellar/typescript-wallet-sdk 5.1.0 → 6.0.0-beta.1793996806758

package/lib/walletSdk/Exceptions/index.d.ts

@@ -172,6 +172,9 @@ export declare class Sep7InvalidUriError extends Error {
 export declare class Sep7LongMsgError extends Error {
     constructor(msgMaxLength: number);
 }
+export declare class Sep7ContractMemoError extends Error {
+    constructor();
+}
 export declare class Sep7UriTypeNotSupportedError extends Error {
     constructor(type: string);
 }

package/lib/walletSdk/Uri/Sep7Pay.d.ts

@@ -20,6 +20,8 @@ export declare class Sep7Pay extends Sep7Base {
      *
      * @constructor
      * @param {URL | string} [uri] - uri to initialize the Sep7 instance.
+     * @throws {Sep7ContractMemoError} if 'uri' has a memo and a contract ("C...")
+     * or muxed contract ("W...") destination.
      */
     constructor(uri?: URL | string);
     /**
@@ -32,6 +34,10 @@ export declare class Sep7Pay extends Sep7Base {
      * Gets the destination of the payment request, which should be a valid
      * Stellar address.
      *
+     * A contract ("C...") or muxed contract ("W...") destination can only be
+     * paid with a Stellar Asset Contract transfer, not a classic payment, and a
+     * uri with one can't have a memo.
+     *
      * @returns {string | undefined} the 'destination' uri param if present.
      */
     get destination(): string | undefined;
@@ -42,6 +48,8 @@ export declare class Sep7Pay extends Sep7Base {
      * Deletes the uri 'destination' param if set as 'undefined'.
      *
      * @param {string | undefined} destination the uri 'destination' param to be set.
+     * @throws {Sep7ContractMemoError} if 'destination' is a contract ("C...") or
+     * muxed contract ("W...") address and the uri has a memo.
      */
     set destination(destination: string | undefined);
     /**
@@ -102,6 +110,8 @@ export declare class Sep7Pay extends Sep7Base {
      * Deletes the uri 'memo' param if set as 'undefined'.
      *
      * @param {string | undefined} memo the uri 'memo' param to be set.
+     * @throws {Sep7ContractMemoError} if 'memo' is set and the uri's destination
+     * is a contract ("C...") or muxed contract ("W...") address.
      */
     set memo(memo: string | undefined);
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar/typescript-wallet-sdk",
-  "version": "5.1.0",
+  "version": "6.0.0-beta.1793996806758",
   "engines": {
     "node": ">=22.12.0"
   },
@@ -49,7 +49,7 @@
   "dependencies": {
     "@stablelib/base64": "^2.0.0",
     "@stablelib/utf8": "^2.0.0",
-    "@stellar/stellar-sdk": "17.0.1",
+    "@stellar/stellar-sdk": "17.4.0",
     "axios": "^1.4.0",
     "https-browserify": "^1.0.0",
     "jws": "^4.0.0",
@@ -77,4 +77,4 @@
     "example:sep24": "ts-node examples/sep24/sep24.ts",
     "example:sep12": "ts-node examples/sep12/sep12.ts"
   }
-}
+}

package/src/walletSdk/Exceptions/index.ts

@@ -474,6 +474,15 @@ export class Sep7LongMsgError extends Error {
   }
 }
 
+export class Sep7ContractMemoError extends Error {
+  constructor() {
+    super(
+      "the 'memo' parameter is not supported for a contract ('C') or muxed contract ('W') 'destination'",
+    );
+    Object.setPrototypeOf(this, Sep7ContractMemoError.prototype);
+  }
+}
+
 export class Sep7UriTypeNotSupportedError extends Error {
   constructor(type: string) {
     super(

package/src/walletSdk/Uri/Sep7Pay.ts

@@ -1,6 +1,31 @@
-import { MemoType } from "@stellar/stellar-sdk";
+import { MemoType, StrKey } from "@stellar/stellar-sdk";
 import { Sep7Base } from "../Uri";
 import { Sep7OperationType, WEB_STELLAR_SCHEME } from "../Types";
+import { Sep7ContractMemoError } from "../Exceptions";
+
+/**
+ * Throws if a uri would have a memo with a contract ("C...") or muxed
+ * contract ("W...") destination, which 'parseSep7Uri' rejects. Paying either
+ * takes a Soroban transaction, which can't have a memo.
+ *
+ * @param {string | undefined} destination the uri 'destination' param.
+ * @param {string | undefined} memo the uri 'memo' param.
+ * @throws {Sep7ContractMemoError} if both are set and 'destination' is a
+ * contract or muxed contract address.
+ */
+const assertNoContractMemo = (
+  destination: string | undefined,
+  memo: string | undefined,
+) => {
+  if (
+    memo &&
+    destination &&
+    (StrKey.isValidContract(destination) ||
+      StrKey.isValidMuxedContract(destination))
+  ) {
+    throw new Sep7ContractMemoError();
+  }
+};
 
 /**
  * The Sep-7 'pay' operation represents a request to pay a specific address
@@ -27,9 +52,13 @@ export class Sep7Pay extends Sep7Base {
    *
    * @constructor
    * @param {URL | string} [uri] - uri to initialize the Sep7 instance.
+   * @throws {Sep7ContractMemoError} if 'uri' has a memo and a contract ("C...")
+   * or muxed contract ("W...") destination.
    */
   constructor(uri?: URL | string) {
     super(uri ?? new URL(`${WEB_STELLAR_SCHEME}${Sep7OperationType.pay}`));
+
+    assertNoContractMemo(this.destination, this.memo);
   }
 
   /**
@@ -45,6 +74,10 @@ export class Sep7Pay extends Sep7Base {
    * Gets the destination of the payment request, which should be a valid
    * Stellar address.
    *
+   * A contract ("C...") or muxed contract ("W...") destination can only be
+   * paid with a Stellar Asset Contract transfer, not a classic payment, and a
+   * uri with one can't have a memo.
+   *
    * @returns {string | undefined} the 'destination' uri param if present.
    */
   get destination(): string | undefined {
@@ -58,8 +91,12 @@ export class Sep7Pay extends Sep7Base {
    * Deletes the uri 'destination' param if set as 'undefined'.
    *
    * @param {string | undefined} destination the uri 'destination' param to be set.
+   * @throws {Sep7ContractMemoError} if 'destination' is a contract ("C...") or
+   * muxed contract ("W...") address and the uri has a memo.
    */
   set destination(destination: string | undefined) {
+    assertNoContractMemo(destination, this.memo);
+
     this.setParam("destination", destination);
   }
 
@@ -142,8 +179,12 @@ export class Sep7Pay extends Sep7Base {
    * Deletes the uri 'memo' param if set as 'undefined'.
    *
    * @param {string | undefined} memo the uri 'memo' param to be set.
+   * @throws {Sep7ContractMemoError} if 'memo' is set and the uri's destination
+   * is a contract ("C...") or muxed contract ("W...") address.
    */
   set memo(memo: string | undefined) {
+    assertNoContractMemo(this.destination, memo);
+
     this.setParam("memo", memo);
   }
 

package/src/walletSdk/Uri/sep7Parser.ts

@@ -78,11 +78,15 @@ export const isValidSep7Uri = (uri: string): IsValidSep7UriResult => {
   }
 
   if (type === Sep7OperationType.pay && destination) {
-    // Checks if it's a valid "G", "M" or "C" Stellar address
+    const isContract =
+      StrKey.isValidContract(destination) ||
+      StrKey.isValidMuxedContract(destination);
+
+    // Checks if it's a valid "G", "M", "C" or "W" Stellar address
     const isValidStellarAddress =
       StrKey.isValidEd25519PublicKey(destination) ||
       StrKey.isValidMed25519PublicKey(destination) ||
-      StrKey.isValidContract(destination);
+      isContract;
 
     if (!isValidStellarAddress) {
       return {
@@ -91,6 +95,18 @@ export const isValidSep7Uri = (uri: string): IsValidSep7UriResult => {
           "the provided 'destination' parameter is not a valid Stellar address",
       };
     }
+
+    // A "C" (contract) or "W" (muxed contract) address can only be paid with
+    // a Stellar Asset Contract transfer. That's a Soroban transaction, which
+    // can't have a memo, so a wallet could only drop it. A "W" address's mux
+    // ID already identifies the payee.
+    if (isContract && url.searchParams.get("memo")) {
+      return {
+        result: false,
+        reason:
+          "the 'memo' parameter is not supported for a contract ('C') or muxed contract ('W') 'destination'",
+      };
+    }
   }
 
   if (msg?.length > URI_MSG_MAX_LENGTH) {

package/test/accountService.test.ts

@@ -11,7 +11,8 @@ let accountAddress: string;
 
 describe("Horizon", () => {
   // Creates testing stellar account with USDC trustline
-  // in case it doesn't exist just yet
+  // in case it doesn't exist just yet. One friendbot call can take 25 s or
+  // more on testnet, so this allows 90 s.
   beforeAll(async () => {
     const wallet = Wallet.TestNet();
     const stellar = wallet.stellar();
@@ -46,7 +47,7 @@ describe("Horizon", () => {
     await stellar.submitTransaction(addUsdcTx);
 
     accountAddress = testingAccountKp.publicKey;
-  }, 30000);
+  }, 90000);
 
   it("should return stellar account details", async () => {
     const response = await accountService.getInfo({ accountAddress });

package/test/auth.test.ts

@@ -726,6 +726,57 @@ describe("Sep10 challenge validation", () => {
     });
   });
 
+  // WebAuth.readChallengeTx checks these since stellar-sdk 17.3. SEP-10
+  // requires the client_domain operation's source to be the client domain's
+  // signing key.
+  describe("client_domain operation source", () => {
+    it.each([
+      ["has no source account", "none"],
+      ["uses the server account as its source", "server"],
+    ])(
+      "should reject a challenge whose client_domain operation %s",
+      async (_, clientDomainSource) => {
+        const serverKeypair = Keypair.random();
+        const clientKeypair = Keypair.random();
+        const { xdr } = buildChallenge({
+          serverKeypair,
+          clientKeypair,
+          additionalOps: [
+            Operation.manageData({
+              name: "client_domain",
+              value: "wallet.example.com",
+              source:
+                clientDomainSource === "server"
+                  ? serverKeypair.publicKey()
+                  : undefined,
+            }),
+          ],
+        });
+        const { sep10, postStub } = setupSep10({
+          serverSigningKey: serverKeypair.publicKey(),
+          challengeXdr: xdr,
+          token: createJwt(clientKeypair),
+        });
+        const signWithDomainAccount = sinon
+          .stub()
+          .rejects(new Error("the challenge should be rejected first"));
+
+        const result = sep10.authenticate({
+          accountKp: SigningKeypair.fromSecret(clientKeypair.secret()),
+          clientDomain: "wallet.example.com",
+          walletSigner: {
+            signWithClientAccount: ({ transaction }) => transaction,
+            signWithDomainAccount,
+          },
+        });
+        await expect(result).rejects.toThrow(ChallengeValidationFailedError);
+        await expect(result).rejects.toThrow(/client_domain/);
+        expect(signWithDomainAccount.notCalled).toBe(true);
+        expect(postStub.notCalled).toBe(true);
+      },
+    );
+  });
+
   describe("network passphrase mismatch", () => {
     it("should reject when server returns a different network passphrase", async () => {
       const { xdr, serverKeypair, clientKeypair } = buildChallenge();

package/test/e2e/reactNative.test.ts

@@ -19,9 +19,22 @@ import * as vm from "vm";
  */
 const BANNED = ["Buffer", "Event", "EventTarget", "process"];
 
+// Behaves like fast-text-encoding 1.0.6, a TextDecoder that React Native apps
+// commonly install on Hermes: its constructor throws for `{ fatal: true }`.
+const NonFatalTextDecoder = function (
+  label?: string,
+  options?: TextDecoderOptions,
+) {
+  if (options?.fatal) {
+    throw new RangeError("the 'fatal' option is unsupported");
+  }
+  return new TextDecoder(label, options);
+} as unknown as typeof TextDecoder;
+
 const makeHermesLikeContext = ({
   includeBase64 = true,
   includeTextCodec = true,
+  textDecoder = TextDecoder,
 } = {}) => {
   const sandbox: Record<string, unknown> = {
     console,
@@ -56,7 +69,7 @@ const makeHermesLikeContext = ({
     // "TypeError: globalThis.TextDecoder is not a constructor" at load —
     // before any of our own code runs. See the test below that enforces this.
     sandbox.TextEncoder = TextEncoder;
-    sandbox.TextDecoder = TextDecoder;
+    sandbox.TextDecoder = textDecoder;
   }
 
   if (includeBase64) {
@@ -126,6 +139,25 @@ describe("React Native (Hermes-like) bundle compatibility", () => {
     });
   }
 
+  for (const [name, relativePath] of bundles) {
+    it(`loads the ${name} bundle with a TextDecoder that can't decode strictly`, () => {
+      // stellar-sdk 17.3+ builds a strict (`{ fatal: true }`) TextDecoder only
+      // when it decodes something: a stellar.toml or federation response, or
+      // an XdrString read with toStringStrict(). Loading a bundle must not
+      // need one, or an app whose TextDecoder can't decode strictly would
+      // crash on startup instead of only on those calls.
+      const bundlePath = path.resolve(__dirname, relativePath);
+      const context = makeHermesLikeContext({
+        textDecoder: NonFatalTextDecoder,
+      });
+      const code = fs.readFileSync(bundlePath, "utf8");
+
+      expect(() =>
+        vm.runInContext(code, context, { filename: `${name}.js` }),
+      ).not.toThrow();
+    });
+  }
+
   it("exercises the core SDK public API in the sandbox", () => {
     const context = makeHermesLikeContext();
     const code = fs.readFileSync(
@@ -154,6 +186,85 @@ describe("React Native (Hermes-like) bundle compatibility", () => {
     expect(result.signature).toHaveLength(88);
   });
 
+  it("verifies a SEP-7 signature only with a TextDecoder that decodes strictly", async () => {
+    // Verifying reads the origin domain's stellar.toml, and stellar-sdk 17.3+
+    // decodes stellar.toml and federation responses with a strict
+    // (`{ fatal: true }`) TextDecoder. With a TextDecoder that can't build
+    // one, verifySignature() fails closed and returns false for a valid
+    // signature, and Anchor.sep1() rejects.
+    const verifyWith = (textDecoder: typeof TextDecoder) => {
+      const context = makeHermesLikeContext({ textDecoder });
+      // React Native provides these, and the SDK's stellar.toml fetch uses
+      // them. The fetch stub serves the toml that the code below writes.
+      Object.assign(context, {
+        Headers,
+        AbortController,
+        AbortSignal,
+        fetch: () => Promise.resolve(new Response(context.stellarToml)),
+      });
+      const code = fs.readFileSync(
+        path.resolve(__dirname, "../../lib/bundle_browser.js"),
+        "utf8",
+      );
+      vm.runInContext(code, context, { filename: "bundle_browser.js" });
+
+      return vm.runInContext(
+        `(() => {
+          const { Wallet, Sep7Pay } = module.exports;
+          const kp = Wallet.TestNet().stellar().account().createKeypair();
+          globalThis.stellarToml = 'URI_REQUEST_SIGNING_KEY="' + kp.publicKey + '"';
+          const uri = Sep7Pay.forDestination(kp.publicKey);
+          uri.originDomain = "example.com";
+          uri.addSignature(kp.keypair);
+          return uri.verifySignature();
+        })()`,
+        context,
+      ) as Promise<boolean>;
+    };
+
+    expect(await verifyWith(TextDecoder)).toBe(true);
+    expect(await verifyWith(NonFatalTextDecoder)).toBe(false);
+  });
+
+  it("reads an anchor's stellar.toml only with a TextDecoder that decodes strictly", async () => {
+    // Every anchor flow starts from Anchor.sep1(), which reads the anchor's
+    // stellar.toml. With a TextDecoder that can't decode strictly, it rejects.
+    const sep1With = (textDecoder: typeof TextDecoder) => {
+      const context = makeHermesLikeContext({ textDecoder });
+      // React Native defines `window` as the global object, and
+      // Wallet.anchor() reads `window.URL` through it.
+      Object.assign(context, {
+        window: context,
+        Headers,
+        AbortController,
+        AbortSignal,
+        fetch: () =>
+          Promise.resolve(
+            new Response(
+              'WEB_AUTH_ENDPOINT="https://example.com/auth"\n[DOCUMENTATION]\nORG_NAME="Example"\n',
+            ),
+          ),
+      });
+      const code = fs.readFileSync(
+        path.resolve(__dirname, "../../lib/bundle_browser.js"),
+        "utf8",
+      );
+      vm.runInContext(code, context, { filename: "bundle_browser.js" });
+
+      return vm.runInContext(
+        `module.exports.Wallet.TestNet().anchor({ homeDomain: "example.com" }).sep1()`,
+        context,
+      ) as Promise<{ webAuthEndpoint: string }>;
+    };
+
+    expect((await sep1With(TextDecoder)).webAuthEndpoint).toBe(
+      "https://example.com/auth",
+    );
+    await expect(sep1With(NonFatalTextDecoder)).rejects.toThrow(
+      "the 'fatal' option is unsupported",
+    );
+  });
+
   it("requires btoa/atob for base64 paths, while base32/StrKey keypair creation stays pure JS", () => {
     const context = makeHermesLikeContext({ includeBase64: false });
     const code = fs.readFileSync(

package/test/fixtures/muxedContract.ts

@@ -0,0 +1,47 @@
+import { Address, Operation, Transaction } from "@stellar/stellar-sdk";
+
+// Protocol 30 (CAP-84) muxed contract addresses: a contract ID plus a uint64
+// mux ID, encoded as a "W..." strkey.
+
+// SEP-23's test vector: this contract with mux ID 0.
+export const SEP23_CONTRACT =
+  "CA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUWDA";
+export const SEP23_MUXED_CONTRACT =
+  "WA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAAAWWC";
+
+// The same contract with the largest mux ID, 2^64 - 1, which a JS number
+// can't hold exactly.
+export const MUXED_CONTRACT_MAX_ID =
+  "WA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJV7777777777777GMO";
+
+// SEP23_MUXED_CONTRACT with its last character changed, so the checksum
+// doesn't match.
+export const MUXED_CONTRACT_BAD_CHECKSUM =
+  "WA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAAAAAWWA";
+
+export const TRANSFER_SOURCE =
+  "GDVEU3DD4KOFECV66VIHWEZOYX4ZKR3WV27L464SIIPOU2IUI3JCZA57";
+
+// The native XLM Stellar Asset Contract on testnet.
+export const TESTNET_NATIVE_SAC =
+  "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC";
+
+// An unsigned testnet transaction with one operation: TESTNET_NATIVE_SAC's
+// transfer(TRANSFER_SOURCE, MUXED_CONTRACT_MAX_ID, 12345). Its only Protocol 30
+// part is the `to` argument, an ScAddress of type SC_ADDRESS_TYPE_MUXED_CONTRACT.
+export const TRANSFER_TO_MUXED_CONTRACT_XDR =
+  "AAAAAgAAAADqSmxj4pxSCr71UHsTLsX5lUd2rr6+e5JCHuppFEbSLAAAAGQAAAAAAAAAZAAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAGAAAAAAAAAAB15KLcsJwPM/q9+uf9O9NUEpVqLl5/JtFDqLIQrTRzmEAAAAIdHJhbnNmZXIAAAADAAAAEgAAAAAAAAAA6kpsY+KcUgq+9VB7Ey7F+ZVHdq6+vnuSQh7qaRRG0iwAAAASAAAABf//////////Pww0v5OtDZlx0EzMkPcFURyDiq2XNKSi+w16A/x/6JoAAAAKAAAAAAAAAAAAAAAAAAAwOQAAAAAAAAAAAAAAAA==";
+
+// Reads the `to` argument of the transfer in a transaction like
+// TRANSFER_TO_MUXED_CONTRACT_XDR, as a strkey.
+export const transferRecipient = (tx: Transaction): string => {
+  const { func } = tx.operations[0] as Operation.InvokeHostFunction;
+  if (func.type !== "hostFunctionTypeInvokeContract") {
+    throw new Error(`expected a contract invocation, not ${func.type}`);
+  }
+  const to = func.invokeContract.args[1];
+  if (to.type !== "scvAddress") {
+    throw new Error(`expected an address, not ${to.type}`);
+  }
+  return Address.fromScAddress(to.address).toString();
+};

package/test/integration/anchorplatform.test.ts

@@ -9,6 +9,7 @@ let accountKp;
 const anchorUrl = "anchor-sep-server-dev.stellar.org";
 
 describe("Anchor Platform Integration Tests", () => {
+  // One friendbot call can take 25 s or more on testnet, so this allows 90 s.
   beforeAll(async () => {
     // Setup
     wallet = Wallet.TestNet();
@@ -16,7 +17,7 @@ describe("Anchor Platform Integration Tests", () => {
     anchor = wallet.anchor({ homeDomain: anchorUrl });
     accountKp = stellar.account().createKeypair();
     await stellar.fundTestnetAccount(accountKp.publicKey);
-  }, 30000);
+  }, 90000);
 
   it("SEP-10 auth should work", async () => {
     const auth = await anchor.sep10();

package/test/integration/recovery.test.ts

@@ -51,15 +51,15 @@ describe("Recovery Integration Tests", () => {
       await stellar.server.loadAccount(deviceKp.publicKey);
       await stellar.server.loadAccount(recoveryKp.publicKey);
     } catch (e) {
-      await axios.get(
-        "https://friendbot.stellar.org/?addr=" + accountKp.publicKey,
-      );
-      await axios.get(
-        "https://friendbot.stellar.org/?addr=" + deviceKp.publicKey,
-      );
-      await axios.get(
-        "https://friendbot.stellar.org/?addr=" + recoveryKp.publicKey,
-      );
+      // One friendbot call can take 25 s or more on testnet, so these run in
+      // parallel and the test allows 120 s.
+      await Promise.all([
+        axios.get("https://friendbot.stellar.org/?addr=" + accountKp.publicKey),
+        axios.get("https://friendbot.stellar.org/?addr=" + deviceKp.publicKey),
+        axios.get(
+          "https://friendbot.stellar.org/?addr=" + recoveryKp.publicKey,
+        ),
+      ]);
     }
 
     // Create SEP-30 identities
@@ -164,5 +164,5 @@ describe("Recovery Integration Tests", () => {
     expect(resp.signers.find((obj) => obj.key === newKp.publicKey).weight).toBe(
       10,
     );
-  }, 60000);
+  }, 120000);
 });

package/test/sep6.test.ts

@@ -7,6 +7,7 @@ let sep6;
 let accountKp;
 
 describe("SEP-6", () => {
+  // One friendbot call can take 25 s or more on testnet, so this allows 90 s.
   beforeAll(async () => {
     wallet = Wallet.TestNet();
     anchor = wallet.anchor({ homeDomain: "testanchor.stellar.org" });
@@ -16,7 +17,7 @@ describe("SEP-6", () => {
     await axios.get(
       "https://friendbot.stellar.org/?addr=" + accountKp.publicKey,
     );
-  }, 30000);
+  }, 90000);
 
   it("should get anchor info", async () => {
     const resp = await sep6.info();