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

package/test/sep7.test.ts

@@ -1,12 +1,17 @@
 import {
   Account,
+  Address,
   Asset,
   BASE_FEE,
   Keypair,
   Networks,
   Operation,
   StellarToml,
+  Transaction,
   TransactionBuilder,
+  nativeToScVal,
+  rpc,
+  xdr,
 } from "@stellar/stellar-sdk";
 import {
   NativeAssetId,
@@ -25,9 +30,19 @@ import {
   URI_REPLACE_MAX_LENGTH,
 } from "../src/walletSdk/Types";
 import {
+  Sep7ContractMemoError,
   Sep7InvalidUriError,
   Sep7LongMsgError,
 } from "../src/walletSdk/Exceptions";
+import {
+  MUXED_CONTRACT_BAD_CHECKSUM,
+  MUXED_CONTRACT_MAX_ID,
+  SEP23_CONTRACT,
+  SEP23_MUXED_CONTRACT,
+  TESTNET_NATIVE_SAC,
+  TRANSFER_TO_MUXED_CONTRACT_XDR,
+  transferRecipient,
+} from "./fixtures/muxedContract";
 
 const testKp1 = SigningKeypair.fromSecret(
   "SBKQDF56C5VY2YQTNQFGY7HM6R3V6QKDUEDXZQUCPQOP2EBZWG2QJ2JL",
@@ -700,7 +715,14 @@ describe("sep7Parser", () => {
     // With Soroban Contract destination
     expect(
       isValidSep7Uri(
-        "web+stellar:pay?destination=CAPECFLUT6KHYOOWUQNP7KC6PTMICKANBURFWRMPZTXUEEKHN67B7UI2&amount=120.1234567&memo=skdjfasf&memo_type=MEMO_TEXT&msg=pay%20me%20with%20lumens",
+        "web+stellar:pay?destination=CAPECFLUT6KHYOOWUQNP7KC6PTMICKANBURFWRMPZTXUEEKHN67B7UI2&amount=120.1234567&msg=pay%20me%20with%20lumens",
+      ).result,
+    ).toBe(true);
+
+    // With Muxed Contract destination
+    expect(
+      isValidSep7Uri(
+        `web+stellar:pay?destination=${SEP23_MUXED_CONTRACT}&amount=120.1234567&msg=pay%20me%20with%20lumens`,
       ).result,
     ).toBe(true);
   });
@@ -857,7 +879,14 @@ describe("sep7Parser", () => {
     // With Soroban Contract destination
     expect(
       parseSep7Uri(
-        "web+stellar:pay?destination=CAPECFLUT6KHYOOWUQNP7KC6PTMICKANBURFWRMPZTXUEEKHN67B7UI2&amount=120.123&asset_code=USD&asset_issuer=GCRCUE2C5TBNIPYHMEP7NK5RWTT2WBSZ75CMARH7GDOHDDCQH3XANFOB&memo=hasysda987fs&memo_type=MEMO_TEXT&callback=url%3Ahttps%3A%2F%2FsomeSigningService.com%2Fhasysda987fs%3Fasset%3DUSD",
+        "web+stellar:pay?destination=CAPECFLUT6KHYOOWUQNP7KC6PTMICKANBURFWRMPZTXUEEKHN67B7UI2&amount=120.123&asset_code=USD&asset_issuer=GCRCUE2C5TBNIPYHMEP7NK5RWTT2WBSZ75CMARH7GDOHDDCQH3XANFOB&callback=url%3Ahttps%3A%2F%2FsomeSigningService.com%2Fhasysda987fs%3Fasset%3DUSD",
+      ),
+    ).toBeInstanceOf(Sep7Pay);
+
+    // With Muxed Contract destination
+    expect(
+      parseSep7Uri(
+        `web+stellar:pay?destination=${SEP23_MUXED_CONTRACT}&amount=120.123&asset_code=USD&asset_issuer=GCRCUE2C5TBNIPYHMEP7NK5RWTT2WBSZ75CMARH7GDOHDDCQH3XANFOB&callback=url%3Ahttps%3A%2F%2FsomeSigningService.com%2Fhasysda987fs%3Fasset%3DUSD`,
       ),
     ).toBeInstanceOf(Sep7Pay);
   });
@@ -1067,3 +1096,191 @@ describe("SEP-7 byte encoding regressions", () => {
     expect(uri.getTransaction().toXdr()).toEqual(tx.toXdr());
   });
 });
+
+describe("SEP-7 with muxed contract (W) addresses", () => {
+  it.each([
+    ["mux ID 0", SEP23_MUXED_CONTRACT],
+    ["the largest mux ID", MUXED_CONTRACT_MAX_ID],
+  ])(
+    "parses a 'pay' uri to a W address with %s and keeps the address as given",
+    (_, destination) => {
+      const uri = parseSep7Uri(
+        `web+stellar:pay?destination=${destination}&amount=10&asset_code=USDC&asset_issuer=GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5`,
+      );
+
+      expect(uri).toBeInstanceOf(Sep7Pay);
+      expect((uri as Sep7Pay).destination).toBe(destination);
+    },
+  );
+
+  it("rejects a 'pay' uri to a W address whose checksum doesn't match", () => {
+    expect(
+      isValidSep7Uri(
+        `web+stellar:pay?destination=${MUXED_CONTRACT_BAD_CHECKSUM}&amount=10`,
+      ),
+    ).toEqual({
+      result: false,
+      reason:
+        "the provided 'destination' parameter is not a valid Stellar address",
+    });
+  });
+
+  it("parses a 'tx' uri whose transaction pays a W address", () => {
+    const uri = `web+stellar:tx?xdr=${encodeURIComponent(
+      TRANSFER_TO_MUXED_CONTRACT_XDR,
+    )}&network_passphrase=${encodeURIComponent(Networks.TESTNET)}`;
+
+    expect(isValidSep7Uri(uri)).toEqual({ result: true });
+
+    const tx = (parseSep7Uri(uri) as Sep7Tx).getTransaction();
+    expect(transferRecipient(tx)).toBe(MUXED_CONTRACT_MAX_ID);
+    expect(tx.toXdr()).toBe(TRANSFER_TO_MUXED_CONTRACT_XDR);
+  });
+});
+
+// Runs on testnet, which needs Protocol 30 for a W address to go on chain. A
+// dapp builds the transfer, has RPC add its Soroban data and passes it to a
+// wallet as a 'tx' uri, which the wallet signs and submits.
+describe("SEP-7 'tx' uri for a transfer to a W address, on testnet", () => {
+  it("is signed and submitted by a wallet, and the network keeps the W", async () => {
+    const stellar = Wallet.TestNet().stellar();
+    const sourceKp = stellar.account().createKeypair();
+    await stellar.fundTestnetAccount(sourceKp.publicKey);
+
+    const txBuilder = await stellar.transaction({ sourceAddress: sourceKp });
+    const transfer = txBuilder
+      .addOperation(
+        Operation.invokeContractFunction({
+          contract: TESTNET_NATIVE_SAC,
+          function: "transfer",
+          args: [
+            new Address(sourceKp.publicKey).toScVal(),
+            new Address(MUXED_CONTRACT_MAX_ID).toScVal(),
+            nativeToScVal(12345, { type: "i128" }),
+          ],
+        }),
+      )
+      .build();
+    const prepared = await new rpc.Server(
+      "https://soroban-testnet.stellar.org",
+    ).prepareTransaction(transfer);
+    const uri = Sep7Tx.forTransaction(prepared).toString();
+
+    expect(isValidSep7Uri(uri)).toEqual({ result: true });
+    const tx = (parseSep7Uri(uri) as Sep7Tx).getTransaction();
+    expect(transferRecipient(tx)).toBe(MUXED_CONTRACT_MAX_ID);
+
+    sourceKp.sign(tx);
+    expect(await stellar.submitTransaction(tx)).toBe(true);
+
+    const record = await stellar.server
+      .transactions()
+      .transaction(xdr.encodeBytes(tx.hash(), "hex"))
+      .call();
+    const onChain = stellar.decodeTransaction(
+      record.envelope_xdr,
+    ) as Transaction;
+    expect(transferRecipient(onChain)).toBe(MUXED_CONTRACT_MAX_ID);
+  }, 60000);
+});
+
+// A C or W address can only be paid with a Stellar Asset Contract transfer, and
+// that's a Soroban transaction, which can't carry a memo.
+describe("SEP-7 'pay' to a contract (C or W) address with a memo", () => {
+  it.each([
+    ["C", "a MEMO_TEXT", SEP23_CONTRACT, "&memo=skdjfasf&memo_type=MEMO_TEXT"],
+    ["C", "a MEMO_ID", SEP23_CONTRACT, "&memo=1234&memo_type=MEMO_ID"],
+    ["C", "an untyped", SEP23_CONTRACT, "&memo=skdjfasf"],
+    [
+      "W",
+      "a MEMO_TEXT",
+      SEP23_MUXED_CONTRACT,
+      "&memo=skdjfasf&memo_type=MEMO_TEXT",
+    ],
+    ["W", "a MEMO_ID", SEP23_MUXED_CONTRACT, "&memo=1234&memo_type=MEMO_ID"],
+    ["W", "an untyped", SEP23_MUXED_CONTRACT, "&memo=skdjfasf"],
+  ])(
+    "rejects a 'pay' uri to a %s address that has %s memo",
+    (_, __, destination, memoParams) => {
+      const uri = `web+stellar:pay?destination=${destination}&amount=10${memoParams}`;
+
+      expect(isValidSep7Uri(uri)).toEqual({
+        result: false,
+        reason:
+          "the 'memo' parameter is not supported for a contract ('C') or muxed contract ('W') 'destination'",
+      });
+      expect(() => parseSep7Uri(uri)).toThrow(Sep7InvalidUriError);
+    },
+  );
+});
+
+// Sep7Pay shouldn't build a uri that parseSep7Uri rejects.
+describe("Sep7Pay with a memo and a contract (C or W) destination", () => {
+  const ACCOUNT = "GCALNQQBXAPZ2WIRSDDBMSTAKCUH5SG6U76YBFLQLIXJTF7FE5AX7AOO";
+  const MUXED_ACCOUNT =
+    "MA7QYNF7SOWQ3GLR2BGMZEHXAVIRZA4KVWLTJJFC7MGXUA74P7UJUAAAAAAAAAABUTGI4";
+
+  describe.each([
+    ["C", SEP23_CONTRACT],
+    ["W", SEP23_MUXED_CONTRACT],
+  ])("to a %s address", (_, destination) => {
+    it("the memo setter throws and leaves the uri unchanged", () => {
+      const uri = Sep7Pay.forDestination(destination);
+
+      expect(() => {
+        uri.memo = "skdjfasf";
+      }).toThrow(Sep7ContractMemoError);
+      expect(uri.toString()).toBe(`web+stellar:pay?destination=${destination}`);
+    });
+
+    it("the destination setter throws on a uri that has a memo and leaves it unchanged", () => {
+      const uri = Sep7Pay.forDestination(ACCOUNT);
+      uri.memo = "skdjfasf";
+
+      expect(() => {
+        uri.destination = destination;
+      }).toThrow(Sep7ContractMemoError);
+      expect(uri.toString()).toBe(
+        `web+stellar:pay?destination=${ACCOUNT}&memo=skdjfasf`,
+      );
+    });
+
+    it("the constructor throws on a uri that has a memo", () => {
+      expect(
+        () =>
+          new Sep7Pay(
+            `web+stellar:pay?destination=${destination}&memo=skdjfasf`,
+          ),
+      ).toThrow(Sep7ContractMemoError);
+    });
+
+    it("builds a uri that parses once the memo is cleared", () => {
+      const uri = Sep7Pay.forDestination(ACCOUNT);
+      uri.memo = "skdjfasf";
+      uri.memo = undefined;
+      uri.destination = destination;
+      uri.amount = "10";
+
+      expect(() => {
+        uri.memo = undefined;
+      }).not.toThrow();
+      expect(uri.toString()).toBe(
+        `web+stellar:pay?destination=${destination}&amount=10`,
+      );
+      expect(parseSep7Uri(uri.toString())).toBeInstanceOf(Sep7Pay);
+    });
+  });
+
+  it.each([
+    ["G", ACCOUNT],
+    ["M", MUXED_ACCOUNT],
+  ])("the memo setter accepts a %s destination", (_, destination) => {
+    const uri = Sep7Pay.forDestination(destination);
+    uri.memo = "skdjfasf";
+
+    expect(uri.toString()).toBe(
+      `web+stellar:pay?destination=${destination}&memo=skdjfasf`,
+    );
+    expect(parseSep7Uri(uri.toString())).toBeInstanceOf(Sep7Pay);
+  });
+});

package/test/server.test.ts

@@ -277,6 +277,45 @@ describe("signChallengeTransaction validation", () => {
     ).rejects.toThrow(ChallengeValidationFailedError);
   });
 
+  // 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.
+  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 challenge = TransactionBuilder.cloneFrom(
+        TransactionBuilder.fromXDR(
+          buildChallenge(anchorAKp, anchorA, accountKp.publicKey),
+          networkPassphrase,
+        ) as Transaction,
+      )
+        .addOperation(
+          Operation.manageData({
+            name: "client_domain",
+            value: "wallet.example.com",
+            source:
+              clientDomainSource === "server"
+                ? anchorAKp.publicKey()
+                : undefined,
+          }),
+        )
+        .build();
+      challenge.sign(anchorAKp);
+
+      const result = Server.signChallengeTransaction({
+        accountKp,
+        challengeTx: challenge.toXDR(),
+        networkPassphrase,
+        anchorDomain: anchorA,
+      });
+      await expect(result).rejects.toThrow(ChallengeValidationFailedError);
+      await expect(result).rejects.toThrow(/client_domain/);
+    },
+  );
+
   it("should accept an explicit homeDomain that differs from anchorDomain", async () => {
     const homeDomain = "wallet-home.example.com";
     const challengeTx = buildChallenge(

package/test/stellar.test.ts

@@ -21,6 +21,11 @@ import {
   Assets,
 } from "../src/walletSdk/Asset";
 import { TransactionStatus, WithdrawTransaction } from "../src/walletSdk/Types";
+import {
+  MUXED_CONTRACT_MAX_ID,
+  TRANSFER_TO_MUXED_CONTRACT_XDR,
+  transferRecipient,
+} from "./fixtures/muxedContract";
 import {
   TransactionSubmitWithFeeIncreaseFailedError,
   WithdrawalTxMemoError,
@@ -496,6 +501,8 @@ let txnSourceKp;
 let sponsorKp;
 let newKp;
 describe("SponsoringBuilder", () => {
+  // One friendbot call can take 25 s or more on testnet, so this funds both
+  // accounts in parallel and allows 90 s.
   beforeAll(async () => {
     wal = Wallet.TestNet();
     stellar = wal.stellar();
@@ -503,13 +510,11 @@ describe("SponsoringBuilder", () => {
     txnSourceKp = new SigningKeypair(Keypair.random());
     sponsorKp = new SigningKeypair(Keypair.random());
     newKp = new SigningKeypair(Keypair.random());
-    await axios.get(
-      "https://friendbot.stellar.org/?addr=" + sponsorKp.publicKey,
-    );
-    await axios.get(
-      "https://friendbot.stellar.org/?addr=" + txnSourceKp.publicKey,
-    );
-  }, 30000);
+    await Promise.all([
+      axios.get("https://friendbot.stellar.org/?addr=" + sponsorKp.publicKey),
+      axios.get("https://friendbot.stellar.org/?addr=" + txnSourceKp.publicKey),
+    ]);
+  }, 90000);
 
   it("should sponsor creating an account", async () => {
     const wal = Wallet.TestNet();
@@ -644,6 +649,8 @@ describe("Asset", () => {
   });
 });
 
+// These tests wait on testnet, where one friendbot call can take 25 s or more,
+// so they fund their accounts in parallel and allow 90 s.
 describe("Account Modifying", () => {
   it("should modify account ", async () => {
     const wallet = Wallet.TestNet();
@@ -651,10 +658,10 @@ describe("Account Modifying", () => {
 
     const sourceKp = new SigningKeypair(Keypair.random());
     const otherKp = new SigningKeypair(Keypair.random());
-    await axios.get(
-      "https://friendbot.stellar.org/?addr=" + sourceKp.publicKey,
-    );
-    await axios.get("https://friendbot.stellar.org/?addr=" + otherKp.publicKey);
+    await Promise.all([
+      axios.get("https://friendbot.stellar.org/?addr=" + sourceKp.publicKey),
+      axios.get("https://friendbot.stellar.org/?addr=" + otherKp.publicKey),
+    ]);
 
     // Add account signer
     let txBuilder = await stellar.transaction({
@@ -718,7 +725,7 @@ describe("Account Modifying", () => {
 
     resp = await stellar.server.loadAccount(sourceKp.publicKey);
     expect(resp.signers[0].weight).toBe(0);
-  }, 45000);
+  }, 90000);
 
   it("should merge account", async () => {
     const wallet = Wallet.TestNet();
@@ -727,8 +734,10 @@ describe("Account Modifying", () => {
 
     const accountKp = account.createKeypair();
     const sourceKp = account.createKeypair();
-    await stellar.fundTestnetAccount(accountKp.publicKey);
-    await stellar.fundTestnetAccount(sourceKp.publicKey);
+    await Promise.all([
+      stellar.fundTestnetAccount(accountKp.publicKey),
+      stellar.fundTestnetAccount(sourceKp.publicKey),
+    ]);
 
     const txBuilder = await stellar.transaction({
       sourceAddress: accountKp,
@@ -753,7 +762,7 @@ describe("Account Modifying", () => {
     expect(found).toBeFalsy();
     const accResp = await stellar.server.loadAccount(accountKp.publicKey);
     expect(parseInt(accResp.balances[0].balance)).toBeGreaterThan(19998);
-  }, 30000);
+  }, 90000);
 });
 
 // Hermetic (no network): stellar-sdk v16 tightened Memo validation, so a
@@ -818,3 +827,14 @@ describe("transferWithdrawalTransaction memo validation", () => {
     ).toThrow(WithdrawalTxMemoError);
   });
 });
+
+describe("decodeTransaction with a muxed contract (W) address", () => {
+  it("decodes a transfer to a W address and re-encodes it unchanged", () => {
+    const tx = Wallet.TestNet()
+      .stellar()
+      .decodeTransaction(TRANSFER_TO_MUXED_CONTRACT_XDR) as Transaction;
+
+    expect(transferRecipient(tx)).toBe(MUXED_CONTRACT_MAX_ID);
+    expect(tx.toXdr()).toBe(TRANSFER_TO_MUXED_CONTRACT_XDR);
+  });
+});

package/test/transaction.test.ts

@@ -19,6 +19,7 @@ import {
 } from "../src";
 import { IssuedAssetId, NativeAssetId } from "../src/walletSdk/Asset";
 import { PathPayBoundRequiredError } from "../src/walletSdk/Exceptions";
+import { MUXED_CONTRACT_MAX_ID } from "./fixtures/muxedContract";
 
 describe("Muxed Transactions", () => {
   let wallet: Wallet;
@@ -424,3 +425,45 @@ describe("Path Payment bounds", () => {
     expect(op.destMin).toBe("0.9000000");
   });
 });
+
+// A muxed contract (W) address can only receive a Stellar Asset Contract
+// transfer, so no classic operation may take one as its destination.
+describe("classic operations to a muxed contract (W) address", () => {
+  const newBuilder = () =>
+    new TransactionBuilder(
+      new Config({
+        stellarConfiguration: StellarConfiguration.TestNet(),
+        applicationConfiguration: new ApplicationConfiguration(),
+      }),
+      new Account(Keypair.random().publicKey(), "0"),
+    );
+
+  it.each([
+    [
+      "transfer",
+      (builder: TransactionBuilder) =>
+        builder.transfer(MUXED_CONTRACT_MAX_ID, new NativeAssetId(), "1"),
+    ],
+    [
+      "pathPay",
+      (builder: TransactionBuilder) =>
+        builder.pathPay({
+          destinationAddress: MUXED_CONTRACT_MAX_ID,
+          sendAsset: new NativeAssetId(),
+          destAsset: new IssuedAssetId(
+            "USDC",
+            "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+          ),
+          sendAmount: "5",
+          destMin: "4.9",
+        }),
+    ],
+    [
+      "accountMerge",
+      (builder: TransactionBuilder) =>
+        builder.accountMerge(MUXED_CONTRACT_MAX_ID),
+    ],
+  ])("%s refuses a W destination", (_, addOperation) => {
+    expect(() => addOperation(newBuilder())).toThrow("destination is invalid");
+  });
+});

package/test/wallet.test.ts

@@ -2033,6 +2033,7 @@ describe("AuthHeaderSigner", () => {
   beforeAll(() => {
     jest.resetAllMocks();
   });
+  // One friendbot call can take 25 s or more on testnet, so this allows 90 s.
   it("full sep-10 auth using header token should work", async () => {
     const wallet = Wallet.TestNet();
     const accountKp = wallet.stellar().account().createKeypair();
@@ -2054,7 +2055,7 @@ describe("AuthHeaderSigner", () => {
     });
 
     expect(authToken).toBeTruthy();
-  }, 30000);
+  }, 90000);
 
   it("should match example implementation generated JWT", async () => {
     const generatedAuthToken =