feat: process tx after push

__tests__/integration/helpers/wallet.helper.ts

@@ -234,7 +234,7 @@ export async function stopAllWallets() {
  *
  * @return {Promise<CreateNewTokenResponse>}
  */
-export async function createTokenHelper(hWallet, name, symbol, amount, options) {
+export async function createTokenHelper(hWallet, name, symbol, amount, options = {}) {
   const newTokenResponse = await hWallet.createNewToken(name, symbol, amount, options);
   const tokenUid = newTokenResponse.hash;
   await waitForTxReceived(hWallet, tokenUid);
@@ -271,10 +271,9 @@ export function waitForWalletReady(hWallet) {
  * Waits for the wallet to receive the transaction from a websocket message
  * and process the history
  *
- * @param {HathorWallet} hWallet
- * @param {string} txId
- * @param {number} [timeout] Timeout in milisseconds. Default value defined on test-constants.
- * @returns {Promise<IHistoryTx>}
+ * @param hWallet
+ * @param txId
+ * @param [timeout] Timeout in milisseconds. Default value defined on test-constants.
  */
 export async function waitForTxReceived(
   hWallet: HathorWallet,
@@ -289,7 +288,7 @@ export async function waitForTxReceived(
     timeoutReached = true;
   }, timeoutPeriod);
 
-  let storageTx = await hWallet.getTx(txId);
+  let storageTx = (await hWallet.getTx(txId)) as IHistoryTx;
 
   // We consider that the tx was received after it's in the storage
   // and the history processing is finished
@@ -300,7 +299,7 @@ export async function waitForTxReceived(
 
     // Tx not found, wait 1s before trying again
     await delay(1000);
-    storageTx = await hWallet.getTx(txId);
+    storageTx = (await hWallet.getTx(txId)) as IHistoryTx;
   }
 
   // Clean timeout handler

__tests__/integration/utils/core.util.ts

@@ -7,10 +7,9 @@
 
 /**
  * Simple way to wait asynchronously before continuing the funcion. Does not block the JS thread.
- * @param {number} ms Amount of milliseconds to delay
- * @returns {Promise<unknown>}
+ * @param ms Amount of milliseconds to delay
  */
-export async function delay(ms) {
+export async function delay(ms: number): Promise<unknown> {
   return new Promise(resolve => {
     setTimeout(resolve, ms);
   });
@@ -19,11 +18,8 @@ export async function delay(ms) {
 /**
  * Generates a random positive integer between the maximum and minimum values,
  * with the default minimum equals zero
- * @param {number} max
- * @param {number} [min=0]
- * @returns {number} Random number
  */
-export function getRandomInt(max, min = 0) {
+export function getRandomInt(max: number, min: number = 0): number {
   const _min = Math.ceil(min);
   const _max = Math.floor(max);
   return Math.floor(Math.random() * (_max - _min + 1)) + _min;

src/api/txApi.ts

@@ -5,10 +5,9 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { AxiosResponse } from 'axios';
 import { createRequestInstance } from './axiosInstance';
 import { transformJsonBigIntResponse } from '../utils/bigint';
-import { TransactionSchema, transactionSchema } from './schemas/txApi';
+import { transactionSchema } from './schemas/txApi';
 
 /**
  * Api calls for transaction
@@ -78,7 +77,7 @@ const txApi = {
    * @memberof ApiTransaction
    * @inner
    */
-  getTransaction(id, resolve): Promise<void | AxiosResponse<TransactionSchema>> {
+  getTransaction(id, resolve): Promise<void> {
     const data = { id };
     return this.getTransactionBase(data, resolve, transactionSchema);
   },

src/models/p2pkh.ts

@@ -16,6 +16,7 @@ import {
 import { intToBytes } from '../utils/buffer';
 import helpers from '../utils/helpers';
 import Address from './address';
+import { IHistoryOutputDecoded } from '../types';
 
 type optionsType = {
   timelock?: number | null | undefined;
@@ -82,6 +83,17 @@ class P2PKH {
     return util.buffer.concat(arr);
   }
 
+  /**
+   * Build the original decoded script
+   */
+  toData(): IHistoryOutputDecoded {
+    return {
+      type: this.getType(),
+      address: this.address.base58,
+      timelock: this.timelock,
+    };
+  }
+
   /**
    * Identify a script as P2PKH or not.
    *

src/models/p2sh.ts

@@ -10,6 +10,7 @@ import { OP_GREATERTHAN_TIMESTAMP, OP_HASH160, OP_EQUAL } from '../opcodes';
 import helpers from '../utils/helpers';
 import { intToBytes } from '../utils/buffer';
 import Address from './address';
+import { IHistoryOutputDecoded } from '../types';
 
 type optionsType = {
   timelock?: number | null | undefined;
@@ -49,6 +50,17 @@ class P2SH {
     return 'p2sh';
   }
 
+  /**
+   * Build the original decoded script
+   */
+  toData(): IHistoryOutputDecoded {
+    return {
+      type: this.getType(),
+      address: this.address.base58,
+      timelock: this.timelock,
+    };
+  }
+
   /**
    * Create a P2SH script
    *

src/models/script_data.ts

@@ -9,6 +9,7 @@ import { util } from 'bitcore-lib';
 import buffer from 'buffer';
 import { OP_CHECKSIG } from '../opcodes';
 import helpers from '../utils/helpers';
+import { IHistoryOutputDecoded } from '../types';
 
 class ScriptData {
   // String of data to store on the script
@@ -34,6 +35,16 @@ class ScriptData {
     return 'data';
   }
 
+  /**
+   * Build the original decoded script
+   */
+  toData(): IHistoryOutputDecoded {
+    return {
+      type: this.getType(),
+      data: this.data,
+    };
+  }
+
   /**
    * Create an output script from data
    *

src/new/sendTransaction.ts

@@ -28,6 +28,8 @@ import {
 } from '../types';
 import Transaction from '../models/transaction';
 import { bestUtxoSelection } from '../utils/utxo';
+import { addCreatedTokenFromTx } from '../utils/storage';
+import CreateTokenTransaction from '../models/create_token_transaction';
 
 export interface ISendInput {
   txId: string;
@@ -422,6 +424,23 @@ export default class SendTransaction extends EventEmitter {
               throw new WalletError(ErrorMessages.TRANSACTION_IS_NULL);
             }
             this.transaction.updateHash();
+            if (this.storage) {
+              // Add transaction to storage and process storage
+              (async (storage: IStorage, transaction: Transaction) => {
+                // Get the transaction as a history object
+                const historyTx = await transactionUtils.convertTransactionToHistoryTx(
+                  transaction,
+                  storage
+                );
+                // Add transaction to storage
+                await storage.addTx(historyTx);
+                // Add token from a create token transaction to the storage
+                // This just returns if the transaction is not a CREATE_TOKEN_TX
+                await addCreatedTokenFromTx(transaction as CreateTokenTransaction, storage);
+                // Process new transaction
+                await storage.processNewTx(historyTx);
+              })(this.storage, this.transaction);
+            }
             this.emit('send-tx-success', this.transaction);
             resolve(this.transaction);
           } else {

src/storage/storage.ts

@@ -120,8 +120,12 @@ export class Storage implements IStorage {
    * Set the native token config on the store
    */
   async saveNativeToken(): Promise<void> {
-    if ((await this.store.getToken(NATIVE_TOKEN_UID)) === null) {
-      await this.store.saveToken(this.getNativeTokenData());
+    await this.addToken(this.getNativeTokenData());
+  }
+
+  async addToken(data: ITokenData): Promise<void> {
+    if ((await this.store.getToken(data.uid)) === null) {
+      await this.store.saveToken(data);
     }
   }
 

src/types.ts

@@ -506,6 +506,7 @@ export interface IStorage {
   processNewTx(tx: IHistoryTx): Promise<void>;
 
   // Tokens
+  addToken(data: ITokenData): Promise<void>;
   isTokenRegistered(tokenUid: string): Promise<boolean>;
   registerToken(token: ITokenData): Promise<void>;
   unregisterToken(tokenUid: string): Promise<void>;

src/utils/storage.ts

@@ -23,6 +23,7 @@
   HistorySyncFunction,
   WalletType,
   IUtxo,
+  ITokenData,
 } from '../types';
 import walletApi from '../api/wallet';
 import helpers from './helpers';
@@ -35,8 +36,10 @@
   NANO_CONTRACTS_VERSION,
   LOAD_WALLET_MAX_RETRY,
   LOAD_WALLET_RETRY_SLEEP,
+  CREATE_TOKEN_TX_VERSION,
 } from '../constants';
 import { AddressHistorySchema, GeneralTokenInfoSchema } from '../api/schemas/wallet';
+import CreateTokenTransaction from '../models/create_token_transaction';
 
 /**
  * Get history sync method for a given mode
@@ -515,8 +518,12 @@
 
       const { name, symbol } = response;
       const tokenData = { uid, name, symbol };
-      // saveToken will ignore the meta and save only the token config
-      await store.saveToken(tokenData);
+
+      const storeToken = await store.getToken(uid);
+      if (storeToken === null) {
+        // saveToken will ignore the meta and save only the token config
+        await store.saveToken(tokenData);
+      }
     }
   }
 }
@@ -890,3 +897,24 @@
   // Remove utxo from locked utxos so that it is not processed again
   await store.unlockUtxo(lockedUtxo);
 }
+
+export async function addCreatedTokenFromTx(
+  tx: CreateTokenTransaction,
+  storage: IStorage
+): Promise<void> {
+  if (tx.version !== CREATE_TOKEN_TX_VERSION) {
+    return;
+  }
+
+  if (!tx.hash) {
+    throw new Error('Cannot infer UID from transaction without hash');
+  }
+
+  const tokenInfo: ITokenData = {
+    uid: tx.hash,
+    name: tx.name,
+    symbol: tx.symbol,
+  };
+
+  await storage.addToken(tokenInfo);
+}