@stellar/typescript-wallet-sdk 1.1.2 → 1.2.0

package/test/stellar.test.ts

@@ -36,14 +36,13 @@ describe("Stellar", () => {
     } catch (e) {
       await axios.get("https://friendbot.stellar.org/?addr=" + kp.publicKey);
     }
-  });
+  }, 10000);
   it("should create and submit a transaction", async () => {
     const now = Math.floor(Date.now() / 1000) - 5;
 
     const txBuilderParams = [
       {
         sourceAddress: kp,
-        baseFee: 100,
         startingBalance: 2,
       },
       {
@@ -198,32 +197,174 @@ describe("Stellar", () => {
     kp.sign(tx);
   });
   it("should transfer withdrawal transaction", async () => {
-    const walletTransaction = {
-      id: "db15d166-5a5e-4d5c-ba5d-271c32cd8cf0",
-      kind: "withdrawal",
-      status: TransactionStatus.pending_user_transfer_start,
-      amount_in: "50.55",
-      withdraw_memo_type: "text",
-      withdraw_memo: "the withdraw memo",
-      withdraw_anchor_account:
-        "GCSGSR6KQQ5BP2FXVPWRL6SWPUSFWLVONLIBJZUKTVQB5FYJFVL6XOXE",
-    } as WithdrawTransaction;
+    const memoExamples = [
+      {
+        type: "text",
+        value: "example text",
+      },
+      {
+        type: "id",
+        value: "12345",
+      },
+      {
+        type: "hash",
+        value: "AAAAAAAAAAAAAAAAAAAAAMAP+8deo0TViBD09TfOBY0=",
+      },
+      {
+        type: "hash",
+        value: "MV9b23bQeMQ7isAGTkoBZGErH853yGk0W/yUx1iU7dM=",
+      },
+    ];
 
-    const asset = new IssuedAssetId(
-      "USDC",
-      "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+    for (const memoExample of memoExamples) {
+      const walletTransaction = {
+        id: "db15d166-5a5e-4d5c-ba5d-271c32cd8cf0",
+        kind: "withdrawal",
+        status: TransactionStatus.pending_user_transfer_start,
+        amount_in: "50.55",
+        withdraw_memo_type: memoExample.type,
+        withdraw_memo: memoExample.value,
+        withdraw_anchor_account:
+          "GCSGSR6KQQ5BP2FXVPWRL6SWPUSFWLVONLIBJZUKTVQB5FYJFVL6XOXE",
+      } as WithdrawTransaction;
+
+      const asset = new IssuedAssetId(
+        "USDC",
+        "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+      );
+
+      const txBuilder = await stellar.transaction({
+        sourceAddress: kp,
+        baseFee: 100,
+      });
+
+      const txn = txBuilder
+        .transferWithdrawalTransaction(walletTransaction, asset)
+        .build();
+      expect(txn).toBeTruthy();
+    }
+  }, 20000);
+});
+
+let txnSourceKp;
+let sponsorKp;
+let newKp;
+describe("SponsoringBuilder", () => {
+  beforeAll(async () => {
+    wal = Wallet.TestNet();
+    stellar = wal.stellar();
+
+    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,
+    );
+  }, 15000);
+
+  it("should sponsor creating an account", async () => {
+    const wal = Wallet.TestNet();
+    const stellar = wal.stellar();
 
     const txBuilder = await stellar.transaction({
-      sourceAddress: kp,
+      sourceAddress: txnSourceKp,
+      baseFee: 100,
+    });
+    const buildingFunction = (bldr) => bldr.createAccount(newKp, 0);
+    // scenario of different txn source account from sponsor account
+    const txn = txBuilder
+      .sponsoring(sponsorKp, buildingFunction, newKp)
+      .build();
+    newKp.sign(txn);
+    txnSourceKp.sign(txn);
+    sponsorKp.sign(txn);
+
+    const res = await stellar.submitTransaction(txn);
+    expect(res).toBe(true);
+
+    const sponsoredLoaded = (await stellar.server.loadAccount(
+      newKp.publicKey,
+    )) as any;
+    expect(sponsoredLoaded.num_sponsored).toBe(2);
+  }, 15000);
+
+  it("should sponsor adding trustlines", async () => {
+    const txBuilder = await stellar.transaction({
+      sourceAddress: txnSourceKp,
       baseFee: 100,
     });
+    const buildingFunction = (bldr) =>
+      bldr.addAssetSupport(
+        new IssuedAssetId(
+          "USDC",
+          "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+        ),
+      );
+    const txn = txBuilder.sponsoring(sponsorKp, buildingFunction).build();
+    sponsorKp.sign(txn);
+    txnSourceKp.sign(txn);
 
+    const res = await stellar.submitTransaction(txn);
+    expect(res).toBe(true);
+
+    const sponsorLoaded = (await stellar.server.loadAccount(
+      sponsorKp.publicKey,
+    )) as any;
+    expect(sponsorLoaded.num_sponsoring).toBe(3);
+  }, 15000);
+
+  it("should allow sponsoring and regular operations in same transaction", async () => {
+    const txBuilder = await stellar.transaction({
+      sourceAddress: txnSourceKp,
+      baseFee: 100,
+    });
+    const buildingFunction = (bldr) =>
+      bldr.addAssetSupport(
+        new IssuedAssetId(
+          "USDC",
+          "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+        ),
+      );
     const txn = txBuilder
-      .transferWithdrawalTransaction(walletTransaction, asset)
+      .sponsoring(sponsorKp, buildingFunction)
+      .transfer(sponsorKp.publicKey, new NativeAssetId(), "5")
       .build();
-    expect(txn).toBeTruthy();
-  });
+    sponsorKp.sign(txn);
+    txnSourceKp.sign(txn);
+
+    const res = await stellar.submitTransaction(txn);
+    expect(res).toBe(true);
+
+    const sponsorLoaded = (await stellar.server.loadAccount(
+      sponsorKp.publicKey,
+    )) as any;
+    expect(sponsorLoaded.num_sponsoring).toBe(3);
+  }, 15000);
+  it("should sponsor account modification", async () => {
+    const txBuilder = await stellar.transaction({
+      sourceAddress: txnSourceKp,
+      baseFee: 100,
+    });
+    const otherKp = new SigningKeypair(Keypair.random());
+
+    const txn = txBuilder
+      .sponsoring(sponsorKp, (bldr) => bldr.addAccountSigner(otherKp, 2))
+      .build();
+    sponsorKp.sign(txn);
+    txnSourceKp.sign(txn);
+
+    await stellar.submitTransaction(txn);
+    const sourceLoaded = (await stellar.server.loadAccount(
+      txnSourceKp.publicKey,
+    )) as any;
+    expect(
+      sourceLoaded.signers.find((signer) => signer.key === otherKp.publicKey)
+        .weight,
+    ).toBe(2);
+  }, 15000);
 });
 
 describe("Asset", () => {
@@ -245,3 +386,80 @@ describe("Asset", () => {
     expect(fiat.sep38).toBe("iso4217:USD");
   });
 });
+
+describe("Account Modifying", () => {
+  it("should modify account ", async () => {
+    const wallet = Wallet.TestNet();
+    const stellar = wallet.stellar();
+
+    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);
+
+    // Add account signer
+    let txBuilder = await stellar.transaction({
+      sourceAddress: sourceKp,
+      baseFee: 1000,
+    });
+    const tx = txBuilder.addAccountSigner(otherKp, 1).build();
+    tx.sign(sourceKp.keypair);
+    await stellar.submitTransaction(tx);
+
+    let resp = await stellar.server.loadAccount(sourceKp.publicKey);
+
+    expect(
+      resp.signers.find((signer) => signer.key === sourceKp.publicKey),
+    ).toBeTruthy();
+    expect(
+      resp.signers.find((signer) => signer.key === otherKp.publicKey),
+    ).toBeTruthy();
+
+    // Remove account signer
+    txBuilder = await stellar.transaction({
+      sourceAddress: sourceKp,
+      baseFee: 1000,
+    });
+    const removeTx = txBuilder.removeAccountSigner(otherKp).build();
+    removeTx.sign(sourceKp.keypair);
+    await stellar.submitTransaction(removeTx);
+
+    resp = await stellar.server.loadAccount(sourceKp.publicKey);
+    expect(
+      resp.signers.find((signer) => signer.key === sourceKp.publicKey),
+    ).toBeTruthy();
+    expect(
+      resp.signers.find((signer) => signer.key === otherKp.publicKey),
+    ).toBeFalsy();
+
+    // Change account thresholds
+    txBuilder = await stellar.transaction({
+      sourceAddress: sourceKp,
+      baseFee: 1000,
+    });
+    const thresholdTx = txBuilder.setThreshold({ low: 0, high: 1 }).build();
+    thresholdTx.sign(sourceKp.keypair);
+    await stellar.submitTransaction(thresholdTx);
+
+    resp = await stellar.server.loadAccount(sourceKp.publicKey);
+    expect(resp.thresholds).toEqual({
+      low_threshold: 0,
+      med_threshold: 0,
+      high_threshold: 1,
+    });
+
+    // Lock master account
+    txBuilder = await stellar.transaction({
+      sourceAddress: sourceKp,
+      baseFee: 1000,
+    });
+    const lockTx = txBuilder.lockAccountMasterKey().build();
+    lockTx.sign(sourceKp.keypair);
+    await stellar.submitTransaction(lockTx);
+
+    resp = await stellar.server.loadAccount(sourceKp.publicKey);
+    expect(resp.signers[0].weight).toBe(0);
+  }, 45000);
+});

package/test/transaction.test.ts

@@ -0,0 +1,325 @@
+import axios from "axios";
+import { Horizon, MuxedAccount } from "stellar-sdk";
+
+import { AccountService, SigningKeypair, Stellar, Wallet } from "../src";
+import { IssuedAssetId, NativeAssetId } from "../src/walletSdk/Asset";
+
+describe("Muxed Transactions", () => {
+  let wallet: Wallet;
+  let stellar: Stellar;
+  let accountService: AccountService;
+  let testingDistributionKp: SigningKeypair;
+  let testingAsset: IssuedAssetId;
+
+  // Creates testing stellar account with testing TSWT asset
+  // in case it doesn't exist just yet
+  beforeAll(async () => {
+    wallet = Wallet.TestNet();
+    stellar = wallet.stellar();
+    accountService = stellar.account();
+
+    // Keys for accounts to issue and receive the new TSWT asset
+    var issuingKeys = SigningKeypair.fromSecret(
+      "SAJMJSEC44DWU22TJF6RWYLRPPXLY4G3L5PVGC7D2QDUCPJIFCOISNQE",
+    );
+    var receivingKeys = SigningKeypair.fromSecret(
+      "SAOQQ76UQFEYN4QAAAOIO45KNZZNQKSXAUB5GXKI6YOFLEDCWPWTCDM3",
+    );
+
+    // The "receiving" account is the distribution account
+    testingDistributionKp = receivingKeys;
+
+    // This is the testing asset we'll use to test sending non-native payments
+    testingAsset = new IssuedAssetId("TSWT", issuingKeys.publicKey);
+
+    let assetAlreadyCreated = false;
+    try {
+      const receivingAccountInfo = await accountService.getInfo({
+        accountAddress: receivingKeys.publicKey,
+      });
+
+      const tswtAssetBalance = receivingAccountInfo.balances.find(
+        (balanceLine) => {
+          const { asset_code, balance } =
+            balanceLine as Horizon.BalanceLineAsset;
+          return asset_code === testingAsset.code && Number(balance) > 1000;
+        },
+      );
+
+      if (tswtAssetBalance) {
+        assetAlreadyCreated = true;
+      }
+    } catch {}
+
+    if (assetAlreadyCreated) {
+      return;
+    }
+
+    // If the TSWT asset is not there yet, let's issue and distribute it!
+    try {
+      // First make sure both issuing and receiving(distribution) accounts
+      // are funded
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + issuingKeys.publicKey,
+      );
+
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + receivingKeys.publicKey,
+      );
+    } catch {}
+
+    let didFail = false;
+    try {
+      // Then, the receiving(distribution) account must trust the asset
+      const txBuilder = await stellar.transaction({
+        sourceAddress: receivingKeys,
+        baseFee: 100,
+      });
+      const addTswtTx = txBuilder.addAssetSupport(testingAsset).build();
+      addTswtTx.sign(receivingKeys.keypair);
+      await stellar.submitTransaction(addTswtTx);
+
+      // Finally, the issuing account actually sends a payment using the asset
+      // to fund the receiving(distribution) account
+      const txBuilder2 = await stellar.transaction({
+        sourceAddress: issuingKeys,
+        baseFee: 100,
+      });
+      const fundingPaymentTx = txBuilder2
+        .transfer(receivingKeys.publicKey, testingAsset, "100000000")
+        .build();
+      fundingPaymentTx.sign(issuingKeys.keypair);
+      await stellar.submitTransaction(fundingPaymentTx);
+    } catch {
+      didFail = true;
+    }
+
+    expect(didFail).toBeFalsy();
+  }, 60000);
+
+  it("should send 'native' payment to valid Muxed account", async () => {
+    const baseAccoutKp = SigningKeypair.fromSecret(
+      "SDC4SZWQDELBKWPBPBLZSKMWAIPNE27OF6BPJV7F7FCXTKHBACN3KWRO",
+    );
+
+    try {
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + baseAccoutKp.publicKey,
+      );
+    } catch {}
+
+    const baseAccount = await stellar.server.loadAccount(
+      baseAccoutKp.publicKey,
+    );
+    const muxedAccount = new MuxedAccount(baseAccount, "123");
+
+    const txBuilder = await stellar.transaction({
+      sourceAddress: testingDistributionKp,
+      baseFee: 100,
+    });
+
+    const sendNativePaymentTx = txBuilder
+      .transfer(muxedAccount.accountId(), new NativeAssetId(), "1")
+      .build();
+    sendNativePaymentTx.sign(testingDistributionKp.keypair);
+
+    const response = await stellar.submitTransaction(sendNativePaymentTx);
+
+    expect(response).toBeTruthy();
+  }, 30000);
+
+  it("should send non-native payment to valid Muxed account", async () => {
+    const baseAccoutKp = SigningKeypair.fromSecret(
+      "SDFK2E4LSVZJGEWKFIX4SXOLDXQQWMDGNONERVBNFXDVWE2PTEKY6ZSI",
+    );
+
+    try {
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + baseAccoutKp.publicKey,
+      );
+    } catch {}
+
+    const baseAccount = await stellar.server.loadAccount(
+      baseAccoutKp.publicKey,
+    );
+    const muxedAccount = new MuxedAccount(baseAccount, "456");
+
+    // First add support for the non-native asset
+    const txBuilder1 = await stellar.transaction({
+      sourceAddress: baseAccoutKp,
+      baseFee: 100,
+    });
+    const addTswtTx = txBuilder1.addAssetSupport(testingAsset).build();
+    addTswtTx.sign(baseAccoutKp.keypair);
+    await stellar.submitTransaction(addTswtTx);
+
+    // Then submit the non-native payment!
+    const txBuilder2 = await stellar.transaction({
+      sourceAddress: testingDistributionKp,
+      baseFee: 100,
+    });
+
+    const sendNonNativePaymentTx = txBuilder2
+      .transfer(muxedAccount.accountId(), testingAsset, "1")
+      .build();
+    sendNonNativePaymentTx.sign(testingDistributionKp.keypair);
+
+    const response = await stellar.submitTransaction(sendNonNativePaymentTx);
+
+    expect(response).toBeTruthy();
+  }, 30000);
+
+  it("should return 'op_no_trust' error for sending unsupported Asset to valid Muxed account", async () => {
+    const baseAccoutKp = SigningKeypair.fromSecret(
+      "SD4UETXJ2MJCIPSU72DAJDPL2YGDHF2FEIJVNARUGE6MFDPXNS5YHNGK",
+    );
+
+    try {
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + baseAccoutKp.publicKey,
+      );
+    } catch {}
+
+    const baseAccount = await stellar.server.loadAccount(
+      baseAccoutKp.publicKey,
+    );
+    const muxedAccount = new MuxedAccount(baseAccount, "789");
+
+    // Try submitting the non-native payment without adding the trustline
+    const txBuilder = await stellar.transaction({
+      sourceAddress: testingDistributionKp,
+      baseFee: 100,
+    });
+
+    const sendNonNativePaymentTx = txBuilder
+      .transfer(muxedAccount.accountId(), testingAsset, "1")
+      .build();
+    sendNonNativePaymentTx.sign(testingDistributionKp.keypair);
+
+    try {
+      await stellar.submitTransaction(sendNonNativePaymentTx);
+    } catch (error) {
+      expect(error?.response?.status === 400).toBeTruthy();
+
+      const resultCodeOperations: Array<string> =
+        error?.response?.data?.extras?.result_codes?.operations || [];
+
+      expect(resultCodeOperations).toContain("op_no_trust");
+    }
+  }, 30000);
+
+  it("should return error for sending payment to invalid Muxed address", async () => {
+    const txBuilder = await stellar.transaction({
+      sourceAddress: testingDistributionKp,
+      baseFee: 100,
+    });
+
+    try {
+      txBuilder
+        .transfer(
+          // Invalid Muxed address ending in "XXXXXX"
+          "MBE3SABPOQFUSVCNDO5WNSS4N2KD7ZUFIYDRBP6Q3UBXBMYZFYWLSAAAAAAAAAAXXXXXX",
+          new NativeAssetId(),
+          "1",
+        )
+        .build();
+    } catch (error) {
+      const lowercaseError = error.toString().toLowerCase();
+      // Catches "Error: destination is invalid" error message
+      expect(lowercaseError.match(/destination.*invalid/)).toBeTruthy();
+    }
+  });
+});
+
+describe("Path Payment", () => {
+  let wallet: Wallet;
+  let stellar: Stellar;
+  let sourceKp;
+  let receivingKp;
+  const usdcAsset = new IssuedAssetId(
+    "USDC",
+    "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+  );
+  beforeAll(async () => {
+    wallet = Wallet.TestNet();
+    stellar = wallet.stellar();
+
+    // set up accounts
+    sourceKp = SigningKeypair.fromSecret(
+      "SBTMCNDNPMJFEYUHLCAMFM5C2PWI7ZUI7PFMLI53O62CSSXFSAXEDTS6",
+    );
+    receivingKp = SigningKeypair.fromSecret(
+      "SDU4Z54AAFF3Y3GA6U27QSSYYX5FLDV6KWGFCCWSMSOSFWHSABJFBFOD",
+    );
+    try {
+      await stellar.server.loadAccount(sourceKp.publicKey);
+      await stellar.server.loadAccount(receivingKp.publicKey);
+    } catch (e) {
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + sourceKp.publicKey,
+      );
+      await axios.get(
+        "https://friendbot.stellar.org/?addr=" + receivingKp.publicKey,
+      );
+
+      // add trustlines if new accounts
+      let txBuilder = await stellar.transaction({
+        sourceAddress: receivingKp,
+      });
+      let txn = txBuilder.addAssetSupport(usdcAsset).build();
+      receivingKp.sign(txn);
+      await stellar.submitTransaction(txn);
+
+      txBuilder = await stellar.transaction({
+        sourceAddress: sourceKp,
+      });
+      txn = txBuilder.addAssetSupport(usdcAsset).build();
+      sourceKp.sign(txn);
+      await stellar.submitTransaction(txn);
+    }
+  }, 20000);
+
+  it("should use path payment send", async () => {
+    const txBuilder = await stellar.transaction({
+      sourceAddress: sourceKp,
+    });
+    const txn = txBuilder
+      .pathPay({
+        destinationAddress: receivingKp.publicKey,
+        sendAsset: new NativeAssetId(),
+        destAsset: usdcAsset,
+        sendAmount: "5",
+      })
+      .build();
+    sourceKp.sign(txn);
+    const success = await stellar.submitTransaction(txn);
+    expect(success).toBe(true);
+  }, 15000);
+
+  it("should use path payment receive", async () => {
+    const txBuilder = await stellar.transaction({
+      sourceAddress: sourceKp,
+    });
+    const txn = txBuilder
+      .pathPay({
+        destinationAddress: receivingKp.publicKey,
+        sendAsset: new NativeAssetId(),
+        destAsset: usdcAsset,
+        destAmount: "5",
+      })
+      .build();
+    sourceKp.sign(txn);
+    const success = await stellar.submitTransaction(txn);
+    expect(success).toBe(true);
+  }, 15000);
+
+  it("should swap", async () => {
+    const txBuilder = await stellar.transaction({
+      sourceAddress: sourceKp,
+    });
+    const txn = txBuilder.swap(new NativeAssetId(), usdcAsset, "1").build();
+    sourceKp.sign(txn);
+    const success = await stellar.submitTransaction(txn);
+    expect(success).toBe(true);
+  }, 15000);
+});

package/test/wallet.test.ts

@@ -18,6 +18,7 @@ import {
 } from "../src/walletSdk/Auth/WalletSigner";
 import { SigningKeypair } from "../src/walletSdk/Horizon/Account";
 import { Sep24 } from "../src/walletSdk/Anchor/Sep24";
+import { DomainSigner } from "../src/walletSdk/Auth/WalletSigner";
 
 import { TransactionsResponse } from "../test/fixtures/TransactionsResponse";
 
@@ -1804,6 +1805,29 @@ describe("Anchor", () => {
   });
 });
 
+describe("DomainSigner", () => {
+  it("should work", async () => {
+    jest.spyOn(DefaultClient, "post").mockResolvedValue({
+      data: {
+        transaction:
+          "AAAAAgAAAADVJRbxdB+qXZjUMLcrL/VVoS6megW1ReSxIO33pvO61AAAB9AAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAACwAAAAAAAAACAAAAAAAAAAA=",
+      },
+    });
+    const signer = new DomainSigner("example url", {
+      SampleHeader: "sample-header",
+    });
+
+    const txn = await signer.signWithDomainAccount({
+      transactionXDR: "test-xdr",
+      networkPassphrase: "Test SDF Network ; September 2015",
+      accountKp: SigningKeypair.fromSecret(
+        "SBYAW5H46NNDGCECWMWWM32DE4DPNN3RHVMNTR3BXXZX2DJF6LZWBMWZ",
+      ),
+    });
+    expect(txn).toBeTruthy();
+  });
+});
+
 describe("Http client", () => {
   it("should work with http", async () => {
     const accountKp = Keypair.fromSecret(