feat: partial tx facade

__tests__/integration/atomic_swap.test.js

@@ -0,0 +1,82 @@
+import { GenesisWalletHelper } from './helpers/genesis-wallet.helper';
+import {
+  createTokenHelper,
+  DEFAULT_PIN_CODE,
+  generateWalletHelper,
+  stopAllWallets,
+  waitForTxReceived,
+} from './helpers/wallet.helper';
+import { HATHOR_TOKEN_CONFIG } from '../../src/constants';
+import SendTransaction from '../../src/new/sendTransaction';
+import PartialTxProposal from '../../src/wallet/partialTxProposal';
+import storage from '../../src/storage';
+
+describe('partial tx proposal', () => {
+  afterEach(async () => {
+    await stopAllWallets();
+    await GenesisWalletHelper.clearListeners();
+  });
+
+  it('Should exchange tokens between wallets', async () => {
+    // Create the wallet
+    const hWallet1 = await generateWalletHelper();
+    const hWallet2 = await generateWalletHelper();
+    const network = hWallet1.getNetworkObject();
+
+    // Injecting funds and creating a new custom token
+    await GenesisWalletHelper.injectFunds(hWallet1.getAddressAtIndex(0), 101);
+    const { hash: token1Uid } = await createTokenHelper(
+      hWallet1,
+      'Token1',
+      'TK1',
+      100,
+    );
+
+    // Injecting funds and creating a new custom token
+    await GenesisWalletHelper.injectFunds(hWallet2.getAddressAtIndex(0), 10);
+    const { hash: token2Uid } = await createTokenHelper(
+      hWallet2,
+      'Token2',
+      'TK2',
+      1000,
+    );
+
+    /**
+     * The exchange will be:
+     *
+     * Wallet1 will send 100 HTR and 100 TK1
+     * Wallet2 will send 1000 TK2
+     */
+    const proposal = new PartialTxProposal(network);
+    // Wallet1 side
+    proposal.addSend(hWallet1, HATHOR_TOKEN_CONFIG.uid, 100);
+    proposal.addSend(hWallet1, token1Uid, 100);
+    proposal.addReceive(hWallet1, token2Uid, 1000);
+    expect(proposal.partialTx.isComplete()).toBeFalsy();
+    // Wallet2 side
+    proposal.addSend(hWallet2, token2Uid, 1000);
+    proposal.addReceive(hWallet2, HATHOR_TOKEN_CONFIG.uid, 100);
+    proposal.addReceive(hWallet2, token1Uid, 100);
+    expect(proposal.partialTx.isComplete()).toBeTruthy();
+
+    const serialized = proposal.partialTx.serialize();
+    const proposal1 = PartialTxProposal.fromPartialTx(serialized, network);
+    storage.setStore(hWallet1.store);
+    await proposal1.signData(DEFAULT_PIN_CODE, true);
+    expect(proposal1.signatures.isComplete()).toBeFalsy();
+
+    const proposal2 = PartialTxProposal.fromPartialTx(serialized, network);
+    storage.setStore(hWallet2.store);
+    await proposal2.signData(DEFAULT_PIN_CODE, true);
+
+    expect(proposal2.signatures.isComplete()).toBeFalsy();
+
+    proposal2.signatures.addSignatures(proposal1.signatures.serialize());
+    expect(proposal2.signatures.isComplete()).toBeTruthy();
+
+    const transaction = proposal2.prepareTx();
+    const sendTransaction = new SendTransaction({ transaction, network });
+    const tx = await sendTransaction.runFromMining();
+    expect(tx.hash).toBeDefined();
+  });
+});

__tests__/models/partial_tx.test.js

@@ -12,7 +12,13 @@ import dateFormatter from '../../src/date';
 
 
 import { UnsupportedScriptError } from '../../src/errors';
-import { HATHOR_TOKEN_CONFIG, DEFAULT_TX_VERSION, TOKEN_AUTHORITY_MASK } from '../../src/constants';
+import {
+  HATHOR_TOKEN_CONFIG,
+  DEFAULT_TX_VERSION,
+  TOKEN_AUTHORITY_MASK,
+  TOKEN_MINT_MASK,
+  TOKEN_MELT_MASK,
+} from '../../src/constants';
 import helpers from '../../src/utils/helpers';
 import txApi from '../../src/api/txApi';
 import P2PKH from '../../src/models/p2pkh';
@@ -178,7 +184,7 @@ describe('PartialTx.isComplete', () => {
       new ProposalOutput(1, Buffer.from([])),
       new ProposalOutput(1, Buffer.from([]), { token: '2' }),
       // Add authority output for token 2
-      new ProposalOutput(1, Buffer.from([]), { token: '2', authorities: 1 }), // mint
+      new ProposalOutput(1, Buffer.from([]), { token: '2', authorities: TOKEN_MINT_MASK }),
     ];
 
     expect(partialTx.isComplete()).toBe(true);
@@ -203,8 +209,8 @@ describe('PartialTx.addInput', () => {
     expect(partialTx.inputs).toEqual(expected);
 
     // Authority input
-    expected.push(expect.objectContaining({ hash: 'hash3', index: 10, token: '1', authorities: 3, value: 1056, address: 'W1b3' }));
-    partialTx.addInput('hash3', 10, 1056, 'W1b3', { token: '1', authorities: 3 });
+    expected.push(expect.objectContaining({ hash: 'hash3', index: 10, token: '1', authorities: TOKEN_MINT_MASK | TOKEN_MELT_MASK, value: 1056, address: 'W1b3' }));
+    partialTx.addInput('hash3', 10, 1056, 'W1b3', { token: '1', authorities: TOKEN_MINT_MASK | TOKEN_MELT_MASK });
     expect(partialTx.inputs).toEqual(expected);
   });
 });
@@ -223,9 +229,9 @@ describe('PartialTx.addOutput', () => {
       isChange: true,
       value: 27,
       script: expect.toMatchBuffer(Buffer.from([230, 148, 32])),
-      authorities: 2,
+      authorities: TOKEN_MELT_MASK,
     }));
-    partialTx.addOutput(27, Buffer.from([230, 148, 32]), { token: '1', authorities: 2, isChange: true});
+    partialTx.addOutput(27, Buffer.from([230, 148, 32]), { token: '1', authorities: TOKEN_MELT_MASK, isChange: true});
     expect(partialTx.outputs).toEqual(expected);
 
     expected.push(expect.objectContaining({
@@ -464,7 +470,7 @@ describe('PartialTx.validate', () => {
     // TokenData of inputs[1] is wrong
     partialTx.inputs = [
       new ProposalInput(txId1, 0, 27, addr1),
-      new ProposalInput(txId2, 4, 13, addr2, { token: testTokenConfig.uid, authorities: 2 }),
+      new ProposalInput(txId2, 4, 13, addr2, { token: testTokenConfig.uid, authorities: TOKEN_MELT_MASK }),
     ];
 
     await expect(partialTx.validate()).resolves.toEqual(false);

__tests__/wallet/partialTxProposal.test.ts

@@ -295,11 +295,11 @@ test('addInput', async () => {
     20,
     70,
     ADDR2,
-    { token: FAKE_UID, authorities: 1, markAsSelected: false },
+    { token: FAKE_UID, authorities: TOKEN_MINT_MASK, markAsSelected: false },
   );
   expect(spyReset).toHaveBeenCalledTimes(1);
   expect(hwallet.markUtxoSelected).not.toHaveBeenCalled();
-  expect(spyInput).toBeCalledWith(FAKE_TXID, 20, 70, ADDR2, { token: FAKE_UID, authorities: 1 });
+  expect(spyInput).toBeCalledWith(FAKE_TXID, 20, 70, ADDR2, { token: FAKE_UID, authorities: TOKEN_MINT_MASK });
 
   // Remove mocks
   spyReset.mockRestore();
@@ -381,12 +381,12 @@ test('calculateBalance', async () => {
     new ProposalInput(FAKE_TXID, 2, 7, ADDR3),
     new ProposalInput(FAKE_TXID, 3, 3, ADDR1),
     // Authority
-    new ProposalInput(FAKE_TXID, 4, TOKEN_MELT_MASK, ADDR2, { token: fakeUid3, authorities: 2 }),
-    new ProposalInput(FAKE_TXID, 5, TOKEN_MELT_MASK, ADDR3, { token: fakeUid3, authorities: 2 }),
+    new ProposalInput(FAKE_TXID, 4, TOKEN_MELT_MASK, ADDR2, { token: fakeUid3, authorities: TOKEN_MELT_MASK }),
+    new ProposalInput(FAKE_TXID, 5, TOKEN_MELT_MASK, ADDR3, { token: fakeUid3, authorities: TOKEN_MELT_MASK }),
     // Not from the wallet
     new ProposalInput(FAKE_TXID, 6, 4, ADDR_OTHER, { token: fakeUid3 }),
     new ProposalInput(FAKE_TXID, 7, 999, ADDR_OTHER, { token: fakeUid4 }),
-    new ProposalInput(FAKE_TXID, 8, TOKEN_MINT_MASK, ADDR_OTHER, { token: fakeUid3, authorities: 1 }),
+    new ProposalInput(FAKE_TXID, 8, TOKEN_MINT_MASK, ADDR_OTHER, { token: fakeUid3, authorities: TOKEN_MINT_MASK }),
   ], [
     new ProposalOutput(5, scriptFromAddressP2PKH(ADDR1), { token: FAKE_UID }),
     new ProposalOutput(8, scriptFromAddressP2PKH(ADDR2), { token: fakeUid2 }),
@@ -397,13 +397,13 @@ test('calculateBalance', async () => {
     new ProposalOutput(3, scriptFromAddressP2PKH(ADDR3, timelock), { token: FAKE_UID }),
     new ProposalOutput(4, scriptFromAddressP2PKH(ADDR1, timelock), { token: fakeUid2 }),
     // Authority
-    new ProposalOutput(TOKEN_MINT_MASK, scriptFromAddressP2PKH(ADDR2), { token: FAKE_UID, authorities: 1 }),
+    new ProposalOutput(TOKEN_MINT_MASK, scriptFromAddressP2PKH(ADDR2), { token: FAKE_UID, authorities: TOKEN_MINT_MASK }),
     // Authority locked
-    new ProposalOutput(TOKEN_MELT_MASK, scriptFromAddressP2PKH(ADDR3, timelock), { token: fakeUid2, authorities: 2 }),
-    new ProposalOutput(TOKEN_MINT_MASK, scriptFromAddressP2PKH(ADDR1, timelock), { token: fakeUid3, authorities: 1 }),
+    new ProposalOutput(TOKEN_MELT_MASK, scriptFromAddressP2PKH(ADDR3, timelock), { token: fakeUid2, authorities: TOKEN_MELT_MASK }),
+    new ProposalOutput(TOKEN_MINT_MASK, scriptFromAddressP2PKH(ADDR1, timelock), { token: fakeUid3, authorities: TOKEN_MINT_MASK }),
     // Not from the wallet
     new ProposalOutput(10, scriptFromAddressP2PKH(ADDR_OTHER)),
-    new ProposalOutput(TOKEN_MELT_MASK, scriptFromAddressP2PKH(ADDR_OTHER), { token: fakeUid2, authorities: 2 }),
+    new ProposalOutput(TOKEN_MELT_MASK, scriptFromAddressP2PKH(ADDR_OTHER), { token: fakeUid2, authorities: TOKEN_MELT_MASK }),
   ]);
   /**
    * Summary of the test fixture