@stellar/typescript-wallet-sdk 1.0.0-beta.0 → 1.0.0

package/src/walletSdk/Anchor/Sep24.ts

@@ -0,0 +1,267 @@
+import { AxiosInstance } from "axios";
+import queryString from "query-string";
+
+import { Anchor } from "../Anchor";
+import {
+  AssetNotSupportedError,
+  ServerRequestFailedError,
+  MissingTransactionIdError,
+  InvalidTransactionResponseError,
+  InvalidTransactionsResponseError,
+} from "../Exceptions";
+import {
+  FLOW_TYPE,
+  Sep24PostParams,
+  Sep24PostResponse,
+  AnchorTransaction,
+  GetTransactionParams,
+  GetTransactionsParams,
+  TransactionStatus,
+  AnchorServiceInfo,
+} from "../Types";
+import { Watcher } from "../Watcher";
+import { camelToSnakeCaseObject } from "../Utils";
+
+// Let's prevent exporting this constructor type as
+// we should not create this Sep24 class directly.
+type Sep24Params = {
+  anchor: Anchor;
+  httpClient: AxiosInstance;
+};
+
+// Do not create this object directly, use the Wallet class.
+export class Sep24 {
+  private anchor: Anchor;
+  private httpClient: AxiosInstance;
+
+  constructor(params: Sep24Params) {
+    const { anchor, httpClient } = params;
+
+    this.anchor = anchor;
+    this.httpClient = httpClient;
+  }
+
+  async deposit({
+    assetCode,
+    authToken,
+    lang,
+    extraFields,
+    destinationMemo,
+    destinationAccount,
+  }: Sep24PostParams): Promise<Sep24PostResponse> {
+    return this.flow({
+      assetCode,
+      authToken,
+      lang,
+      extraFields,
+      destinationMemo,
+      account: destinationAccount,
+      type: FLOW_TYPE.DEPOSIT,
+    });
+  }
+
+  async withdraw({
+    assetCode,
+    authToken,
+    lang,
+    extraFields,
+    withdrawalAccount,
+  }: Sep24PostParams): Promise<Sep24PostResponse> {
+    return this.flow({
+      assetCode,
+      authToken,
+      lang,
+      extraFields,
+      account: withdrawalAccount,
+      type: FLOW_TYPE.WITHDRAW,
+    });
+  }
+
+  private async flow(
+    params: Sep24PostParams & { type: FLOW_TYPE },
+  ): Promise<Sep24PostResponse> {
+    const {
+      assetCode,
+      authToken,
+      lang = this.anchor.language,
+      extraFields,
+      destinationMemo,
+      account,
+      type,
+    } = params;
+
+    const toml = await this.anchor.sep1();
+    const transferServerEndpoint = toml.transferServerSep24;
+
+    const serviceInfo = await this.anchor.getServicesInfo();
+
+    let assets: string[];
+    if (type === FLOW_TYPE.DEPOSIT) {
+      assets = Object.keys(serviceInfo.deposit);
+    } else {
+      assets = Object.keys(serviceInfo.withdraw);
+    }
+    if (!assets.includes(assetCode)) {
+      throw new AssetNotSupportedError(type, assetCode);
+    }
+    let memoMap = {};
+    if (destinationMemo) {
+      memoMap["memo_type"] = destinationMemo.type;
+      memoMap["memo"] = destinationMemo.value;
+    }
+
+    try {
+      const resp = await this.httpClient.post(
+        `${transferServerEndpoint}/transactions/${type}/interactive`,
+        {
+          asset_code: assetCode,
+          lang,
+          account,
+          ...memoMap,
+          ...extraFields,
+        },
+        {
+          headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${authToken}`,
+          },
+        },
+      );
+
+      const interactiveResponse: Sep24PostResponse = resp.data;
+
+      return interactiveResponse;
+    } catch (e) {
+      throw new ServerRequestFailedError(e);
+    }
+  }
+
+  async getServicesInfo(): Promise<AnchorServiceInfo> {
+    return this.anchor.getServicesInfo();
+  }
+
+  watcher(): Watcher {
+    return new Watcher(this.anchor);
+  }
+
+  /**
+   * Get single transaction's current status and details. One of the [id], [stellarTransactionId],
+   * [externalTransactionId] must be provided.
+   *
+   * @param authToken auth token of the account authenticated with the anchor
+   * @param id transaction ID
+   * @param stellarTransactionId stellar transaction ID
+   * @param externalTransactionId external transaction ID
+   * @return transaction object
+   * @throws [MissingTransactionIdError] if none of the id params is provided
+   * @throws [InvalidTransactionResponseError] if Anchor returns an invalid transaction
+   * @throws [ServerRequestFailedError] if server request fails
+   */
+  async getTransactionBy({
+    authToken,
+    id,
+    stellarTransactionId,
+    externalTransactionId,
+    lang = this.anchor.language,
+  }: GetTransactionParams): Promise<AnchorTransaction> {
+    if (!id && !stellarTransactionId && !externalTransactionId) {
+      throw new MissingTransactionIdError();
+    }
+
+    const toml = await this.anchor.sep1();
+    const transferServerEndpoint = toml.transferServerSep24;
+
+    let qs: { [name: string]: string } = {};
+
+    if (id) {
+      qs = { id };
+    } else if (stellarTransactionId) {
+      qs = { stellar_transaction_id: stellarTransactionId };
+    } else if (externalTransactionId) {
+      qs = { external_transaction_id: externalTransactionId };
+    }
+
+    qs = { lang, ...qs };
+
+    try {
+      const resp = await this.httpClient.get(
+        `${transferServerEndpoint}/transaction?${queryString.stringify(qs)}`,
+        {
+          headers: {
+            Authorization: `Bearer ${authToken}`,
+          },
+        },
+      );
+
+      const transaction: AnchorTransaction = resp.data.transaction;
+
+      if (!transaction || Object.keys(transaction).length === 0) {
+        throw new InvalidTransactionResponseError(transaction);
+      }
+
+      return transaction;
+    } catch (e) {
+      throw new ServerRequestFailedError(e);
+    }
+  }
+
+  /**
+   * Get account's transactions specified by asset and other params.
+   *
+   * @param authToken auth token of the account authenticated with the anchor
+   * @param assetCode target asset to query for
+   * @param noOlderThan response should contain transactions starting on or after this date & time
+   * @param limit response should contain at most 'limit' transactions
+   * @param kind kind of transaction that is desired. E.g.: 'deposit', 'withdrawal'
+   * @param pagingId response should contain transactions starting prior to this ID (exclusive)
+   * @param lang desired language (localization), it can also accept locale in the format 'en-US'
+   * @return list of transactions as requested by the client, sorted in time-descending order
+   * @throws [InvalidTransactionsResponseError] if Anchor returns an invalid response
+   * @throws [ServerRequestFailedError] if server request fails
+   */
+  async getTransactionsForAsset({
+    authToken,
+    assetCode,
+    noOlderThan,
+    limit,
+    kind,
+    pagingId,
+    lang = this.anchor.language,
+  }: GetTransactionsParams): Promise<AnchorTransaction[]> {
+    const toml = await this.anchor.sep1();
+    const transferServerEndpoint = toml.transferServerSep24;
+
+    // Let's convert all params to snake case for the API call
+    const apiParams = camelToSnakeCaseObject({
+      assetCode,
+      noOlderThan,
+      limit,
+      kind,
+      pagingId,
+      lang,
+    });
+
+    try {
+      const resp = await this.httpClient.get(
+        `${transferServerEndpoint}/transactions?${queryString.stringify(
+          apiParams,
+        )}`,
+        {
+          headers: {
+            Authorization: `Bearer ${authToken}`,
+          },
+        },
+      );
+
+      const transactions: AnchorTransaction[] = resp.data.transactions;
+
+      if (!transactions || !Array.isArray(transactions)) {
+        throw new InvalidTransactionsResponseError(transactions);
+      }
+
+      return transactions;
+    } catch (e) {
+      throw new ServerRequestFailedError(e);
+    }
+  }
+}

package/src/walletSdk/Anchor/index.ts

@@ -1,27 +1,12 @@
 import { AxiosInstance } from "axios";
-import queryString from "query-string";
 import { StellarTomlResolver } from "stellar-sdk";
 
 import { Config } from "walletSdk";
-import { Auth } from "../Auth";
-import {
-  MissingTransactionIdError,
-  ServerRequestFailedError,
-  InvalidTransactionResponseError,
-  InvalidTransactionsResponseError,
-  AssetNotSupportedError,
-} from "../Exceptions";
-import { Interactive } from "../Interactive";
-import { 
-  AnchorServiceInfo, 
-  AnchorTransaction, 
-  GetTransactionParams, 
-  GetTransactionsParams, 
-  TomlInfo, 
-  TransactionStatus 
-} from "../Types";
-import { Watcher } from "../Watcher";
-import { camelToSnakeCaseObject, parseToml } from "../Utils";
+import { Sep10 } from "../Auth";
+import { ServerRequestFailedError } from "../Exceptions";
+import { Sep24 } from "./Sep24";
+import { AnchorServiceInfo, TomlInfo } from "../Types";
+import { parseToml } from "../Utils";
 
 // Let's prevent exporting this constructor type as
 // we should not create this Anchor class directly.
@@ -42,12 +27,7 @@ export class Anchor {
   private toml: TomlInfo;
 
   constructor(params: AnchorParams) {
-    const {
-      cfg,
-      homeDomain,
-      httpClient,
-      language,
-    } = params;
+    const { cfg, homeDomain, httpClient, language } = params;
 
     this.cfg = cfg;
     this.homeDomain = homeDomain;
@@ -55,7 +35,7 @@ export class Anchor {
     this.language = language;
   }
 
-  async getInfo(shouldRefresh?: boolean): Promise<TomlInfo> {
+  async sep1(shouldRefresh?: boolean): Promise<TomlInfo> {
     // return cached TOML values by default
     if (this.toml && !shouldRefresh) {
       return this.toml;
@@ -68,26 +48,24 @@ export class Anchor {
     return parsedToml;
   }
 
-  async auth(): Promise<Auth> {
-    const tomlInfo = await this.getInfo();
-    return new Auth({
+  async sep10(): Promise<Sep10> {
+    const tomlInfo = await this.sep1();
+    return new Sep10({
       cfg: this.cfg,
       webAuthEndpoint: tomlInfo.webAuthEndpoint,
       homeDomain: this.homeDomain,
-      httpClient: this.httpClient
+      httpClient: this.httpClient,
     });
   }
 
-  interactive(): Interactive {
-    return new Interactive({ anchor: this, httpClient: this.httpClient});
+  sep24(): Sep24 {
+    return new Sep24({ anchor: this, httpClient: this.httpClient });
   }
 
-  watcher(): Watcher {
-    return new Watcher(this);
-  }
-
-  async getServicesInfo(lang: string = this.language): Promise<AnchorServiceInfo> {
-    const toml = await this.getInfo();
+  async getServicesInfo(
+    lang: string = this.language,
+  ): Promise<AnchorServiceInfo> {
+    const toml = await this.sep1();
     const transferServerEndpoint = toml.transferServerSep24;
 
     try {
@@ -97,186 +75,14 @@ export class Anchor {
           headers: {
             "Content-Type": "application/json",
           },
-        }
+        },
       );
 
       const servicesInfo: AnchorServiceInfo = resp.data;
-      
-      return servicesInfo;
-    } catch (e) {
-      throw new ServerRequestFailedError(e);
-    }
-  }
-
-  /**
-   * Get single transaction's current status and details. One of the [id], [stellarTransactionId],
-   * [externalTransactionId] must be provided.
-   *
-   * @param authToken auth token of the account authenticated with the anchor
-   * @param id transaction ID
-   * @param stellarTransactionId stellar transaction ID
-   * @param externalTransactionId external transaction ID
-   * @return transaction object
-   * @throws [MissingTransactionIdError] if none of the id params is provided
-   * @throws [InvalidTransactionResponseError] if Anchor returns an invalid transaction
-   * @throws [ServerRequestFailedError] if server request fails
-   */
-  async getTransactionBy({
-    authToken,
-    id,
-    stellarTransactionId,
-    externalTransactionId,
-    lang = this.language,
-  }: GetTransactionParams): Promise<AnchorTransaction> {
-
-    if (!id && !stellarTransactionId && !externalTransactionId) {
-      throw new MissingTransactionIdError();
-    }
-
-    const toml = await this.getInfo();
-    const transferServerEndpoint = toml.transferServerSep24;
-
-    let qs: { [name: string]: string } = {};
 
-    if (id) {
-      qs = { id };
-    } else if (stellarTransactionId) {
-      qs = { stellar_transaction_id: stellarTransactionId };
-    } else if (externalTransactionId) {
-      qs = { external_transaction_id: externalTransactionId };
-    }
-
-    qs = { lang, ...qs };
-
-    try {
-      const resp = await this.httpClient.get(
-        `${transferServerEndpoint}/transaction?${queryString.stringify(qs)}`,
-        {
-          headers: {
-            Authorization: `Bearer ${authToken}`,
-          },
-        }
-      );
-
-      const transaction: AnchorTransaction = resp.data.transaction;
-
-      if (!transaction || Object.keys(transaction).length === 0) {
-        throw new InvalidTransactionResponseError(transaction);
-      }
-
-      return transaction;
-    } catch (e) {
-      throw new ServerRequestFailedError(e);
-    }
-  }
-
-  /**
-   * Get account's transactions specified by asset and other params.
-   *
-   * @param authToken auth token of the account authenticated with the anchor
-   * @param assetCode target asset to query for
-   * @param noOlderThan response should contain transactions starting on or after this date & time
-   * @param limit response should contain at most 'limit' transactions
-   * @param kind kind of transaction that is desired. E.g.: 'deposit', 'withdrawal'
-   * @param pagingId response should contain transactions starting prior to this ID (exclusive)
-   * @param lang desired language (localization), it can also accept locale in the format 'en-US'
-   * @return list of transactions as requested by the client, sorted in time-descending order
-   * @throws [InvalidTransactionsResponseError] if Anchor returns an invalid response
-   * @throws [ServerRequestFailedError] if server request fails
-   */
-  async getTransactionsForAsset({
-    authToken,
-    assetCode,
-    noOlderThan,
-    limit,
-    kind,
-    pagingId,
-    lang = this.language,
-  }: GetTransactionsParams): Promise<AnchorTransaction[]> {
-    const toml = await this.getInfo();
-    const transferServerEndpoint = toml.transferServerSep24;
-
-    // Let's convert all params to snake case for the API call
-    const apiParams = camelToSnakeCaseObject({
-      assetCode,
-      noOlderThan,
-      limit,
-      kind,
-      pagingId,
-      lang,
-    });
-
-    try {
-      const resp = await this.httpClient.get(
-        `${transferServerEndpoint}/transactions?${queryString.stringify(
-          apiParams
-        )}`,
-        {
-          headers: {
-            Authorization: `Bearer ${authToken}`,
-          },
-        }
-      );
-        
-      const transactions: AnchorTransaction[] = resp.data.transactions;
-
-      if (!transactions || !Array.isArray(transactions)) {
-        throw new InvalidTransactionsResponseError(transactions);
-      }
-
-      return transactions;
+      return servicesInfo;
     } catch (e) {
       throw new ServerRequestFailedError(e);
     }
   }
-
-  /**
-   * Get all successfully finished (either completed or refunded) account transactions for specified
-   * asset. Optional field implementation depends on anchor.
-   *
-   * @param authToken auth token of the account authenticated with the anchor
-   * @param assetCode target asset to query for
-   * @param noOlderThan response should contain transactions starting on or after this date & time
-   * @param limit response should contain at most 'limit' transactions
-   * @param kind kind of transaction that is desired. E.g.: 'deposit', 'withdrawal'
-   * @param pagingId response should contain transactions starting prior to this ID (exclusive)
-   * @param lang desired language (localization), it can also accept locale in the format 'en-US'
-   * @return list of filtered transactions that achieved a final state (completed or refunded)
-   * @throws [AssetNotSupportedError] if asset is not supported by the anchor 
-   * @throws [InvalidTransactionsResponseError] if Anchor returns an invalid response
-   * @throws [ServerRequestFailedError] if server request fails
-   */
-
-  async getHistory({
-    authToken,
-    assetCode,
-    noOlderThan,
-    limit,
-    kind,
-    pagingId,
-    lang = this.language,
-  }: GetTransactionsParams): Promise<AnchorTransaction[]> {
-    const toml = await this.getInfo();
-    if (!toml.currencies?.find(({ code }) => code === assetCode)) {
-      throw new AssetNotSupportedError(null, assetCode);
-    }
-
-    const transactions = await this.getTransactionsForAsset({
-      authToken,
-      assetCode,
-      noOlderThan,
-      limit,
-      kind,
-      pagingId,
-      lang,
-    });
-
-    const finishedTransactions = transactions
-      .filter(({ status }) => [
-        TransactionStatus.completed, 
-        TransactionStatus.refunded
-      ].includes(status));
-
-    return finishedTransactions;
-  }
 }

package/src/walletSdk/Auth/WalletSigner.ts

@@ -1,28 +1,30 @@
 import { Transaction } from "stellar-sdk";
-import { 
-  SignWithClientAccountParams, 
-  SignWithDomainAccountParams 
+import {
+  SignWithClientAccountParams,
+  SignWithDomainAccountParams,
 } from "../Types";
 
 export interface WalletSigner {
-  signWithClientAccount({ 
-    transaction, 
-    accountKp 
+  signWithClientAccount({
+    transaction,
+    accountKp,
   }: SignWithClientAccountParams): Transaction;
 
   signWithDomainAccount({
     transactionXDR,
     networkPassphrase,
-    accountKp
-  }: SignWithDomainAccountParams): Transaction;
+    accountKp,
+  }: SignWithDomainAccountParams): Promise<Transaction>;
 }
 
 export const DefaultSigner: WalletSigner = {
   signWithClientAccount: ({ transaction, accountKp }) => {
-    transaction.sign(accountKp);
+    transaction.sign(accountKp.keypair);
     return transaction;
   },
-  signWithDomainAccount: () => {
-    throw new Error("The DefaultSigner can't sign transactions with domain account");
+  signWithDomainAccount: async () => {
+    throw new Error(
+      "The DefaultSigner can't sign transactions with domain account",
+    );
   },
 };