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

package/src/walletSdk/Utils/toml.ts

@@ -0,0 +1,103 @@
+import { StellarTomlResolver } from "stellar-sdk";
+
+import { TomlInfo } from "../Types";
+
+export const parseToml = (toml: StellarTomlResolver.StellarToml): TomlInfo => {
+  const tomlDocumentation = toml["DOCUMENTATION"];
+  const documentation = {
+    orgName: tomlDocumentation["ORG_NAME"],
+    orgDba: tomlDocumentation["ORG_DBA"],
+    orgUrl: tomlDocumentation["ORG_URL"],
+    orgLogo: tomlDocumentation["ORG_LOGO"],
+    orgDescription: tomlDocumentation["ORG_DESCRIPTION"],
+    orgPhysicalAddress: tomlDocumentation["ORG_PHYSICAL_ADDRESS"],
+    orgPhysicalAddressAttestation:
+      tomlDocumentation["ORG_PHYSICAL_ADDRESS_ATTESTATION"],
+    orgPhoneNumber: tomlDocumentation["ORG_PHONE_NUMBER"],
+    orgPhoneNumberAttestation:
+      tomlDocumentation["ORG_PHONE_NUMBER_ATTESTATION"],
+    orgKeybase: tomlDocumentation["ORG_KEYBASE"],
+    orgTwitter: tomlDocumentation["ORG_TWITTER"],
+    orgGithub: tomlDocumentation["ORG_GITHUB"],
+    orgOfficialEmail: tomlDocumentation["ORG_OFFICIAL_EMAIL"],
+    orgSupportEmail: tomlDocumentation["ORG_SUPPORT_EMAIL"],
+    orgLicensingAuthority: tomlDocumentation["ORG_LICENSING_AUTHORITY"],
+    orgLicenseType: tomlDocumentation["ORG_LICENSE_TYPE"],
+    orgLicenseNumber: tomlDocumentation["ORG_LICENSE_NUMBER"],
+  };
+
+  const tomlPrincipals = toml["PRINCIPALS"] || [];
+  const principals = tomlPrincipals.map((tp) => {
+    return {
+      name: tp["name"],
+      email: tp["email"],
+      keybase: tp["keybase"],
+      telegram: tp["telegram"],
+      twitter: tp["twitter"],
+      github: tp["github"],
+      idPhotoHash: tp["id_photo_hash"],
+      verificationPhotoHash: tp["verification_photo_hash"],
+    };
+  });
+
+  const tomlCurrencies = toml["CURRENCIES"] || [];
+  const currencies = tomlCurrencies.map((tc) => {
+    return {
+      code: tc["code"],
+      codeTemplate: tc["code_template"],
+      issuer: tc["issuer"],
+      status: tc["status"],
+      displayDecimals: tc["display_decimals"],
+      name: tc["name"],
+      desc: tc["desc"],
+      conditions: tc["conditions"],
+      image: tc["image"],
+      fixedNumber: tc["fixed_number"],
+      maxNumber: tc["max_number"],
+      isUnlimited: tc["is_unlimited"],
+      isAssetAnchored: tc["is_asset_anchored"],
+      anchorAssetType: tc["anchor_asset_type"],
+      anchorAsset: tc["anchor_asset"],
+      attestationOfReserve: tc["attestation_of_reserve"],
+      redemptionInstructions: tc["redemption_instructions"],
+      collateralAddresses: tc["collateral_addresses"],
+      collateralAddressMessages: tc["collateral_address_messages"],
+      collateralAddressSignatures: tc["collateral_address_signatures"],
+      regulated: tc["regulated"],
+      approvalServer: tc["approval_server"],
+      approvalCriteria: tc["approval_criteria"],
+    };
+  });
+
+  const tomlValidators = toml["VALIDATORS"] || [];
+  const validators = tomlValidators.map((tv) => {
+    return {
+      alias: tv["ALIAS"],
+      displayName: tv["DISPLAY_NAME"],
+      publicKey: tv["PUBLIC_KEY"],
+      host: tv["HOST"],
+      history: tv["HISTORY"],
+    };
+  });
+
+  return {
+    version: toml["VERSION"],
+    networkPassphrase: toml["NETWORK_PASSPHRASE"],
+    federationServer: toml["FEDERATION_SERVER"],
+    authServer: toml["AUTH_SERVER"] as string,
+    transferServer: toml["TRANSFER_SERVER"],
+    transferServerSep24: toml["TRANSFER_SERVER_SEP0024"],
+    kycServer: toml["KYC_SERVER"],
+    webAuthEndpoint: toml["WEB_AUTH_ENDPOINT"],
+    signingKey: toml["SIGNING_KEY"],
+    horizonUrl: toml["HORIZON_URL"],
+    accounts: toml["ACCOUNTS"],
+    uriRequestSigningKey: toml["URI_REQUEST_SIGNING_KEY"],
+    directPaymentServer: toml["DIRECT_PAYMENT_SERVER"],
+    anchorQuoteServer: toml["ANCHOR_QUOTE_SERVER"],
+    documentation,
+    principals,
+    currencies,
+    validators,
+  };
+};

package/src/walletSdk/{util → Utils}/url.ts

@@ -7,6 +7,6 @@ if (typeof window === "undefined") {
   Url = window.URL;
 }
 
-export const getUrlDomain = (url) => {
+export const getUrlDomain = (url: string) => {
   return new Url(url).host;
 };

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 {
       },
     };
   }
-
 }