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;

__tests__/utils/storage.test.ts

@@ -16,8 +16,11 @@ import {
   getSupportedSyncMode,
   getHistorySyncMethod,
   apiSyncHistory,
+  addCreatedTokenFromTx,
 } from '../../src/utils/storage';
 import { manualStreamSyncHistory, xpubStreamSyncHistory } from '../../src/sync/stream';
+import CreateTokenTransaction from '../../src/models/create_token_transaction';
+import Transaction from '../../src/models/transaction';
 
 describe('scanning policy methods', () => {
   it('start addresses', async () => {
@@ -356,8 +359,34 @@ test('getSupportedSyncMode', async () => {
   await expect(getSupportedSyncMode(storage)).resolves.toEqual([]);
 });
 
-test('getHistorySyyncMethod', () => {
+test('getHistorySyncMethod', () => {
   expect(getHistorySyncMethod(HistorySyncMode.POLLING_HTTP_API)).toEqual(apiSyncHistory);
   expect(getHistorySyncMethod(HistorySyncMode.MANUAL_STREAM_WS)).toEqual(manualStreamSyncHistory);
   expect(getHistorySyncMethod(HistorySyncMode.XPUB_STREAM_WS)).toEqual(xpubStreamSyncHistory);
 });
+
+test('addCreatedTokenFromTx', async () => {
+  const store = new MemoryStore();
+  const storage = new Storage(store);
+  const spy = jest.spyOn(storage, 'addToken');
+  const tx = new CreateTokenTransaction('Token A', 'tkA', [], []);
+  const notCreateTokenTx = new Transaction([], []);
+
+  // If we force a transaction without the correct version it should do nothing.
+  await addCreatedTokenFromTx(notCreateTokenTx as CreateTokenTransaction, storage);
+  expect(spy).not.toHaveBeenCalled();
+
+  // Tx without hash means we do not know the UID.
+  await expect(addCreatedTokenFromTx(tx, storage)).rejects.toThrow();
+  expect(spy).not.toHaveBeenCalled();
+
+  // A working test
+  tx.hash = 'd00d';
+  await addCreatedTokenFromTx(tx, storage);
+  expect(spy).toHaveBeenCalledWith({
+    uid: 'd00d',
+    name: 'Token A',
+    symbol: 'tkA',
+  });
+  await expect(storage.getToken('d00d')).resolves.not.toBeNull();
+});

__tests__/utils/transaction.test.ts

@@ -19,9 +19,13 @@ import {
   TOKEN_MELT_MASK,
   TOKEN_MINT_MASK,
 } from '../../src/constants';
+import txApi from '../../src/api/txApi';
 import { MemoryStore, Storage } from '../../src/storage';
 import Input from '../../src/models/input';
 import Transaction from '../../src/models/transaction';
+import Output from '../../src/models/output';
+import P2PKH from '../../src/models/p2pkh';
+import Address from '../../src/models/address';
 
 test('isAuthorityOutput', () => {
   expect(transaction.isAuthorityOutput({ token_data: TOKEN_AUTHORITY_MASK })).toBe(true);
@@ -464,3 +468,197 @@ test('getTxType', () => {
   expect(transaction.getTxType({ version: POA_BLOCK_VERSION })).toBe('Proof-of-Authority Block');
   expect(transaction.getTxType({ version: 999 })).toBe('Unknown');
 });
+
+test('convertTransactionToHistoryTx', async () => {
+  const p2pkh = new P2PKH(new Address('WYBwT3xLpDnHNtYZiU52oanupVeDKhAvNp'));
+  const script = p2pkh.createScript();
+  const store = new MemoryStore();
+  await store.saveTx({
+    tx_id: 'from-storage-tx1',
+    inputs: [],
+    outputs: [
+      {
+        script: script.toString('hex'),
+        decoded: { address: 'WYBwT3xLpDnHNtYZiU52oanupVeDKhAvNp' },
+        spent_by: null,
+        token: 'token-C',
+        token_data: 2,
+        value: 123n,
+        selected_as_input: false,
+      },
+      {
+        script: script.toString('hex'),
+        decoded: { address: 'WYBwT3xLpDnHNtYZiU52oanupVeDKhAvNp' },
+        spent_by: null,
+        token: 'token-A',
+        token_data: 1,
+        value: 1n,
+        selected_as_input: false,
+      },
+    ],
+    tokens: [],
+    is_voided: false,
+    nonce: 456,
+    parents: [],
+    timestamp: 123,
+    version: 1,
+    weight: 18,
+  });
+
+  const storage = new Storage(store);
+  storage.config.setNetwork('testnet');
+  const getTxSpy = jest.spyOn(txApi, 'getTransaction');
+  const tx = new Transaction([], [], {
+    hash: '',
+    parents: ['parent-1', 'parent-2'],
+    nonce: 123,
+    timestamp: 456,
+    tokens: ['token-A', 'token-B'],
+    version: 1,
+    signalBits: 5,
+    weight: 18,
+  });
+
+  getTxSpy.mockImplementation(async (txId, resolve) => {
+    switch (txId) {
+      case 'resolve-fail':
+        resolve({ success: false, message: 'failed api call' });
+        break;
+      case 'no-outputs':
+        resolve({
+          success: true,
+          tx: { outputs: [] },
+        });
+        break;
+      case 'fail':
+        throw new Error('Boom!');
+      case 'from-api-tx1':
+        resolve({
+          success: true,
+          tx: {
+            outputs: [
+              {
+                value: 2n,
+                token_data: 129,
+                script: script.toString('hex'),
+                token: 'token-B',
+                decoded: {
+                  type: 'P2PKH',
+                  address: 'WYBwT3xLpDnHNtYZiU52oanupVeDKhAvNp',
+                  timelock: undefined,
+                  token_data: 129,
+                  value: 2n,
+                },
+                spent_by: null,
+              },
+            ],
+            tokens: [{ uid: 'token-B', name: 'Token B', symbol: 'TKB' }],
+            inputs: [],
+            nonce: '',
+            timestamp: 0,
+            version: 1,
+            weight: 19.0,
+            signal_bits: 0,
+            parents: [],
+            hash: '',
+            raw: '',
+          },
+          meta: {
+            hash: '',
+            accumulated_weight: 0,
+            children: [],
+            conflict_with: [],
+            feature_activation_bit_counts: [],
+            height: 0,
+            min_height: 0,
+            received_by: [],
+            score: 0,
+            spent_outputs: [],
+            twins: [],
+            voided_by: [],
+            first_block: '',
+            first_block_height: 0,
+            validation: '',
+          },
+          spent_outputs: [],
+        });
+        break;
+      default:
+        throw new Error('Unknown test case');
+    }
+  });
+
+  try {
+    tx.hash = 'resolve-fail-case';
+    tx.inputs = [new Input('resolve-fail', 0)];
+    await expect(transaction.convertTransactionToHistoryTx(tx, storage)).rejects.toThrow(
+      'failed api call'
+    );
+    tx.hash = 'no-outputs-case';
+    tx.inputs = [new Input('no-outputs', 0)];
+    await expect(transaction.convertTransactionToHistoryTx(tx, storage)).rejects.toThrow(
+      'Index outside of tx output array bounds'
+    );
+
+    tx.hash = 'fail-case';
+    tx.inputs = [new Input('fail', 0)];
+    await expect(transaction.convertTransactionToHistoryTx(tx, storage)).rejects.toThrow('Boom!');
+
+    tx.hash = 'success-case';
+    tx.inputs = [new Input('from-storage-tx1', 1), new Input('from-api-tx1', 0)];
+    tx.outputs = [new Output(3n, script)];
+    await expect(transaction.convertTransactionToHistoryTx(tx, storage)).resolves.toEqual({
+      tx_id: 'success-case',
+      parents: ['parent-1', 'parent-2'],
+      nonce: 123,
+      timestamp: 456,
+      tokens: ['token-A', 'token-B'],
+      version: 1,
+      signalBits: 5,
+      weight: 18,
+      is_voided: false,
+      inputs: [
+        {
+          tx_id: 'from-storage-tx1',
+          index: 1,
+          script: script.toString('hex'),
+          decoded: { address: 'WYBwT3xLpDnHNtYZiU52oanupVeDKhAvNp' },
+          token_data: 1,
+          token: 'token-A',
+          value: 1n,
+        },
+        {
+          tx_id: 'from-api-tx1',
+          index: 0,
+          script: script.toString('hex'),
+          decoded: {
+            type: 'P2PKH',
+            address: 'WYBwT3xLpDnHNtYZiU52oanupVeDKhAvNp',
+            timelock: undefined,
+            token_data: 129,
+            value: 2n,
+          },
+          token_data: 129,
+          token: 'token-B',
+          value: 2n,
+        },
+      ],
+      outputs: [
+        {
+          value: 3n,
+          token_data: 0,
+          script: script.toString('hex'),
+          decoded: {
+            type: 'P2PKH',
+            address: 'WYBwT3xLpDnHNtYZiU52oanupVeDKhAvNp',
+            timelock: null,
+          },
+          token: '00',
+          spent_by: null,
+        },
+      ],
+    });
+  } finally {
+    getTxSpy.mockRestore();
+  }
+});

src/api/schemas/txApi.ts

@@ -45,7 +45,6 @@ export const fullnodeTxApiInputSchema = z.object({
   tx_id: z.string(),
   index: z.number(),
   token: z.string().nullish(),
-  spent_by: z.string().nullish(),
 });
 
 export const fullnodeTxApiOutputSchema = z.object({
@@ -54,7 +53,7 @@ export const fullnodeTxApiOutputSchema = z.object({
   script: z.string(),
   decoded: decodedSchema,
   token: z.string().nullish(),
-  spent_by: z.string().nullish(),
+  spent_by: z.string().nullable().default(null),
 });
 
 export const fullnodeTxApiTokenSchema = z.object({

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().toUpperCase(),
+      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().toUpperCase(),
+      address: this.address.base58,
+      timelock: this.timelock,
+    };
+  }
+
   /**
    * Create a P2SH script
    *