@stellar/typescript-wallet-sdk 1.1.0-alpha.2 → 1.1.1

package/src/walletSdk/Watcher/index.ts

@@ -1,7 +1,13 @@
 import isEqual from "lodash/isEqual";
 
-import { Anchor } from "walletSdk/Anchor";
-import { TransactionStatus, WatcherResponse } from "./Types";
+import { Anchor } from "../Anchor";
+import {
+  AnchorTransaction,
+  TransactionStatus,
+  WatchTransactionParams,
+  WatchTransactionsParams,
+  WatcherResponse,
+} from "../Types";
 
 interface WatchRegistryAsset {
   [id: string]: boolean;
@@ -30,7 +36,7 @@ export class Watcher {
   private _oneTransactionWatcher: {
     [assetCode: string]: {
       [id: string]: ReturnType<typeof setTimeout>;
-    }
+    };
   };
   private _allTransactionsWatcher?: ReturnType<typeof setTimeout>;
   private _watchOneTransactionRegistry: WatchOneTransactionRegistry;
@@ -50,41 +56,42 @@ export class Watcher {
   }
 
   /**
-  * Watch all transactions returned from a transfer server. When new or
-  * updated transactions come in, run an `onMessage` callback.
-  *
-  * 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
-  *
-  * You may also provide an array of transaction ids, `watchlist`, and this
-  * watcher will always react to transactions whose ids are in the watchlist.
-  */
-  watchAllTransactions(params: {
-    authToken: string;
-    assetCode: string;
-    onMessage: (transaction) => void;
-    onError: (error) => void; // TOOD - add :Transaction | Error type
-    watchlist?: string[];
-    timeout?: number;
-    isRetry?: boolean;
-    noOlderThan?: string;
-    kind?: string;
-    lang?: string;
-  }): WatcherResponse {
-    const {
+   * Watch all transactions returned from a transfer server. When new or
+   * updated transactions come in, run an `onMessage` callback.
+   *
+   * 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
+   *
+   * You may also provide an array of transaction ids, `watchlist`, and this
+   * watcher will always react to transactions whose ids are in the watchlist.
+   */
+  watchAllTransactions({
+    authToken,
+    assetCode,
+    onMessage,
+    onError,
+    watchlist = [],
+    timeout = 5000,
+    isRetry = false,
+    lang = this.anchor.language,
+    kind,
+    noOlderThan,
+  }: WatchTransactionsParams): WatcherResponse {
+    const allParams = {
       authToken,
       assetCode,
       onMessage,
       onError,
-      watchlist = [],
-      timeout = 5000,
-      isRetry = false,
-      lang = this.anchor.language,
-      ...otherParams
-    } = params;
-    
+      watchlist,
+      timeout,
+      isRetry,
+      lang,
+      kind,
+      noOlderThan,
+    };
+
     // make an object map out of watchlist
     const watchlistMap = watchlist.reduce(
       (memo, id: string) => ({ ...memo, [id]: true }),
@@ -93,10 +100,10 @@ export class Watcher {
 
     // make sure to initiate registries for the given asset code
     // to prevent 'Cannot read properties of undefined' errors
-    if(!this._transactionsRegistry[assetCode]) {
+    if (!this._transactionsRegistry[assetCode]) {
       this._transactionsRegistry[assetCode] = {};
     }
-    if(!this._transactionsIgnoredRegistry[assetCode]) {
+    if (!this._transactionsIgnoredRegistry[assetCode]) {
       this._transactionsIgnoredRegistry[assetCode] = {};
     }
 
@@ -105,74 +112,76 @@ export class Watcher {
       this._watchAllTransactionsRegistry[assetCode] = true;
     }
 
-    this.anchor.getTransactionsForAsset({ authToken, assetCode, lang, ...otherParams })
-      .then((transactions: any[]) => { // TOOD - replace with Transaction[] type
+    this.anchor
+      .sep24()
+      .getTransactionsForAsset({
+        authToken,
+        assetCode,
+        lang,
+        kind,
+        noOlderThan,
+      })
+      .then((transactions: AnchorTransaction[]) => {
         // make sure we're still watching
         if (!this._watchAllTransactionsRegistry[assetCode]) {
           return;
         }
 
         try {
-          const newTransactions = transactions.filter(
-            (transaction) => {
-              const isInProgress =
-                transaction.status.indexOf("pending") === 0 ||
-                transaction.status === TransactionStatus.incomplete;
-              const registeredTransaction = this._transactionsRegistry[
-                assetCode
-              ][transaction.id];
-
-              // if this is the first watch, only keep the pending ones
-              if (!isRetry) {
-                // always show transactions on the watchlist
-                if (watchlistMap[transaction.id]) {
-                  return true;
-                }
-
-                // if we're not in progress, then save this in an ignore reg
-                if (!isInProgress) {
-                  this._transactionsIgnoredRegistry[assetCode][
-                    transaction.id
-                  ] = transaction;
-                }
-
-                return isInProgress;
+          const newTransactions = transactions.filter((transaction) => {
+            const isInProgress =
+              transaction.status.indexOf("pending") === 0 ||
+              transaction.status === TransactionStatus.incomplete;
+            const registeredTransaction =
+              this._transactionsRegistry[assetCode][transaction.id];
+
+            // if this is the first watch, only keep the pending ones
+            if (!isRetry) {
+              // always show transactions on the watchlist
+              if (watchlistMap[transaction.id]) {
+                return true;
               }
 
-              // if we've had the transaction before, only report updates
-              if (registeredTransaction) {
-                return !isEqual(registeredTransaction, transaction);
+              // if we're not in progress, then save this in an ignore reg
+              if (!isInProgress) {
+                this._transactionsIgnoredRegistry[assetCode][transaction.id] =
+                  transaction;
               }
 
-              // if it's NOT a registered transaction, and it's not the first
-              // roll, maybe it's a new transaction that achieved a final
-              // status immediately so register that!
-              if (
-                [
-                  TransactionStatus.completed,
-                  TransactionStatus.refunded,
-                  TransactionStatus.expired,
-                  TransactionStatus.error,
-                ].includes(transaction.status) &&
-                isRetry &&
-                !this._transactionsIgnoredRegistry[assetCode][transaction.id]
-              ) {
-                return true;
-              }
+              return isInProgress;
+            }
 
-              // always use in progress transactions
-              if (isInProgress) {
-                return true;
-              }
+            // if we've had the transaction before, only report updates
+            if (registeredTransaction) {
+              return !isEqual(registeredTransaction, transaction);
+            }
+
+            // if it's NOT a registered transaction, and it's not the first
+            // roll, maybe it's a new transaction that achieved a final
+            // status immediately so register that!
+            if (
+              [
+                TransactionStatus.completed,
+                TransactionStatus.refunded,
+                TransactionStatus.expired,
+                TransactionStatus.error,
+              ].includes(transaction.status) &&
+              isRetry &&
+              !this._transactionsIgnoredRegistry[assetCode][transaction.id]
+            ) {
+              return true;
+            }
+
+            // always use in progress transactions
+            if (isInProgress) {
+              return true;
+            }
 
-              return false;
-            },
-          );
+            return false;
+          });
 
           newTransactions.forEach((transaction) => {
-            this._transactionsRegistry[assetCode][
-              transaction.id
-            ] = transaction;
+            this._transactionsRegistry[assetCode][transaction.id] = transaction;
 
             if (transaction.status === TransactionStatus.error) {
               onError(transaction);
@@ -191,9 +200,9 @@ export class Watcher {
         }
         this._allTransactionsWatcher = setTimeout(() => {
           this.watchAllTransactions({
-            ...params,
+            ...allParams,
             isRetry: true,
-         });
+          });
         }, timeout);
       })
       .catch((e) => {
@@ -212,9 +221,9 @@ export class Watcher {
         }
 
         this.watchAllTransactions({
-          ...params,
+          ...allParams,
           isRetry: true,
-       });
+        });
       },
       stop: () => {
         if (this._allTransactionsWatcher) {
@@ -228,41 +237,41 @@ export class Watcher {
   }
 
   /**
-  * Watch a transaction until it stops pending. Takes three callbacks:
-  * * onMessage - When the transaction comes back as pending_ or incomplete.
-  * * 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.
-  */
-  watchOneTransaction(params: {
-    authToken: string;
-    assetCode: string;
-    id: string;
-    onMessage: (transaction) => void;
-    onSuccess: (transaction) => void;
-    onError: (error) => void; // TOOD - add :Transaction | Error type
-    timeout?: number;
-    isRetry?: boolean;
-    lang?: string;
-  }): WatcherResponse {
-    const {
+   * Watch a transaction until it stops pending. Takes three callbacks:
+   * * onMessage - When the transaction comes back as pending_ or incomplete.
+   * * 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.
+   */
+  watchOneTransaction({
+    authToken,
+    assetCode,
+    id,
+    onMessage,
+    onSuccess,
+    onError,
+    timeout = 5000,
+    isRetry = false,
+    lang = this.anchor.language,
+  }: WatchTransactionParams): WatcherResponse {
+    const allParams = {
       authToken,
       assetCode,
       id,
       onMessage,
       onSuccess,
       onError,
-      timeout = 5000,
-      isRetry = false,
-      lang = this.anchor.language,
-    } = params;
+      timeout,
+      isRetry,
+      lang,
+    };
 
     // make sure to initiate registries for the given asset code
     // to prevent 'Cannot read properties of undefined' errors
-    if(!this._transactionsRegistry[assetCode]) {
+    if (!this._transactionsRegistry[assetCode]) {
       this._transactionsRegistry[assetCode] = {};
     }
-    if(!this._oneTransactionWatcher[assetCode]) {
+    if (!this._oneTransactionWatcher[assetCode]) {
       this._oneTransactionWatcher[assetCode] = {};
     }
 
@@ -275,16 +284,17 @@ export class Watcher {
     }
 
     // do this all asynchronously (since this func needs to return a cancel fun)
-    this.anchor.getTransactionBy({ authToken, id, lang })
-      .then((transaction) => {
+    this.anchor
+      .sep24()
+      .getTransactionBy({ authToken, id, lang })
+      .then((transaction: AnchorTransaction) => {
         // make sure we're still watching
         if (!this._watchOneTransactionRegistry[assetCode]?.[id]) {
           return;
         }
 
-        const registeredTransaction = this._transactionsRegistry[assetCode][
-          transaction.id
-        ];
+        const registeredTransaction =
+          this._transactionsRegistry[assetCode][transaction.id];
 
         // if we've had the transaction before, only report if there is a change
         if (
@@ -306,16 +316,16 @@ export class Watcher {
 
           this._oneTransactionWatcher[assetCode][id] = setTimeout(() => {
             this.watchOneTransaction({
-              ...params,
+              ...allParams,
               isRetry: true,
             });
           }, timeout);
           onMessage(transaction);
         } else if (
           [
-            TransactionStatus.completed, 
+            TransactionStatus.completed,
             TransactionStatus.refunded,
-            TransactionStatus.expired
+            TransactionStatus.expired,
           ].includes(transaction.status)
         ) {
           onSuccess(transaction);
@@ -339,7 +349,7 @@ export class Watcher {
         }
 
         this.watchOneTransaction({
-          ...params,
+          ...allParams,
           isRetry: true,
         });
       },
@@ -351,5 +361,4 @@ export class Watcher {
       },
     };
   }
-
 }

package/src/walletSdk/index.ts

@@ -1,12 +1,19 @@
-import StellarSdk, { Networks, Server } from "stellar-sdk";
 import axios, { AxiosInstance, AxiosRequestConfig } from "axios";
+import { Networks, Server } from "stellar-sdk";
 
 import { Anchor } from "./Anchor";
-import { WalletSigner, DefaultSigner } from "./Auth/WalletSigner";
-import { Stellar } from "./horizon/Stellar";
-import { NETWORK_URLS } from "./horizon/constants";
-import { Recovery } from "./recovery/Recovery";
-import { getUrlDomain } from "./util/url";
+import { DefaultSigner, WalletSigner } from "./Auth";
+import { Stellar } from "./Horizon";
+import { Recovery } from "./Recovery";
+import {
+  ConfigParams,
+  StellarConfigurationParams,
+  WalletAnchor,
+  WalletParams,
+  WalletRecovery,
+  NETWORK_URLS,
+} from "./Types";
+import { getUrlDomain } from "./Utils";
 
 /* tslint:disable-next-line:no-var-requires */
 const version = require("../../package.json").version;
@@ -15,49 +22,40 @@ const walletHeaders = {
   "X-Client-Version": version,
 };
 
-export class Config {
-  app: ApplicationConfiguration;
-  stellar: StellarConfiguration;
-  constructor(stellarCfg, appCfg) {
-    this.stellar = stellarCfg;
-    this.app = appCfg;
-  }
-}
-
 export class Wallet {
   private cfg: Config;
   private language: string;
 
   static TestNet = (): Wallet => {
-    return new Wallet(StellarConfiguration.TestNet());
+    return new Wallet({
+      stellarConfiguration: StellarConfiguration.TestNet(),
+    });
   };
 
   static MainNet = (): Wallet => {
-    return new Wallet(StellarConfiguration.MainNet());
+    return new Wallet({
+      stellarConfiguration: StellarConfiguration.MainNet(),
+    });
   };
 
-  constructor(
-    stellarConfiguration: StellarConfiguration,
-    applicationConfiguration: ApplicationConfiguration = new ApplicationConfiguration(),
+  constructor({
+    stellarConfiguration,
+    applicationConfiguration = new ApplicationConfiguration(),
     // Defaults wallet language to "en", this will reflect in all Anchor API calls
-    language: string = "en"
-  ) {
-    this.cfg = new Config(stellarConfiguration, applicationConfiguration);
+    language = "en",
+  }: WalletParams) {
+    this.cfg = new Config({ stellarConfiguration, applicationConfiguration });
     this.language = language;
   }
 
-  anchor(
-    homeDomain: string,
-    httpClientConfig: AxiosRequestConfig = {},
-    language: string = this.language
-  ) {
+  anchor({ homeDomain, language = this.language }: WalletAnchor): Anchor {
     const url =
       homeDomain.indexOf("://") !== -1 ? homeDomain : `https://${homeDomain}`;
 
     return new Anchor({
       cfg: this.cfg,
       homeDomain: getUrlDomain(url),
-      httpClient: this.getClient(httpClientConfig),
+      httpClient: this.cfg.app.defaultClient,
       language,
     });
   }
@@ -66,23 +64,26 @@ export class Wallet {
     return new Stellar(this.cfg);
   }
 
-  recover(servers, httpClientConfig: AxiosRequestConfig = {}) {
-    return new Recovery(
-      this.cfg,
-      this.stellar(),
-      this.getClient(httpClientConfig),
-      servers
-    );
+  recovery({ servers }: WalletRecovery): Recovery {
+    return new Recovery({
+      cfg: this.cfg,
+      stellar: this.stellar(),
+      httpClient: this.cfg.app.defaultClient,
+      servers,
+    });
   }
+}
 
-  getClient(httpClientConfig: AxiosRequestConfig = {}) {
-    return axios.create({
-      headers: {
-        ...walletHeaders,
-        ...httpClientConfig.headers,
-      },
-      ...httpClientConfig,
-    });
+export class Config {
+  stellar: StellarConfiguration;
+  app: ApplicationConfiguration;
+
+  constructor({
+    stellarConfiguration,
+    applicationConfiguration,
+  }: ConfigParams) {
+    this.stellar = stellarConfiguration;
+    this.app = applicationConfiguration;
   }
 }
 
@@ -91,32 +92,48 @@ export class StellarConfiguration {
   network: Networks;
   horizonUrl: string;
   baseFee: number;
+  defaultTimeout: number;
 
   static TestNet = (): StellarConfiguration => {
-    return new StellarConfiguration(Networks.TESTNET, NETWORK_URLS.TESTNET);
+    return new StellarConfiguration({
+      network: Networks.TESTNET,
+      horizonUrl: NETWORK_URLS.TESTNET,
+    });
   };
 
   static MainNet = (): StellarConfiguration => {
-    return new StellarConfiguration(Networks.PUBLIC, NETWORK_URLS.PUBLIC);
+    return new StellarConfiguration({
+      network: Networks.PUBLIC,
+      horizonUrl: NETWORK_URLS.PUBLIC,
+    });
   };
 
-  constructor(network, horizonUrl, baseFee = 100) {
+  constructor({
+    network,
+    horizonUrl,
+    baseFee = 100,
+    defaultTimeout = 180,
+  }: StellarConfigurationParams) {
     this.network = network;
-    this.baseFee = baseFee;
     this.horizonUrl = horizonUrl;
+    this.baseFee = baseFee;
+    this.defaultTimeout = defaultTimeout;
     this.server = new Server(horizonUrl);
   }
 }
 
+export const DefaultClient = axios.create({
+  headers: {
+    ...walletHeaders,
+  },
+});
+
 export class ApplicationConfiguration {
   defaultSigner: WalletSigner;
   defaultClient: AxiosInstance;
-  constructor(defaultSigner: WalletSigner = DefaultSigner) {
-    this.defaultSigner = defaultSigner;
-    this.defaultClient = axios.create({
-      headers: {
-        ...walletHeaders,
-      },
-    });
+
+  constructor(defaultSigner?: WalletSigner, defaultClient?: AxiosInstance) {
+    this.defaultSigner = defaultSigner || DefaultSigner;
+    this.defaultClient = defaultClient || DefaultClient;
   }
 }

package/test/account.test.ts

@@ -1,35 +1,39 @@
-import StellarSdk, {
-  Keypair,
-  TransactionBuilder,
-  Transaction,
-  FeeBumpTransaction,
-  Networks,
-} from "stellar-sdk";
-import { PublicKeypair } from "../src/walletSdk/horizon/Account";
+import crypto from "crypto";
+import { TransactionBuilder, Networks } from "stellar-sdk";
 
-import sdk from "../src";
-const { walletSdk } = sdk;
+import { Wallet } from "../src";
+import { PublicKeypair } from "../src/walletSdk/Horizon/Account";
 
+let wal;
+let account;
 describe("Account", () => {
-  it("should init keypair and sign", () => {
-    const wal = walletSdk.Wallet.TestNet();
-    const account = wal.stellar().account();
+  beforeEach(() => {
+    wal = Wallet.TestNet();
+    account = wal.stellar().account();
+  });
+  it("should create keypair and sign", () => {
     const kp = account.createKeypair();
     expect(kp.publicKey).toBeTruthy();
     expect(kp.secretKey).toBeTruthy();
 
     const tx = TransactionBuilder.fromXDR(
       "AAAAAgAAAADk/TqnRl6sFK79yasH46qlX/dFxQ8R023aHRxAkUmE8wAAAGQAAAAAAAAAAQAAAAEAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAEAAAAAAAAAAQAAAADk/TqnRl6sFK79yasH46qlX/dFxQ8R023aHRxAkUmE8wAAAAAAAAAABfXhAAAAAAAAAAAA",
-      Networks.TESTNET
+      Networks.TESTNET,
     );
     kp.sign(tx);
     expect(tx.signatures.length).toBe(1);
     tx.sign(kp.keypair);
     expect(tx.signatures.length).toBe(2);
   });
+  it("should create keypair from random", () => {
+    const rand = crypto.randomBytes(32);
+    const kp = account.createKeypairFromRandom(rand);
+    expect(kp.publicKey).toBeTruthy();
+    expect(kp.secretKey).toBeTruthy();
+  });
   it("can init from string", () => {
     const kp = PublicKeypair.fromPublicKey(
-      "GCPECGTX5RZWBJNH7Q3FNN4742R7OKMSP6G4ECCUX7Q5IGDCYYG2I447"
+      "GCPECGTX5RZWBJNH7Q3FNN4742R7OKMSP6G4ECCUX7Q5IGDCYYG2I447",
     );
     expect(kp.publicKey).toBeTruthy();
   });