@stellar/typescript-wallet-sdk 1.2.1 → 1.3.0

package/src/walletSdk/Types/sep12.ts

@@ -0,0 +1,61 @@
+export type CustomerInfoMap = {
+  [key: string]: string;
+};
+
+export enum Sep12Status {
+  ACCEPTED = "ACCEPTED",
+  PROCESSING = "PROCESSING",
+  NEEDS_INFO = "NEEDS_INFO",
+  REJECTED = "REJECTED",
+  VERIFICATION_REQUIRED = "VERIFICATION_REQUIRED",
+}
+
+export enum Sep12Type {
+  string = "string",
+  binary = "binary",
+  number = "number",
+  date = "date",
+}
+
+export type Field = {
+  type: Sep12Type;
+  description: string;
+  choices?: Array<string>;
+  optional?: boolean;
+};
+
+export type ProvidedField = {
+  type: Sep12Type;
+  description: string;
+  choices?: Array<string>;
+  optional?: boolean;
+  status?: Sep12Status;
+  error?: string;
+};
+
+export type GetCustomerParams = {
+  id?: string;
+  type?: string;
+  memo?: string;
+  lang?: string;
+};
+
+export type GetCustomerResponse = {
+  id?: string;
+  status: Sep12Status;
+  fields?: { [key: string]: Field };
+  provided_fields?: { [key: string]: ProvidedField };
+  message?: string;
+};
+
+export type AddCustomerParams = {
+  sep9Info?: CustomerInfoMap;
+  sep9BinaryInfo?: CustomerInfoMap;
+  id?: string;
+  memo?: string;
+  type?: string;
+};
+
+export type AddCustomerResponse = {
+  id: string;
+};

package/src/walletSdk/Types/sep38.ts

@@ -0,0 +1,106 @@
+import { AxiosInstance } from "axios";
+import { Anchor } from "../Anchor";
+import { AuthToken } from "./auth";
+
+export interface Sep38Info {
+  assets: Array<Sep38AssetInfo>;
+}
+
+export interface Sep38AssetInfo {
+  asset: string;
+  sell_delivery_methods?: Array<Sep38DeliveryMethod>;
+  buy_delivery_methods?: Array<Sep38DeliveryMethod>;
+  country_codes?: Array<string>;
+}
+
+export interface Sep38DeliveryMethod {
+  name: string;
+  description: string;
+}
+
+export type Sep38Params = {
+  anchor: Anchor;
+  httpClient: AxiosInstance;
+  authToken?: AuthToken;
+};
+
+export interface Sep38PricesParams {
+  sellAsset: string;
+  sellAmount: string;
+  sellDeliveryMethod?: string;
+  buyDeliveryMethod?: string;
+  countryCode?: string;
+}
+
+export interface Sep38PricesResponse {
+  buy_assets: Array<Sep38BuyAsset>;
+}
+
+export interface Sep38BuyAsset {
+  asset: string;
+  price: string;
+  decimals: number;
+}
+
+export interface Sep38PriceParams {
+  sellAsset: string;
+  buyAsset: string;
+  sellAmount?: string;
+  buyAmount?: string;
+  context: Sep38PriceContext;
+  sellDeliveryMethod?: string;
+  buyDeliveryMethod?: string;
+  countryCode?: string;
+}
+
+export enum Sep38PriceContext {
+  SEP6 = "sep6",
+  SEP24 = "sep24",
+  SEP31 = "sep31",
+}
+
+export interface Sep38PriceResponse {
+  total_price: string;
+  price: string;
+  sell_amount: string;
+  buy_amount: string;
+  fee: {
+    total: string;
+    asset: string;
+    details?: Array<Sep38FeeDetails>;
+  };
+}
+
+export interface Sep38FeeDetails {
+  name: string;
+  description?: string;
+  amount: string;
+}
+
+export interface Sep38PostQuoteParams {
+  sell_asset: string;
+  buy_asset: string;
+  sell_amount: string;
+  buy_amount: string;
+  context: Sep38PriceContext;
+  expire_after?: string;
+  sell_delivery_method?: string;
+  buy_delivery_method?: string;
+  country_code?: string;
+}
+
+export interface Sep38PostQuoteResponse {
+  id: string;
+  expires_at: string;
+  total_price: string;
+  price: string;
+  sell_asset: string;
+  sell_amount: string;
+  buy_asset: string;
+  buy_amount: string;
+  fee: {
+    total: string;
+    asset: string;
+    details?: Array<Sep38FeeDetails>;
+  };
+}

package/src/walletSdk/Types/sep6.ts

@@ -0,0 +1,168 @@
+import { AxiosInstance } from "axios";
+import { Anchor } from "../Anchor";
+
+export interface Sep6EndpointInfo {
+  enabled: boolean;
+  authentication_required?: boolean;
+  description?: string;
+}
+
+export interface Sep6DepositInfo {
+  enabled: boolean;
+  authentication_required?: boolean;
+  fee_fixed?: number;
+  fee_percent?: number;
+  min_amount?: number;
+  max_amount?: number;
+  fields?: {
+    [key: string]: {
+      description: string;
+      optional?: boolean;
+      choices?: string[];
+    };
+  };
+}
+
+export interface Sep6WithdrawInfo {
+  enabled: boolean;
+  authentication_required?: boolean;
+  fee_fixed?: number;
+  fee_percent?: number;
+  min_amount?: number;
+  max_amount?: number;
+  types?: {
+    [key: string]: {
+      fields?: {
+        [key: string]: {
+          description: string;
+          optional?: boolean;
+          choices?: string[];
+        };
+      };
+    };
+  };
+}
+
+export interface Sep6Info {
+  deposit: { [key: string]: Sep6DepositInfo };
+  "deposit-exchange": { [key: string]: Sep6DepositInfo };
+  withdraw: { [key: string]: Sep6WithdrawInfo };
+  "withdraw-exchange": { [key: string]: Sep6WithdrawInfo };
+  fee: {
+    enabled: boolean;
+    description: string;
+  };
+  transactions: Sep6EndpointInfo;
+  transaction: Sep6EndpointInfo;
+  features: {
+    account_creation: boolean;
+    claimable_balances: boolean;
+  };
+}
+
+export type Sep6Params = {
+  anchor: Anchor;
+  httpClient: AxiosInstance;
+};
+
+export interface Sep6DepositParams {
+  asset_code: string;
+  account: string;
+  memo_type?: string;
+  memo?: string;
+  email_address?: string;
+  type?: string;
+  lang?: string;
+  on_change_callback?: string;
+  amount?: string;
+  country_code?: string;
+  claimable_balance_supported?: string;
+  customer_id?: string;
+}
+
+export interface Sep6WithdrawParams {
+  asset_code: string;
+  type: string;
+  dest?: string;
+  dest_extra?: string;
+  account?: string;
+  memo?: string;
+  lang?: string;
+  on_change_callback?: string;
+  amount?: string;
+  country_code?: string;
+  refund_memo?: string;
+  refund_memo_type?: string;
+  customer_id?: string;
+}
+
+export type Sep6DepositResponse =
+  | Sep6DepositSuccess
+  | Sep6MissingKYC
+  | Sep6Pending;
+
+export interface Sep6DepositSuccess {
+  how?: string;
+  instructions?: {
+    [key: string]: {
+      value: string;
+      description: string;
+    };
+  };
+  id?: string;
+  eta?: number;
+  min_amoun?: number;
+  max_amount?: number;
+  fee_fixed?: number;
+  fee_percent?: number;
+  extra_info?: { message?: string };
+}
+
+export interface Sep6MissingKYC {
+  type: string;
+  fields: Array<string>;
+}
+
+export interface Sep6Pending {
+  type: string;
+  status: string;
+  more_info_url?: string;
+  eta?: number;
+}
+
+export type Sep6WithdrawResponse =
+  | Sep6WithdrawSuccess
+  | Sep6MissingKYC
+  | Sep6Pending;
+
+export interface Sep6WithdrawSuccess {
+  account_id?: string;
+  memo_type?: string;
+  memo?: string;
+  id?: string;
+  eta?: number;
+  min_amount?: number;
+  max_amount?: number;
+  fee_fixed?: number;
+  fee_percent?: number;
+  extra_info?: { message?: string };
+}
+
+export interface Sep6ExchangeParams {
+  destination_asset: string;
+  source_asset: string;
+  amount: string;
+  account?: string;
+  quote_id?: string;
+  memo_type?: string;
+  memo?: string;
+  email_address?: string;
+  type?: string;
+  lang?: string;
+  on_change_callback?: string;
+  country_code?: string;
+  claimable_balance_supported?: string;
+  customer_id?: string;
+  refund_memo?: string;
+  refund_memo_type?: string;
+}

package/src/walletSdk/Types/watcher.ts

@@ -1,7 +1,8 @@
 import { AnchorTransaction } from "./anchor";
+import { AuthToken } from "./auth";
 
 export type WatchTransactionsParams = {
-  authToken: string;
+  authToken: AuthToken;
   assetCode: string;
   onMessage: (transaction: AnchorTransaction) => void;
   onError: (error: AnchorTransaction | Error) => void;
@@ -14,7 +15,7 @@ export type WatchTransactionsParams = {
 };
 
 export type WatchTransactionParams = {
-  authToken: string;
+  authToken: AuthToken;
   assetCode: string;
   id: string;
   onMessage: (transaction: AnchorTransaction) => void;
@@ -32,3 +33,8 @@ export interface WatcherResponse {
   refresh: WatcherRefreshFunction;
   stop: WatcherStopFunction;
 }
+
+export enum WatcherSepType {
+  SEP6 = "SEP6",
+  SEP24 = "SEP24",
+}

package/src/walletSdk/Utils/camelToSnakeCase.ts

@@ -4,6 +4,7 @@ export const camelToSnakeCaseKey = (key: string): string =>
     (upperCaseLetter) => `_${upperCaseLetter.toLowerCase()}`,
   );
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const camelToSnakeCaseObject = (obj: any): any => {
   const snakeCasedObj = {};
   for (const key in obj) {

package/src/walletSdk/Utils/toml.ts

@@ -1,8 +1,8 @@
-import { StellarTomlResolver } from "stellar-sdk";
+import { StellarToml } from "stellar-sdk";
 
 import { TomlInfo } from "../Types";
 
-export const parseToml = (toml: StellarTomlResolver.StellarToml): TomlInfo => {
+export const parseToml = (toml: StellarToml.Api.StellarToml): TomlInfo => {
   const tomlDocumentation = toml["DOCUMENTATION"];
   const documentation = {
     orgName: tomlDocumentation["ORG_NAME"],

package/src/walletSdk/Watcher/getTransactions.ts

@@ -0,0 +1,65 @@
+import { AxiosInstance } from "axios";
+import queryString from "query-string";
+
+import { AuthToken } from "../Types";
+import {
+  ServerRequestFailedError,
+  InvalidTransactionsResponseError,
+  InvalidTransactionResponseError,
+} from "../Exceptions";
+
+export const _getTransactionsForAsset = async <T>(
+  authToken: AuthToken,
+  params: { [key: string]: string | number },
+  endpoint: string,
+  client: AxiosInstance,
+): Promise<T[]> => {
+  try {
+    const resp = await client.get(
+      `${endpoint}/transactions?${queryString.stringify(params)}`,
+      {
+        headers: {
+          Authorization: `Bearer ${authToken.token}`,
+        },
+      },
+    );
+
+    const transactions: T[] = resp.data.transactions;
+
+    if (!transactions || !Array.isArray(transactions)) {
+      throw new InvalidTransactionsResponseError(transactions);
+    }
+
+    return transactions;
+  } catch (e) {
+    throw new ServerRequestFailedError(e);
+  }
+};
+
+export const _getTransactionBy = async <T>(
+  authToken: AuthToken,
+  params: { [key: string]: string | number },
+  endpoint: string,
+  client: AxiosInstance,
+): Promise<T> => {
+  try {
+    const resp = await client.get(
+      `${endpoint}/transaction?${queryString.stringify(params)}`,
+      {
+        headers: {
+          Authorization: `Bearer ${authToken.token}`,
+        },
+      },
+    );
+
+    const transaction: T = resp.data.transaction;
+
+    if (!transaction || Object.keys(transaction).length === 0) {
+      throw new InvalidTransactionResponseError(transaction);
+    }
+
+    return transaction;
+  } catch (e) {
+    throw new ServerRequestFailedError(e);
+  }
+};

package/src/walletSdk/Watcher/index.ts

@@ -5,6 +5,7 @@ import {
   WatchTransactionParams,
   WatchTransactionsParams,
   WatcherResponse,
+  WatcherSepType,
 } from "../Types";
 
 interface WatchRegistryAsset {
@@ -20,16 +21,21 @@ interface WatchAllTransactionsRegistry {
 }
 
 interface TransactionsRegistryAsset {
-  [id: string]: any; // TOOD - replace with Transaction type
+  [id: string]: AnchorTransaction;
 }
 
 interface TransactionsRegistry {
   [assetCode: string]: TransactionsRegistryAsset;
 }
 
-// Do not create this object directly, use the Anchor class.
+/**
+ * Used for watching transaction from an Anchor as part of sep-24.
+ * Do not create this object directly, use the Anchor class.
+ * @class
+ */
 export class Watcher {
   private anchor: Anchor;
+  private sepType: WatcherSepType;
 
   private _oneTransactionWatcher: {
     [assetCode: string]: {
@@ -42,8 +48,16 @@ export class Watcher {
   private _transactionsRegistry: TransactionsRegistry;
   private _transactionsIgnoredRegistry: TransactionsRegistry;
 
-  constructor(anchor: Anchor) {
+  /**
+   * Creates a new instance of the Watcher class.
+   *
+   * @param {Anchor} anchor - The Anchor to watch from.
+   * @param {WatcherSepType} sepType - The Sep type the anchor being polled is using
+   * (ie. Sep-6 or Sep-24).
+   */
+  constructor(anchor: Anchor, sepType: WatcherSepType) {
     this.anchor = anchor;
+    this.sepType = sepType;
 
     this._oneTransactionWatcher = {};
     this._allTransactionsWatcher = undefined;
@@ -59,11 +73,23 @@ export class Watcher {
    *
    * On initial load, it'll return ALL pending transactions via onMessage.
    * Subsequent messages will be any one of these events:
-   *  - Any new transaction appears
-   *  - Any of the initial pending transactions change any state
+   * - Any new transaction appears
+   * - Any of the initial pending transactions change any state
    *
    * You may also provide an array of transaction ids, `watchlist`, and this
    * watcher will always react to transactions whose ids are in the watchlist.
+   * @param {WatchTransactionsParams} params - The Watch Transactions params.
+   * @param {AuthToken} params.authToken - The authentication token used for authenticating with the anchor.
+   * @param {string} params.assetCode - The asset code to filter transactions by.
+   * @param {Function} params.onMessage - A callback function to handle incoming transaction messages.
+   * @param {Function} params.onError - A callback function to handle errors during transaction streaming.
+   * @param {Array<string>} [params.watchlist=[]] - An optional array of specific transaction IDs to watch.
+   * @param {number} [params.timeout=5000] - The timeout duration for the streaming connection (in milliseconds).
+   * @param {boolean} [params.isRetry=false] - Indicates whether this is a retry attempt (optional).
+   * @param {string} [params.lang=this.anchor.language] - The desired language (localization) for transaction messages.
+   * @param {string} params.kind - The kind of transaction to filter by.
+   * @param {string} [params.noOlderThan] - A date and time specifying that transactions older than this value should not be included.
+   * @returns {WatcherResponse} An object holding the refresh and stop functions for the watcher.
    */
   watchAllTransactions({
     authToken,
@@ -110,8 +136,19 @@ export class Watcher {
       this._watchAllTransactionsRegistry[assetCode] = true;
     }
 
-    this.anchor
-      .sep24()
+    let sepObj;
+    switch (this.sepType) {
+      case WatcherSepType.SEP6:
+        sepObj = this.anchor.sep6();
+        break;
+      case WatcherSepType.SEP24:
+        sepObj = this.anchor.sep24();
+        break;
+      default:
+        break;
+    }
+
+    sepObj
       .getTransactionsForAsset({
         authToken,
         assetCode,
@@ -240,6 +277,17 @@ export class Watcher {
    * * onSuccess - When the transaction comes back as completed / refunded / expired.
    * * onError - When there's a runtime error, or the transaction comes back as
    * no_market / too_small / too_large / error.
+   * @param {WatchTransactionParams} params - The Watch Transaction params.
+   * @param {AuthToken} params.authToken - The authentication token used for authenticating with th anchor.
+   * @param {string} params.assetCode - The asset code to filter transactions by.
+   * @param {string} params.id - The id of the transaction to watch.
+   * @param {Function} params.onMessage - A callback function to handle incoming transaction messages.
+   * @param {Function} params.onSuccess - If a transaction status is in a end state (eg. completed, refunded, expired) then this callback is called.
+   * @param {Function} params.onError - A callback function to handle errors during transaction streaming.
+   * @param {number} [params.timeout=5000] - The timeout duration for the streaming connection (in milliseconds).
+   * @param {boolean} [params.isRetry=false] - Indicates whether this is a retry attempt (optional).
+   * @param {string} [params.lang=this.anchor.language] - The desired language (localization) for transaction messages.
+   * @returns {WatcherResponse} An object holding the refresh and stop functions for the watcher.
    */
   watchOneTransaction({
     authToken,
@@ -281,9 +329,20 @@ export class Watcher {
       };
     }
 
+    let sepObj;
+    switch (this.sepType) {
+      case WatcherSepType.SEP6:
+        sepObj = this.anchor.sep6();
+        break;
+      case WatcherSepType.SEP24:
+        sepObj = this.anchor.sep24();
+        break;
+      default:
+        break;
+    }
+
     // do this all asynchronously (since this func needs to return a cancel fun)
-    this.anchor
-      .sep24()
+    sepObj
       .getTransactionBy({ authToken, id, lang })
       .then((transaction: AnchorTransaction) => {
         // make sure we're still watching
@@ -363,3 +422,5 @@ export class Watcher {
     };
   }
 }
+
+export * from "./getTransactions";

package/src/walletSdk/index.ts

@@ -1,5 +1,5 @@
-import axios, { AxiosInstance, AxiosRequestConfig } from "axios";
-import { Networks, Server } from "stellar-sdk";
+import axios, { AxiosInstance } from "axios";
+import { Networks, Horizon } from "stellar-sdk";
 
 import { Anchor } from "./Anchor";
 import { DefaultSigner, WalletSigner } from "./Auth";
@@ -10,34 +10,54 @@ import {
   StellarConfigurationParams,
   WalletAnchor,
   WalletParams,
-  WalletRecovery,
+  WalletRecoveryServers,
   NETWORK_URLS,
 } from "./Types";
 import { getUrlDomain } from "./Utils";
 
-/* tslint:disable-next-line:no-var-requires */
+/* eslint-disable-next-line @typescript-eslint/no-var-requires */
 const version = require("../../package.json").version;
 const walletHeaders = {
   "X-Client-Name": "typescript-wallet-sdk",
   "X-Client-Version": version,
 };
 
+/**
+ * The Wallet SDK main entry point class. From these class methods you can create a
+ * wallet on the Stellar network.
+ * @class
+ */
 export class Wallet {
   private cfg: Config;
   private language: string;
 
+  /**
+   * Creates a Wallet instance configured to the test network.
+   * @returns {Wallet} A Wallet instance configured to the test network.
+   */
   static TestNet = (): Wallet => {
     return new Wallet({
       stellarConfiguration: StellarConfiguration.TestNet(),
     });
   };
 
+  /**
+   * Creates a Wallet instance configured to the public network.
+   * @returns {Wallet} A Wallet instance configured to the public network.
+   */
   static MainNet = (): Wallet => {
     return new Wallet({
       stellarConfiguration: StellarConfiguration.MainNet(),
     });
   };
 
+  /**
+   * Creates a new Wallet instance.
+   * @param {WalletParams} params - The Wallet params.
+   * @param {StellarConfiguration} params.stellarConfiguration - The Stellar configuration.
+   * @param {ApplicationConfiguration} params.applicationConfiguration - The Application configuration.
+   * @param {string} [params.language] - The default langauge to use.
+   */
   constructor({
     stellarConfiguration,
     applicationConfiguration = new ApplicationConfiguration(),
@@ -48,6 +68,14 @@ export class Wallet {
     this.language = language;
   }
 
+  /**
+   * Create an Anchor instance for interacting with an Anchor.
+   * @param {WalletAnchor} params - The anchor params.
+   * @param {string} params.homeDomain - The home domain of the anchor. This domain will be used for
+   * things like getting the toml info.
+   * @param {string} [params.language=this.language] - The language setting for the Anchor.
+   * @returns {Anchor} An Anchor instance.
+   */
   anchor({ homeDomain, language = this.language }: WalletAnchor): Anchor {
     const url =
       homeDomain.indexOf("://") !== -1 ? homeDomain : `https://${homeDomain}`;
@@ -60,11 +88,20 @@ export class Wallet {
     });
   }
 
-  stellar() {
+  /**
+   * Create a Stellar instance for interacting with the Stellar network.
+   * @returns {Stellar} A Stellar instance.
+   */
+  stellar(): Stellar {
     return new Stellar(this.cfg);
   }
 
-  recovery({ servers }: WalletRecovery): Recovery {
+  /**
+   * Create a Recovery instance for account recovery using SEP-30.
+   * @param {WalletRecoveryServers} servers - A map of recovery servers.
+   * @returns {Recovery} A Recovery instance.
+   */
+  recovery({ servers }: WalletRecoveryServers): Recovery {
     return new Recovery({
       cfg: this.cfg,
       stellar: this.stellar(),
@@ -88,7 +125,7 @@ export class Config {
 }
 
 export class StellarConfiguration {
-  server: Server;
+  server: Horizon.Server;
   network: Networks;
   horizonUrl: string;
   baseFee: number;
@@ -118,7 +155,7 @@ export class StellarConfiguration {
     this.horizonUrl = horizonUrl;
     this.baseFee = baseFee;
     this.defaultTimeout = defaultTimeout;
-    this.server = new Server(horizonUrl);
+    this.server = new Horizon.Server(horizonUrl);
   }
 }