Merge pull request #788 from HathorNetwork/master

v1.14.0

Author: pedroferreira1

.github/workflows/lint.yml

@@ -0,0 +1,40 @@
+name: linter
+on:
+  push:
+    branches:
+    - master
+    - release
+    - release-candidate
+    tags:
+    - v*
+  pull_request:
+    branches:
+    - release
+    - release-candidate
+    - master
+jobs:
+  linter:
+    runs-on: 'ubuntu-latest'
+    timeout-minutes: 40  # default is 360
+    strategy:
+      matrix:
+        node-version: [20.x]
+    steps:
+    - name: Checkout
+      # https://github.com/actions/checkout/releases/tag/v4.1.7
+      uses: actions/checkout@692973e3d937129bcbf40652eb9f2f61becf3332
+
+    - name: Use Node.js ${{ matrix.node-version }}
+      # https://github.com/actions/setup-node/releases/tag/v4.0.2
+      uses: actions/setup-node@60edb5dd545a775178f52524783378180af0d1f8
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - name: Install dependencies
+      run: npm install
+
+    - name: Build
+      run: npm run build
+
+    - name: Lint and format
+      run: npm run format:check && npm run lint

.github/workflows/main.yml renamed to .github/workflows/unit-test.yml

@@ -36,9 +36,6 @@ jobs:
     - name: Build
       run: npm run build
 
-    - name: Lint and format
-      run: npm run format:check && npm run lint
-
     - name: Test
       run: npm run test
 

__tests__/integration/configuration/docker-compose.yml

@@ -6,7 +6,7 @@ services:
 
   fullnode:
     image:
-      ${HATHOR_LIB_INTEGRATION_TESTS_FULLNODE_IMAGE:-hathornetwork/hathor-core:experimental-nano-sdk-new-types}
+      ${HATHOR_LIB_INTEGRATION_TESTS_FULLNODE_IMAGE:-hathornetwork/hathor-core:experimental-nano-sdk-v1.5-rc4-mempool-hotfix}
     command: [
       "run_node",
       "--listen", "tcp:40404",

__tests__/integration/hathorwallet_facade.test.ts

@@ -1736,6 +1736,61 @@ describe('sendManyOutputsTransaction', () => {
   });
 });
 
+describe('authority utxo selection', () => {
+  afterEach(async () => {
+    await stopAllWallets();
+    await GenesisWalletHelper.clearListeners();
+  });
+
+  it('getMintAuthority', async () => {
+    // Setting up the custom token
+    const hWallet = await generateWalletHelper();
+    await GenesisWalletHelper.injectFunds(hWallet, await hWallet.getAddressAtIndex(0), 1);
+    const { hash: tokenUid } = await createTokenHelper(hWallet, 'Token to test', 'ATST', 100);
+
+    // Mark mint authority as selected_as_input
+    const [mintInput] = await hWallet.getMintAuthority(tokenUid, { many: false });
+    await hWallet.markUtxoSelected(mintInput.txId, mintInput.index, true);
+
+    // getMintAuthority should return even if the utxo is already selected_as_input
+    await expect(hWallet.getMintAuthority(tokenUid, { many: false })).resolves.toStrictEqual([
+      mintInput,
+    ]);
+    await expect(
+      hWallet.getMintAuthority(tokenUid, { many: false, only_available_utxos: false })
+    ).resolves.toStrictEqual([mintInput]);
+
+    // getMintAuthority should not return selected_as_input utxos if only_available_utxos is true
+    await expect(
+      hWallet.getMintAuthority(tokenUid, { many: false, only_available_utxos: true })
+    ).resolves.toStrictEqual([]);
+  });
+
+  it('getMeltAuthority', async () => {
+    // Setting up the custom token
+    const hWallet = await generateWalletHelper();
+    await GenesisWalletHelper.injectFunds(hWallet, await hWallet.getAddressAtIndex(0), 1);
+    const { hash: tokenUid } = await createTokenHelper(hWallet, 'Token to test', 'ATST', 100);
+
+    // Mark melt authority as selected_as_input
+    const [meltInput] = await hWallet.getMeltAuthority(tokenUid, { many: false });
+    await hWallet.markUtxoSelected(meltInput.txId, meltInput.index, true);
+
+    // getMeltAuthority should return even if the utxo is already selected_as_input
+    await expect(hWallet.getMeltAuthority(tokenUid, { many: false })).resolves.toStrictEqual([
+      meltInput,
+    ]);
+    await expect(
+      hWallet.getMeltAuthority(tokenUid, { many: false, only_available_utxos: false })
+    ).resolves.toStrictEqual([meltInput]);
+
+    // getMeltAuthority should not return selected_as_input utxos if only_available_utxos is true
+    await expect(
+      hWallet.getMeltAuthority(tokenUid, { many: false, only_available_utxos: true })
+    ).resolves.toStrictEqual([]);
+  });
+});
+
 describe('createNewToken', () => {
   afterEach(async () => {
     await stopAllWallets();

__tests__/integration/helpers/wallet.helper.ts

@@ -5,7 +5,7 @@
  * LICENSE file in the root directory of this source tree.
  */
 
-import { get } from 'lodash';
+import { get, includes } from 'lodash';
 import Connection from '../../../src/new/connection';
 import {
   DEBUG_LOGGING,
@@ -459,7 +459,9 @@ export async function waitTxConfirmed(
 
   try {
     // Only return the positive response after the tx has a first block
-    while ((await getTxFirstBlock(hWallet, txId)) === null) {
+    // the nano contract txs are executing the method as soon as they arrive in the node
+    // and adding the first_block as mempool so we shouldn't consider this as a valid first block for confirmation
+    while (includes([null, 'mempool'], await getTxFirstBlock(hWallet, txId))) {
       await delay(1000);
 
       // If we've reached the requested timeout, break the while loop

__tests__/integration/nanocontracts/bet.test.ts

@@ -344,6 +344,84 @@ describe('full cycle of bet nano contract', () => {
     // Get tx history with success
     const txHistory = await wallet.getTxHistory();
     expect(txHistory).toHaveLength(4);
+
+    // Now test getting nano state in a past block, after the second bet
+    const bet2TxData = await wallet.getFullTxById(txBet2.hash);
+    const firstBlock = bet2TxData.meta.first_block;
+    const firstBlockHeight = bet2TxData.meta.first_block_height;
+
+    // Get NC state in the past, using txBet2 first block
+    const ncStateFirstBlock = await ncApi.getNanoContractState(
+      tx1.hash,
+      [
+        'token_uid',
+        'total',
+        'final_result',
+        'oracle_script',
+        'date_last_bet',
+        `address_details.a'${address2}'`,
+        `withdrawals.a'${address2}'`,
+        `address_details.a'${address3}'`,
+        `withdrawals.a'${address3}'`,
+      ],
+      [],
+      [],
+      firstBlock
+    );
+
+    expect(ncStateFirstBlock.fields.token_uid.value).toBe(NATIVE_TOKEN_UID);
+    expect(ncStateFirstBlock.fields.date_last_bet.value).toBe(dateLastBet);
+    expect(ncStateFirstBlock.fields.oracle_script.value).toBe(bufferToHex(outputScriptBuffer1));
+    expect(ncStateFirstBlock.fields.final_result.value).toBeNull();
+    expect(ncStateFirstBlock.fields.total.value).toBe(300);
+    expect(ncStateFirstBlock.fields[`address_details.a'${address2}'`].value).toHaveProperty(
+      '1x0',
+      100
+    );
+    expect(ncStateFirstBlock.fields[`withdrawals.a'${address2}'`].value).toBeUndefined();
+    expect(ncStateFirstBlock.fields[`address_details.a'${address3}'`].value).toHaveProperty(
+      '2x0',
+      200
+    );
+    expect(ncStateFirstBlock.fields[`withdrawals.a'${address3}'`].value).toBeUndefined();
+
+    // Get NC state in the past, using txBet2 first block height
+    const ncStateFirstBlockHeight = await ncApi.getNanoContractState(
+      tx1.hash,
+      [
+        'token_uid',
+        'total',
+        'final_result',
+        'oracle_script',
+        'date_last_bet',
+        `address_details.a'${address2}'`,
+        `withdrawals.a'${address2}'`,
+        `address_details.a'${address3}'`,
+        `withdrawals.a'${address3}'`,
+      ],
+      [],
+      [],
+      null,
+      firstBlockHeight
+    );
+
+    expect(ncStateFirstBlockHeight.fields.token_uid.value).toBe(NATIVE_TOKEN_UID);
+    expect(ncStateFirstBlockHeight.fields.date_last_bet.value).toBe(dateLastBet);
+    expect(ncStateFirstBlockHeight.fields.oracle_script.value).toBe(
+      bufferToHex(outputScriptBuffer1)
+    );
+    expect(ncStateFirstBlockHeight.fields.final_result.value).toBeNull();
+    expect(ncStateFirstBlockHeight.fields.total.value).toBe(300);
+    expect(ncStateFirstBlockHeight.fields[`address_details.a'${address2}'`].value).toHaveProperty(
+      '1x0',
+      100
+    );
+    expect(ncStateFirstBlockHeight.fields[`withdrawals.a'${address2}'`].value).toBeUndefined();
+    expect(ncStateFirstBlockHeight.fields[`address_details.a'${address3}'`].value).toHaveProperty(
+      '2x0',
+      200
+    );
+    expect(ncStateFirstBlockHeight.fields[`withdrawals.a'${address3}'`].value).toBeUndefined();
   };
 
   it('bet deposit', async () => {

__tests__/new/wallet-utxo.test.ts

@@ -23,9 +23,9 @@ class FakeHathorWallet {
       this[method] = jest.fn().mockImplementation(HathorWallet.prototype[method].bind(this));
     }
 
-    this.sendManyOutputsTransaction.mockImplementation(() => {
-      return Promise.resolve({ hash: '123' });
-    });
+    this.sendManyOutputsSendTransaction.mockImplementation(() => ({
+      run: jest.fn().mockReturnValue(Promise.resolve({ hash: '123' })),
+    }));
 
     // Prepare storage
     const store = new MemoryStore();
@@ -161,18 +161,18 @@ describe('UTXO Consolidation', () => {
 
   test('correctly execute consolidateUtxos', async () => {
     const result = await hathorWallet.consolidateUtxos(destinationAddress);
-    expect(hathorWallet.sendManyOutputsTransaction).toHaveBeenCalled();
+    expect(hathorWallet.sendManyOutputsSendTransaction).toHaveBeenCalled();
     expect(result.total_utxos_consolidated).toBe(2);
     expect(result.total_amount).toBe(2);
     expect(result.txId).toBe('123');
     expect(result.utxos).toHaveLength(2);
     expect(result.utxos.some(utxo => utxo.locked)).toBeFalsy();
     // assert single output
-    expect(hathorWallet.sendManyOutputsTransaction.mock.calls[0][0]).toEqual([
+    expect(hathorWallet.sendManyOutputsSendTransaction.mock.calls[0][0]).toEqual([
       { address: destinationAddress, value: 2, token: '00' },
     ]);
     // assert 2 inputs only
-    expect(hathorWallet.sendManyOutputsTransaction.mock.calls[0][1].inputs).toHaveLength(2);
+    expect(hathorWallet.sendManyOutputsSendTransaction.mock.calls[0][1].inputs).toHaveLength(2);
   });
 
   test('all HTR utxos locked by height', async () => {

src/api/nano.ts

@@ -12,6 +12,7 @@ import {
   NanoContractBlueprintInformationAPIResponse,
   NanoContractHistoryAPIResponse,
   NanoContractStateAPIResponse,
+  NanoContractStateAPIParameters,
 } from '../nano_contracts/types';
 
 /**
@@ -28,6 +29,8 @@ const ncApi = {
    * @param fields Array of fields to get state
    * @param balances Array of balances to get state
    * @param calls Array of private method calls to execute in the nano contract and get the result
+   * @param block_hash Hash of the block to get the state of the nano
+   * @param block_height Height of the block to get the state of the nano
    *
    * @memberof ApiNanoContracts
    * @inner
@@ -36,9 +39,20 @@ const ncApi = {
     id: string,
     fields: string[],
     balances: string[],
-    calls: string[]
+    calls: string[],
+    block_hash: string | null = null,
+    block_height: number | null = null
   ): Promise<NanoContractStateAPIResponse> {
-    const data = { id, fields, balances, calls };
+    const data: NanoContractStateAPIParameters = { id, fields, balances, calls };
+
+    if (block_hash) {
+      data.block_hash = block_hash;
+    }
+
+    if (block_height) {
+      data.block_height = block_height;
+    }
+
     const axiosInstance = await createRequestInstance();
     try {
       const response = await axiosInstance.get(`nano_contract/state`, { params: data });

src/nano_contracts/types.ts

@@ -98,3 +98,12 @@ export interface NanoContractStateAPIResponse {
   // Calls requested
   calls: Map<string, StateValueSuccess | StateValueError>;
 }
+
+export interface NanoContractStateAPIParameters {
+  id: string;
+  fields: string[];
+  balances: string[];
+  calls: string[];
+  block_hash?: string;
+  block_height?: number;
+}