@stellar/typescript-wallet-sdk 1.1.2 → 1.2.0

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

@@ -54,3 +54,6 @@ export declare class WithdrawalTxNotPendingUserTransferStartError extends Error
 export declare class WithdrawalTxMissingMemoError extends Error {
     constructor();
 }
+export declare class WithdrawalTxMemoError extends Error {
+    constructor();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stellar/typescript-wallet-sdk",
-  "version": "1.1.2",
+  "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",
@@ -40,17 +41,18 @@
     "jws": "^4.0.0",
     "lodash": "^4.17.21",
     "query-string": "^7.1.3",
-    "stellar-sdk": "^10.4.1",
+    "stellar-sdk": "^11.0.0-beta.3",
     "stream-http": "^3.2.0",
     "url": "^0.11.0",
     "util": "^0.12.5",
     "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

@@ -146,3 +146,16 @@ export class WithdrawalTxMissingMemoError extends Error {
     Object.setPrototypeOf(this, WithdrawalTxMissingMemoError.prototype);
   }
 }
+
+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`);
+    Object.setPrototypeOf(this, WithdrawalTxMemoError.prototype);
+  }
+}

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

@@ -14,17 +14,22 @@ import {
   InsufficientStartingBalanceError,
   WithdrawalTxMissingMemoError,
   WithdrawalTxNotPendingUserTransferStartError,
+  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,
@@ -32,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,
@@ -43,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(
@@ -59,7 +75,7 @@ export class TransactionBuilder {
       StellarSdk.Operation.createAccount({
         destination: newAccount.publicKey,
         startingBalance: startingBalance.toString(),
-        source: this.sourceAccount,
+        source: this.sourceAddress,
       }),
     );
     return this;
@@ -80,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(
@@ -129,12 +205,31 @@ export class TransactionBuilder {
       throw new WithdrawalTxMissingMemoError();
     }
 
-    return this.setMemo(
-      new Memo(transaction.withdraw_memo_type, transaction.withdraw_memo),
-    ).transfer(
+    if (transaction.withdraw_memo_type === "hash") {
+      try {
+        const buffer = Buffer.from(transaction.withdraw_memo, "base64");
+        const memo = Memo.hash(buffer.toString("hex"));
+        this.setMemo(memo);
+      } catch {
+        throw new WithdrawalTxMemoError();
+      }
+    } else {
+      this.setMemo(
+        new Memo(transaction.withdraw_memo_type, transaction.withdraw_memo),
+      );
+    }
+
+    return this.transfer(
       transaction.withdraw_anchor_account,
       assetId,
       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;
   }
 }