@stellar/typescript-wallet-sdk 1.1.3 → 1.2.1

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/Types/index.ts

@@ -1,4 +1,4 @@
-import { AxiosRequestConfig } from "axios";
+import { RawAxiosRequestHeaders } from "axios";
 import { Server, Networks } from "stellar-sdk";
 import { ApplicationConfiguration, StellarConfiguration } from "walletSdk";
 
@@ -30,6 +30,13 @@ export type StellarConfigurationParams = {
   defaultTimeout?: number;
 };
 
+export type AxiosErrorData = {
+  status?: number;
+  statusText?: string;
+  responseData?: any;
+  headers?: RawAxiosRequestHeaders;
+};
+
 // Export all other types from walletSdk/Types.ts
 export * from "./anchor";
 export * from "./auth";

package/src/walletSdk/Utils/extractAxiosErrorData.ts

@@ -0,0 +1,28 @@
+import axios from "axios";
+import { AxiosErrorData } from "../Types";
+
+// Based on https://axios-http.com/docs/handling_errors
+
+export const extractAxiosErrorData = (error: Error): AxiosErrorData => {
+  if (!axios.isAxiosError(error)) {
+    return { responseData: JSON.stringify(error) };
+  }
+  if (error.response) {
+    return {
+      status: error.response.status,
+      statusText: error.response.statusText,
+      responseData: error.response.data,
+      headers: error.response.headers,
+    };
+  } else if (error.request) {
+    // The request was made but no response was received
+    return {
+      statusText: `No response received from request: ${JSON.stringify(
+        error.request,
+      )}`,
+    };
+  } else {
+    // Something happened in setting up the request that triggered an Error
+    return { statusText: `Failed request with error: ${error.message}` };
+  }
+};

package/src/walletSdk/Utils/index.ts

@@ -1,3 +1,4 @@
 export * from "./camelToSnakeCase";
 export * from "./toml";
 export * from "./url";
+export * from "./extractAxiosErrorData";

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);
+});