@stellar/typescript-wallet-sdk 1.1.3 → 1.2.0

package/examples/sep24/README.md

@@ -0,0 +1,22 @@
+# Sep-24 examples for stellar typescript-wallet-sdk
+
+## Example code
+
+To view how the wallet-sdk can be used to create sep-24 deposits and withdrawals
+look at `sep24.ts`.
+
+## Running deposit and withdrawals
+
+To see them in action you can run below from the project root:
+
+```
+$ yarn example:sep24
+```
+
+This will run the deposit flow and watch for it to finish. At the end it will
+ask if you'd like to run the withdraw flow. Use USDC as the asset for the
+example.
+
+Progress will be logged in the terminal.
+
+_note: the identity values used in the sep24 interactive portal can all be fake_

package/examples/sep24/sep24.ts

@@ -0,0 +1,199 @@
+import axios from "axios";
+import readline from "readline";
+
+import {
+  walletSdk,
+  Anchor,
+  SigningKeypair,
+  Types,
+  IssuedAssetId,
+} from "../../src";
+import { Memo, MemoText } from "stellar-sdk";
+
+const wallet = walletSdk.Wallet.TestNet();
+const stellar = wallet.stellar();
+const anchor = wallet.anchor({ homeDomain: "testanchor.stellar.org" });
+const account = stellar.account();
+
+let kp: SigningKeypair;
+
+const asset = new IssuedAssetId(
+  "USDC",
+  "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+);
+
+const runSep24 = async () => {
+  await createAccount();
+  await runDeposit(anchor, kp);
+  await runDepositWatcher(anchor);
+
+  while (!depositDone) {
+    await new Promise((resolve) => setTimeout(resolve, 1000));
+  }
+
+  const ans = await askQuestion("Do you want to start withdrawal? (y/n)");
+  if (ans !== "y") {
+    process.exit(0);
+  }
+
+  await runWithdraw(anchor, kp);
+  await runWithdrawWatcher(anchor, kp);
+};
+
+// Create Account
+const createAccount = async () => {
+  console.log("creating account ...");
+  kp = account.createKeypair();
+  console.log(`kp: \n${kp.publicKey}\n${kp.secretKey}`);
+
+  // funding new account
+  await axios.get("https://friendbot.stellar.org/?addr=" + kp.publicKey);
+
+  const txBuilder = await stellar.transaction({
+    sourceAddress: kp,
+    baseFee: 1000,
+  });
+  const tx = txBuilder.addAssetSupport(asset).build();
+  kp.sign(tx);
+  await stellar.submitTransaction(tx);
+};
+
+// Create Deposit
+let authToken: string;
+export const runDeposit = async (anchor: Anchor, kp: SigningKeypair) => {
+  console.log("\ncreating deposit ...");
+  const auth = await anchor.sep10();
+  authToken = await auth.authenticate({ accountKp: kp });
+
+  const resp = await anchor.sep24().deposit({
+    assetCode: asset.code,
+    authToken: authToken,
+    lang: "en-US",
+    destinationMemo: new Memo(MemoText, "test-memo"),
+    // Optional field. Same result would be achieved with omitting this field.
+    // Replace with a different account if you want to change destination
+    destinationAccount: kp.publicKey,
+    // If not specified, amount will be collected in the interactive flow. You can also pass extra SEP-9 fields.
+    extraFields: { amount: "10" },
+  });
+
+  console.log("Open url:\n", resp.url);
+};
+
+// Watch Deposit
+export let depositDone = false;
+export const runDepositWatcher = (anchor: Anchor) => {
+  console.log("\nstarting watcher ...");
+
+  let stop: Types.WatcherStopFunction;
+  const onMessage = (m: Types.AnchorTransaction) => {
+    console.log({ m });
+    if (m.status === Types.TransactionStatus.completed) {
+      console.log("status completed, stopping watcher");
+      stop();
+      depositDone = true;
+    }
+  };
+
+  const onError = (error: Types.AnchorTransaction | Error) => {
+    console.error({ error });
+  };
+
+  const watcher = anchor.sep24().watcher();
+  const resp = watcher.watchAllTransactions({
+    authToken: authToken,
+    assetCode: asset.code,
+    onMessage,
+    onError,
+    timeout: 5000,
+    lang: "en-US",
+  });
+
+  stop = resp.stop;
+};
+
+// Create Withdrawal
+export const runWithdraw = async (anchor, kp) => {
+  console.log("\ncreating withdrawal ...");
+
+  const resp = await anchor.sep24().withdraw({
+    assetCode: asset.code,
+    authToken: authToken,
+    lang: "en-US",
+    // Optional field. Same result would be achieved with omitting this field.
+    // Replace with a different account if you want to change destination
+    withdrawalAccount: kp.publicKey,
+    // If not specified, amount will be collected in the interactive flow. You can also pass extra SEP-9 fields.
+    extraFields: { amount: "10" },
+  });
+  console.log("Open url:\n", resp.url);
+};
+
+const sendWithdrawalTransaction = async (withdrawalTxn, kp) => {
+  const asset = new IssuedAssetId(
+    "USDC",
+    "GBBD47IF6LWK7P7MDEVSCWR7DPUWV3NY3DTQEVFL4NAT4AQH3ZLLFLA5",
+  );
+
+  const txBuilder = await stellar.transaction({
+    sourceAddress: kp,
+    baseFee: 1000,
+  });
+  const tx = txBuilder
+    .transferWithdrawalTransaction(withdrawalTxn, asset)
+    .build();
+  kp.sign(tx);
+  await stellar.submitTransaction(tx);
+};
+
+// Watch Withdrawal
+export const runWithdrawWatcher = (anchor, kp) => {
+  console.log("\nstarting watcher ...");
+
+  let stop;
+  const onMessage = (m) => {
+    console.log({ m });
+
+    if (m.status === Types.TransactionStatus.pending_user_transfer_start) {
+      sendWithdrawalTransaction(m, kp);
+    }
+
+    if (m.status === Types.TransactionStatus.completed) {
+      console.log("status completed, stopping watcher");
+
+      stop();
+    }
+  };
+
+  const onError = (e) => {
+    console.error({ e });
+  };
+
+  const watcher = anchor.sep24().watcher();
+  const resp = watcher.watchAllTransactions({
+    authToken: authToken,
+    assetCode: asset.code,
+    onMessage,
+    onError,
+    timeout: 5000,
+    lang: "en-US",
+  });
+
+  stop = resp.stop;
+};
+
+export const askQuestion = (query) => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) =>
+    rl.question(query, (ans) => {
+      rl.close();
+      resolve(ans);
+    }),
+  );
+};
+
+runSep24();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar/typescript-wallet-sdk",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "engines": {
     "node": ">=18"
   },
@@ -29,6 +29,7 @@
     "stream-browserify": "^3.0.0",
     "ts-jest": "^29.0.5",
     "ts-loader": "^9.4.2",
+    "ts-node": "^10.9.1",
     "tslib": "^2.5.0",
     "typescript": "^5.0.4",
     "webpack": "^5.83.1",
@@ -47,10 +48,11 @@
     "utility-types": "^3.10.0"
   },
   "scripts": {
-    "prepare": "yarn build",
+    "prepare": "husky install",
     "test": "jest --watchAll",
     "build:web": "webpack --config webpack.config.js",
     "build:node": "webpack --env NODE=true --config webpack.config.js",
-    "build": "run-p build:web build:node"
+    "build": "run-p build:web build:node",
+    "example:sep24": "ts-node examples/sep24/sep24.ts"
   }
 }

package/src/index.ts

@@ -23,6 +23,7 @@ export {
   AccountService,
   Stellar,
   TransactionBuilder,
+  SponsoringBuilder,
 } from "./walletSdk/Horizon";
 export { Recovery } from "./walletSdk/Recovery";
 export { Watcher } from "./walletSdk/Watcher";

package/src/walletSdk/Anchor/Sep24.ts

@@ -43,7 +43,9 @@ export class Sep24 {
 
   async deposit({
     assetCode,
+
     authToken,
+
     lang,
     extraFields,
     destinationMemo,

package/src/walletSdk/Auth/WalletSigner.ts

@@ -1,8 +1,17 @@
-import { Transaction } from "stellar-sdk";
+import {
+  Transaction,
+  TransactionBuilder as StellarTransactionBuilder,
+  FeeBumpTransaction,
+} from "stellar-sdk";
+import { AxiosInstance } from "axios";
+
 import {
   SignWithClientAccountParams,
   SignWithDomainAccountParams,
+  HttpHeaders,
 } from "../Types";
+import { AccountKeypair } from "../Horizon/Account";
+import { DefaultClient } from "../";
 
 export interface WalletSigner {
   signWithClientAccount({
@@ -28,3 +37,57 @@ export const DefaultSigner: WalletSigner = {
     );
   },
 };
+
+/**
+ * Represents a Domain Signer used for signing Stellar transactions with a domain server.
+ *
+ * @class
+ * @implements {WalletSigner}
+ */
+export class DomainSigner implements WalletSigner {
+  private url: string;
+  private client: AxiosInstance;
+  private headers: HttpHeaders;
+
+  /**
+   * Create a new instance of the DomainSigner class.
+   *
+   * @constructor
+   * @param {string} url - The URL of the domain server.
+   * @param {HttpHeaders} headers - The HTTP headers for requests to the domain server.
+   * These headers can be used for authentication purposes.
+   */
+  constructor(url: string, headers: HttpHeaders) {
+    this.url = url;
+    this.client = DefaultClient;
+    this.headers = headers;
+  }
+
+  signWithClientAccount({
+    transaction,
+    accountKp,
+  }: SignWithClientAccountParams): Transaction {
+    transaction.sign(accountKp.keypair);
+    return transaction;
+  }
+
+  async signWithDomainAccount({
+    transactionXDR,
+    networkPassphrase,
+    accountKp,
+  }: SignWithDomainAccountParams): Promise<Transaction> {
+    const response = await this.client.post(
+      this.url,
+      {
+        transactionXDR,
+        networkPassphrase,
+      },
+      { headers: this.headers },
+    );
+
+    return StellarTransactionBuilder.fromXDR(
+      response.data.transaction,
+      networkPassphrase,
+    ) as Transaction;
+  }
+}

package/src/walletSdk/Auth/index.ts

@@ -55,7 +55,7 @@ export class Sep10 {
     const challengeResponse = await this.challenge({
       accountKp,
       memoId,
-      clientDomain,
+      clientDomain: clientDomain || this.cfg.app.defaultClientDomain,
     });
     const signedTransaction = await this.sign({
       accountKp,

package/src/walletSdk/Exceptions/index.ts

@@ -147,6 +147,12 @@ export class WithdrawalTxMissingMemoError extends Error {
   }
 }
 
+export class PathPayOnlyOneAmountError extends Error {
+  constructor() {
+    super("Must give sendAmount or destAmount value, but not both");
+    Object.setPrototypeOf(this, PathPayOnlyOneAmountError.prototype);
+  }
+}
 export class WithdrawalTxMemoError extends Error {
   constructor() {
     super(`Error parsing withdrawal transaction memo`);

package/src/walletSdk/Horizon/Transaction/CommonTransactionBuilder.ts

@@ -0,0 +1,75 @@
+import StellarSdk, { xdr } from "stellar-sdk";
+import { IssuedAssetId } from "../../Asset";
+import { AccountKeypair } from "../Account";
+
+export abstract class CommonTransactionBuilder<T> {
+  protected sourceAddress: string;
+  protected operations: Array<xdr.Operation>;
+
+  constructor(sourceAddress: string, operations: Array<xdr.Operation>) {
+    this.sourceAddress = sourceAddress;
+    this.operations = operations;
+  }
+
+  addAssetSupport(asset: IssuedAssetId, trustLimit?: string): T {
+    this.operations.push(
+      StellarSdk.Operation.changeTrust({
+        asset: asset.toAsset(),
+        limit: trustLimit,
+        source: this.sourceAddress,
+      }),
+    );
+    return this as any as T;
+  }
+
+  removeAssetSupport(asset: IssuedAssetId): T {
+    return this.addAssetSupport(asset, "0");
+  }
+
+  addAccountSigner(signerAddress: AccountKeypair, signerWeight: number): T {
+    this.operations.push(
+      StellarSdk.Operation.setOptions({
+        source: this.sourceAddress,
+        signer: {
+          ed25519PublicKey: signerAddress.publicKey,
+          weight: signerWeight,
+        },
+      }),
+    );
+    return this as any as T;
+  }
+
+  removeAccountSigner(signerAddress: AccountKeypair): T {
+    return this.addAccountSigner(signerAddress, 0);
+  }
+
+  lockAccountMasterKey(): T {
+    this.operations.push(
+      StellarSdk.Operation.setOptions({
+        source: this.sourceAddress,
+        masterWeight: 0,
+      }),
+    );
+    return this as any as T;
+  }
+
+  setThreshold({
+    low,
+    medium,
+    high,
+  }: {
+    low?: number;
+    medium?: number;
+    high?: number;
+  }): T {
+    this.operations.push(
+      StellarSdk.Operation.setOptions({
+        source: this.sourceAddress,
+        lowThreshold: low,
+        medThreshold: medium,
+        highThreshold: high,
+      }),
+    );
+    return this as any as T;
+  }
+}

package/src/walletSdk/Horizon/Transaction/SponsoringBuilder.ts

@@ -0,0 +1,58 @@
+import StellarSdk, {
+  TransactionBuilder as StellarTransactionBuilder,
+  Transaction,
+  xdr,
+} from "stellar-sdk";
+import { IssuedAssetId } from "../../Asset";
+
+import { CommonTransactionBuilder } from "./CommonTransactionBuilder";
+import { AccountKeypair } from "../Account";
+
+export class SponsoringBuilder extends CommonTransactionBuilder<SponsoringBuilder> {
+  private sponsorAccount: AccountKeypair;
+
+  constructor(
+    sponsoredAddress: string,
+    sponsorAccount: AccountKeypair,
+    operations: Array<xdr.Operation>,
+    buildingFunction: (SponsoringBuilder) => SponsoringBuilder,
+  ) {
+    super(sponsoredAddress, operations);
+    this.sponsorAccount = sponsorAccount;
+
+    this.startSponsoring();
+    buildingFunction(this);
+    this.stopSponsoring();
+  }
+
+  createAccount(
+    newAccount: AccountKeypair,
+    startingBalance: number = 0,
+  ): SponsoringBuilder {
+    this.operations.push(
+      StellarSdk.Operation.createAccount({
+        destination: newAccount.publicKey,
+        startingBalance: startingBalance.toString(),
+        source: this.sponsorAccount.publicKey,
+      }),
+    );
+    return this;
+  }
+
+  startSponsoring() {
+    this.operations.push(
+      StellarSdk.Operation.beginSponsoringFutureReserves({
+        sponsoredId: this.sourceAddress,
+        source: this.sponsorAccount.publicKey,
+      }),
+    );
+  }
+
+  stopSponsoring() {
+    this.operations.push(
+      StellarSdk.Operation.endSponsoringFutureReserves({
+        source: this.sourceAddress,
+      }),
+    );
+  }
+}

package/src/walletSdk/Horizon/Transaction/TransactionBuilder.ts

@@ -17,15 +17,19 @@ import {
   WithdrawalTxMemoError,
 } from "../../Exceptions";
 import { IssuedAssetId, StellarAssetId } from "../../Asset";
-import { WithdrawTransaction, TransactionStatus } from "../../Types";
-
-export class TransactionBuilder {
-  private network: Networks;
-  private operations: Array<xdr.Operation>;
+import {
+  WithdrawTransaction,
+  TransactionStatus,
+  PathPayParams,
+} from "../../Types";
+import { PathPayOnlyOneAmountError } from "../../Exceptions";
+import { CommonTransactionBuilder } from "./CommonTransactionBuilder";
+import { SponsoringBuilder } from "./SponsoringBuilder";
+
+export class TransactionBuilder extends CommonTransactionBuilder<TransactionBuilder> {
+  private cfg: Config;
   private builder: StellarTransactionBuilder;
 
-  sourceAccount: string;
-
   constructor(
     cfg: Config,
     sourceAccount: StellarAccount,
@@ -33,8 +37,7 @@ export class TransactionBuilder {
     memo?: Memo,
     timebounds?: Server.Timebounds,
   ) {
-    this.network = cfg.stellar.network;
-    this.operations = [];
+    super(sourceAccount.accountId(), []);
     this.builder = new StellarTransactionBuilder(sourceAccount, {
       fee: baseFee ? baseFee.toString() : cfg.stellar.baseFee.toString(),
       timebounds,
@@ -44,8 +47,20 @@ export class TransactionBuilder {
     if (!timebounds) {
       this.builder.setTimeout(cfg.stellar.defaultTimeout);
     }
+  }
 
-    this.sourceAccount = sourceAccount.accountId();
+  sponsoring(
+    sponsorAccount: AccountKeypair,
+    buildingFunction: (SponsoringBuilder) => SponsoringBuilder,
+    sponsoredAccount?: AccountKeypair,
+  ): TransactionBuilder {
+    new SponsoringBuilder(
+      sponsoredAccount ? sponsoredAccount.publicKey : this.sourceAddress,
+      sponsorAccount,
+      this.operations,
+      buildingFunction,
+    );
+    return this;
   }
 
   createAccount(
@@ -60,7 +75,7 @@ export class TransactionBuilder {
       StellarSdk.Operation.createAccount({
         destination: newAccount.publicKey,
         startingBalance: startingBalance.toString(),
-        source: this.sourceAccount,
+        source: this.sourceAddress,
       }),
     );
     return this;
@@ -81,39 +96,99 @@ export class TransactionBuilder {
     return this;
   }
 
-  addOperation(op: xdr.Operation): TransactionBuilder {
-    this.builder.addOperation(op);
-    return this;
-  }
+  /**
+   * Creates and adds a path payment operation to the transaction builder.
+   *
+   * @param {string} destinationAddress - The destination Stellar address to which the payment is sent.
+   * @param {StellarAssetId} sendAsset - The asset to be sent.
+   * @param {StellarAssetId} destAsset - The asset the destination will receive.
+   * @param {string} [sendAmount] - The amount to be sent. Must specify either sendAmount or destAmount,
+   * but not both.
+   * @param {string} [destAmount] - The amount to be received by the destination. Must specify either sendAmount or destAmount,
+   * but not both.
+   * @param {string} [destMin] - The minimum amount of the destination asset to be receive. This is a
+   * protective measure, it allows you to specify a lower bound for an acceptable conversion. Only used
+   * if using sendAmount.
+   * (optional, default is ".0000001").
+   * @param {string} [sendMax] - The maximum amount of the destination asset to be sent. This is a
+   * protective measure, it allows you to specify an upper bound for an acceptable conversion. Only used
+   * if using destAmount.
+   * (optional, default is int64 max).
+   *
+   * @returns {TransactionBuilder} - Returns the current TransactionBuilder instance for method chaining.
+   */
+  pathPay({
+    destinationAddress,
+    sendAsset,
+    destAsset,
+    sendAmount,
+    destAmount,
+    destMin,
+    sendMax,
+  }: PathPayParams): TransactionBuilder {
+    if ((sendAmount && destAmount) || (!sendAmount && !destAmount)) {
+      throw new PathPayOnlyOneAmountError();
+    }
+    if (sendAmount) {
+      this.operations.push(
+        StellarSdk.Operation.pathPaymentStrictSend({
+          destination: destinationAddress,
+          sendAsset: sendAsset.toAsset(),
+          sendAmount,
+          destAsset: destAsset.toAsset(),
+          destMin: destMin || ".0000001",
+        }),
+      );
+    } else {
+      this.operations.push(
+        StellarSdk.Operation.pathPaymentStrictReceive({
+          destination: destinationAddress,
+          sendAsset: sendAsset.toAsset(),
+          destAmount,
+          destAsset: destAsset.toAsset(),
+          sendMax: sendMax || "922337203685.4775807",
+        }),
+      );
+    }
 
-  setMemo(memo: Memo): TransactionBuilder {
-    this.builder.addMemo(memo);
     return this;
   }
 
-  addAssetSupport(
-    asset: IssuedAssetId,
-    trustLimit?: string,
+  /**
+   * Swap assets using the Stellar network. This swaps using the
+   * pathPaymentStrictReceive operation.
+   *
+   * @param {StellarAssetId} fromAsset - The source asset to be sent.
+   * @param {StellarAssetId} toAsset - The destination asset to receive.
+   * @param {string} amount - The amount of the source asset to be sent.
+   * @param {string} [destMin] - (Optional) The minimum amount of the destination asset to be received.
+   *
+   * @returns {TransactionBuilder} Returns the current instance of the TransactionBuilder for method chaining.
+   */
+  swap(
+    fromAsset: StellarAssetId,
+    toAsset: StellarAssetId,
+    amount: string,
+    destMin?: string,
   ): TransactionBuilder {
-    this.operations.push(
-      StellarSdk.Operation.changeTrust({
-        asset: asset.toAsset(),
-        limit: trustLimit,
-        source: this.sourceAccount,
-      }),
-    );
+    this.pathPay({
+      destinationAddress: this.sourceAddress,
+      sendAsset: fromAsset,
+      destAsset: toAsset,
+      sendAmount: amount,
+      destMin,
+    });
     return this;
   }
 
-  removeAssetSupport(asset: IssuedAssetId): TransactionBuilder {
-    return this.addAssetSupport(asset, "0");
+  addOperation(op: xdr.Operation): TransactionBuilder {
+    this.builder.addOperation(op);
+    return this;
   }
 
-  build(): Transaction {
-    this.operations.forEach((op) => {
-      this.builder.addOperation(op);
-    });
-    return this.builder.build();
+  setMemo(memo: Memo): TransactionBuilder {
+    this.builder.addMemo(memo);
+    return this;
   }
 
   transferWithdrawalTransaction(
@@ -150,4 +225,11 @@ export class TransactionBuilder {
       transaction.amount_in,
     );
   }
+
+  build(): Transaction {
+    this.operations.forEach((op) => {
+      this.builder.addOperation(op);
+    });
+    return this.builder.build();
+  }
 }

package/src/walletSdk/Horizon/index.ts

@@ -2,3 +2,4 @@ export { PublicKeypair, SigningKeypair } from "./Account";
 export { AccountService } from "./AccountService";
 export { Stellar } from "./Stellar";
 export { TransactionBuilder } from "./Transaction/TransactionBuilder";
+export { SponsoringBuilder } from "./Transaction/SponsoringBuilder";

package/src/walletSdk/Types/auth.ts

@@ -41,3 +41,7 @@ export type SignWithDomainAccountParams = {
   networkPassphrase: NetworkPassphrase;
   accountKp: AccountKeypair;
 };
+
+export type HttpHeaders = {
+  [key: string]: string;
+};

package/src/walletSdk/Types/horizon.ts

@@ -1,6 +1,7 @@
 import { Memo, Server, xdr, Transaction } from "stellar-sdk";
 import { AccountKeypair } from "../Horizon/Account";
 import { TransactionBuilder } from "../Horizon/Transaction/TransactionBuilder";
+import { StellarAssetId } from "../Asset";
 
 export enum NETWORK_URLS {
   PUBLIC = "https://horizon.stellar.org",
@@ -9,7 +10,7 @@ export enum NETWORK_URLS {
 
 export type TransactionParams = {
   sourceAddress: AccountKeypair;
-  baseFee: number;
+  baseFee?: number;
   memo?: Memo;
   timebounds?: Server.Timebounds | number;
 };
@@ -38,3 +39,13 @@ export enum HORIZON_ORDER {
   ASC = "asc",
   DESC = "desc",
 }
+
+export type PathPayParams = {
+  destinationAddress: string;
+  sendAsset: StellarAssetId;
+  destAsset: StellarAssetId;
+  sendAmount?: string;
+  destAmount?: string;
+  destMin?: string;
+  sendMax?: string;
+};

package/src/walletSdk/index.ts

@@ -131,9 +131,15 @@ export const DefaultClient = axios.create({
 export class ApplicationConfiguration {
   defaultSigner: WalletSigner;
   defaultClient: AxiosInstance;
+  defaultClientDomain?: string;
 
-  constructor(defaultSigner?: WalletSigner, defaultClient?: AxiosInstance) {
+  constructor(
+    defaultSigner?: WalletSigner,
+    defaultClient?: AxiosInstance,
+    defaultClientDomain?: string,
+  ) {
     this.defaultSigner = defaultSigner || DefaultSigner;
     this.defaultClient = defaultClient || DefaultClient;
+    this.defaultClientDomain = defaultClientDomain;
   }
 }

package/test/stellar.test.ts

@@ -43,7 +43,6 @@ describe("Stellar", () => {
     const txBuilderParams = [
       {
         sourceAddress: kp,
-        baseFee: 100,
         startingBalance: 2,
       },
       {
@@ -247,6 +246,127 @@ describe("Stellar", () => {
   }, 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: 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
+      .sponsoring(sponsorKp, buildingFunction)
+      .transfer(sponsorKp.publicKey, new NativeAssetId(), "5")
+      .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 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", () => {
   it("should create an asset", () => {
     const issued = new IssuedAssetId(
@@ -266,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(