feat: transaction template

__tests__/integration/hathorwallet_facade.test.ts

@@ -34,11 +34,62 @@ import Network from '../../src/models/network';
 import { WalletType } from '../../src/types';
 import { parseScriptData } from '../../src/utils/scripts';
 import { MemoryStore, Storage } from '../../src/storage';
+import { TransactionTemplateBuilder } from '../../src/template/transaction';
 
 const fakeTokenUid = '008a19f84f2ae284f19bf3d03386c878ddd15b8b0b604a3a3539aa9d714686e1';
 const sampleNftData =
   'ipfs://bafybeiccfclkdtucu6y4yc5cpr6y3yuinr67svmii46v5cfcrkp47ihehy/albums/QXBvbGxvIDEwIE1hZ2F6aW5lIDI3L04=/21716695748_7390815218_o.jpg';
 
+describe('template methods', () => {
+  afterEach(async () => {
+    await stopAllWallets();
+    await GenesisWalletHelper.clearListeners();
+  });
+
+  it('should build transactions from the template transaction', async () => {
+    const hWallet = await generateWalletHelper();
+    const address = await hWallet.getAddressAtIndex(1);
+
+    await GenesisWalletHelper.injectFunds(hWallet, address, 10n);
+
+    const template = new TransactionTemplateBuilder()
+      .addConfigAction({ tokenName: 'Tmpl Token', tokenSymbol: 'TT' })
+      .addSetVarAction({ name: 'addr', call: { method: 'get_wallet_address' } })
+      .addUtxoSelect({ fill: 1 })
+      .addTokenOutput({ address: '{addr}', amount: 100, useCreatedToken: true })
+      .build();
+
+    const tx = await hWallet.buildTxTemplate(template, { signTx: true, pinCode: DEFAULT_PIN_CODE });
+    expect(tx.version).toEqual(2); // Create token transaction
+    expect(tx.inputs).toHaveLength(1);
+    expect(tx.inputs[0].data).not.toBeFalsy(); // Tx is signed
+    // Transaction is not mined yet
+    expect(tx.hash).toBeNull();
+    expect(tx.nonce).toEqual(0);
+  });
+
+  it('should send transactions from the template transaction', async () => {
+    const hWallet = await generateWalletHelper();
+    const address = await hWallet.getAddressAtIndex(1);
+
+    await GenesisWalletHelper.injectFunds(hWallet, address, 10n);
+
+    const template = new TransactionTemplateBuilder()
+      .addConfigAction({ tokenName: 'Tmpl Token', tokenSymbol: 'TT' })
+      .addSetVarAction({ name: 'addr', call: { method: 'get_wallet_address' } })
+      .addUtxoSelect({ fill: 1 })
+      .addTokenOutput({ address: '{addr}', amount: 100, useCreatedToken: true })
+      .build();
+
+    const tx = await hWallet.runTxTemplate(template, DEFAULT_PIN_CODE);
+    expect(tx.version).toEqual(2); // Create token transaction
+    expect(tx.inputs).toHaveLength(1);
+    expect(tx.inputs[0].data).not.toBeFalsy(); // Tx is signed
+    // Transaction is mined and pushed
+    expect(tx.hash).not.toBeNull();
+  });
+});
+
 describe('getWalletInputInfo', () => {
   afterEach(async () => {
     await stopAllWallets();
@@ -143,7 +194,7 @@ describe('getTxById', () => {
       },
     });
     await expect(hWallet.getTxById(tx1.hash)).rejects.toThrow(
-      'Token undefined not found in tokens list'
+      'Invalid token_data undefined, token not found in tokens list'
     );
     jest.spyOn(hWallet, 'getFullTxById').mockRestore();
 

__tests__/integration/template/transaction/template.test.ts

@@ -0,0 +1,263 @@
+import { GenesisWalletHelper } from '../../helpers/genesis-wallet.helper';
+import {
+  DEFAULT_PIN_CODE,
+  generateWalletHelper,
+  stopAllWallets,
+  waitForTxReceived,
+} from '../../helpers/wallet.helper';
+
+import HathorWallet from '../../../../src/new/wallet';
+import SendTransaction from '../../../../src/new/sendTransaction';
+import transactionUtils from '../../../../src/utils/transaction';
+import { TransactionTemplateBuilder } from '../../../../src/template/transaction/builder';
+import { WalletTxTemplateInterpreter } from '../../../../src/template/transaction/interpreter';
+
+const DEBUG = true;
+
+describe('Template execution', () => {
+  let hWallet: HathorWallet;
+  let interpreter: WalletTxTemplateInterpreter;
+  let tokenUid: string;
+
+  beforeAll(async () => {
+    hWallet = await generateWalletHelper(null);
+    interpreter = new WalletTxTemplateInterpreter(hWallet);
+    const address = await hWallet.getAddressAtIndex(0);
+    await GenesisWalletHelper.injectFunds(hWallet, address, 10n, {});
+  });
+
+  afterAll(async () => {
+    await hWallet.stop();
+    await stopAllWallets();
+    await GenesisWalletHelper.clearListeners();
+  });
+
+  it('should be able to create a custom token', async () => {
+    const template = new TransactionTemplateBuilder()
+      .addConfigAction({ tokenName: 'Tmpl Test Token 01', tokenSymbol: 'TTT01' })
+      .addSetVarAction({ name: 'addr', call: { method: 'get_wallet_address' } })
+      .addUtxoSelect({ fill: 1 })
+      .addTokenOutput({ address: '{addr}', amount: 100, useCreatedToken: true })
+      .addAuthorityOutput({ authority: 'mint', address: '{addr}', useCreatedToken: true, count: 5 })
+      .addAuthorityOutput({ authority: 'melt', address: '{addr}', useCreatedToken: true, count: 5 })
+      .build();
+
+    const tx = await interpreter.build(template, DEBUG);
+    await transactionUtils.signTransaction(tx, hWallet.storage, DEFAULT_PIN_CODE);
+    tx.prepareToSend();
+    const sendTx = new SendTransaction({ storage: hWallet.storage, transaction: tx });
+    await sendTx.runFromMining();
+    if (tx.hash === null) {
+      throw new Error('Transaction does not have a hash');
+    }
+    tokenUid = tx.hash;
+    await waitForTxReceived(hWallet, tx.hash, null);
+
+    expect(tx.outputs).toHaveLength(12);
+
+    // HTR change
+    expect(tx.outputs[0].tokenData).toBe(0);
+    expect(tx.outputs[0].value).toBe(9n);
+
+    // Created token
+    expect(tx.outputs[1].tokenData).toBe(1);
+    expect(tx.outputs[1].value).toBe(100n);
+
+    // 5 mint authorities
+    expect(tx.outputs[2].tokenData).toBe(129);
+    expect(tx.outputs[2].value).toBe(1n);
+    expect(tx.outputs[6].tokenData).toBe(129);
+    expect(tx.outputs[6].value).toBe(1n);
+
+    // 5 melt authorities
+    expect(tx.outputs[7].tokenData).toBe(129);
+    expect(tx.outputs[7].value).toBe(2n);
+    expect(tx.outputs[11].tokenData).toBe(129);
+    expect(tx.outputs[11].value).toBe(2n);
+  });
+
+  it('should be able to send tokens and authorities', async () => {
+    const address = await hWallet.getAddressAtIndex(10);
+    const template = new TransactionTemplateBuilder()
+      .addSetVarAction({ name: 'addr', value: address })
+      .addSetVarAction({ name: 'token', value: tokenUid })
+      .addUtxoSelect({ fill: 2 })
+      .addTokenOutput({ address: '{addr}', amount: 2 })
+      .addUtxoSelect({ fill: 3, token: '{token}' })
+      .addTokenOutput({ address: '{addr}', amount: 3, token: '{token}' })
+      .addAuthoritySelect({ authority: 'mint', token: '{token}', count: 1 })
+      .addAuthorityOutput({ address: '{addr}', authority: 'mint', count: 1, token: '{token}' })
+      .addAuthoritySelect({ authority: 'melt', token: '{token}', count: 2 })
+      .addAuthorityOutput({ address: '{addr}', authority: 'melt', count: 2, token: '{token}' })
+      .build();
+
+    const tx = await interpreter.build(template, DEBUG);
+    await transactionUtils.signTransaction(tx, hWallet.storage, DEFAULT_PIN_CODE);
+    tx.prepareToSend();
+    const sendTx = new SendTransaction({ storage: hWallet.storage, transaction: tx });
+    await sendTx.runFromMining();
+    await waitForTxReceived(hWallet, tx.hash, null);
+
+    expect(tx.outputs).toHaveLength(7);
+
+    // HTR Change
+    expect(tx.outputs[0].tokenData).toBe(0);
+    expect(tx.outputs[0].value).toBe(7n);
+
+    // HTR
+    expect(tx.outputs[1].tokenData).toBe(0);
+    expect(tx.outputs[1].value).toBe(2n);
+
+    // Custom token change
+    expect(tx.outputs[2].tokenData).toBe(1);
+    expect(tx.outputs[2].value).toBe(97n);
+
+    // Custom token
+    expect(tx.outputs[3].tokenData).toBe(1);
+    expect(tx.outputs[3].value).toBe(3n);
+
+    // mint authority
+    expect(tx.outputs[4].tokenData).toBe(129);
+    expect(tx.outputs[4].value).toBe(1n);
+
+    // melt authorities
+    expect(tx.outputs[5].tokenData).toBe(129);
+    expect(tx.outputs[5].value).toBe(2n);
+    expect(tx.outputs[6].tokenData).toBe(129);
+    expect(tx.outputs[6].value).toBe(2n);
+  });
+
+  it('should be able to destroy authorities', async () => {
+    const template = new TransactionTemplateBuilder()
+      .addSetVarAction({ name: 'token', value: tokenUid })
+      .addAuthoritySelect({ authority: 'mint', token: '{token}', count: 4 })
+      .addAuthoritySelect({ authority: 'melt', token: '{token}', count: 4 })
+      .build();
+
+    const tx = await interpreter.build(template, DEBUG);
+    await transactionUtils.signTransaction(tx, hWallet.storage, DEFAULT_PIN_CODE);
+    tx.prepareToSend();
+    const sendTx = new SendTransaction({ storage: hWallet.storage, transaction: tx });
+    await sendTx.runFromMining();
+    await waitForTxReceived(hWallet, tx.hash, null);
+
+    expect(tx.outputs).toHaveLength(0);
+  });
+
+  it('should be able to mint new tokens', async () => {
+    const address = await hWallet.getAddressAtIndex(15);
+    const template = new TransactionTemplateBuilder()
+      .addSetVarAction({ name: 'addr', value: address })
+      .addSetVarAction({ name: 'token', value: tokenUid })
+      .addUtxoSelect({ fill: 1 })
+      .addAuthoritySelect({ authority: 'mint', token: '{token}' })
+      .addTokenOutput({ address: '{addr}', amount: 100, token: '{token}' })
+      .addAuthorityOutput({ address: '{addr}', authority: 'mint', token: '{token}' })
+      .build();
+
+    const tx = await interpreter.build(template, DEBUG);
+    await transactionUtils.signTransaction(tx, hWallet.storage, DEFAULT_PIN_CODE);
+    tx.prepareToSend();
+    const sendTx = new SendTransaction({ storage: hWallet.storage, transaction: tx });
+    await sendTx.runFromMining();
+    await waitForTxReceived(hWallet, tx.hash, null);
+
+    expect(tx.outputs[0].tokenData).toBe(0);
+    expect(tx.outputs[1].tokenData).toBe(1);
+    expect(tx.outputs[1].value).toBe(100n);
+  });
+
+  it('should be able to melt tokens', async () => {
+    const address = await hWallet.getAddressAtIndex(20);
+    const template = new TransactionTemplateBuilder()
+      .addSetVarAction({ name: 'addr', value: address })
+      .addSetVarAction({ name: 'token', value: tokenUid })
+      .addUtxoSelect({ fill: 100, token: '{token}' })
+      .addAuthoritySelect({ authority: 'melt', token: '{token}' })
+      .addTokenOutput({ address: '{addr}', amount: 1 })
+      .addAuthorityOutput({ address: '{addr}', authority: 'melt', token: '{token}' })
+      .build();
+
+    const tx = await interpreter.build(template, DEBUG);
+    await transactionUtils.signTransaction(tx, hWallet.storage, DEFAULT_PIN_CODE);
+    tx.prepareToSend();
+    const sendTx = new SendTransaction({ storage: hWallet.storage, transaction: tx });
+    await sendTx.runFromMining();
+    await waitForTxReceived(hWallet, tx.hash, null);
+
+    expect(tx.outputs[0].tokenData).toBe(0);
+    expect(tx.outputs[0].value).toBe(1n);
+    expect(tx.outputs[1].tokenData).toBe(129);
+    expect(tx.outputs[1].value).toBe(2n);
+  });
+
+  it('should be able to complete a transaction inputs', async () => {
+    const address = await hWallet.getAddressAtIndex(25);
+    const template = new TransactionTemplateBuilder()
+      .addSetVarAction({ name: 'addr', value: address })
+      .addSetVarAction({ name: 'token', value: tokenUid })
+      .addSetVarAction({
+        name: 'tk_balance',
+        call: { method: 'get_wallet_balance', token: '{token}' },
+      })
+      .addTokenOutput({ address: '{addr}', amount: '{tk_balance}', token: '{token}' })
+      .addAuthorityOutput({ address: '{addr}', authority: 'mint', token: '{token}' })
+      .addAuthorityOutput({ address: '{addr}', authority: 'mint', token: '{token}' })
+      .addCompleteAction({})
+      .addShuffleAction({ target: 'all' })
+      .build();
+
+    const tx = await interpreter.build(template, DEBUG);
+    await transactionUtils.signTransaction(tx, hWallet.storage, DEFAULT_PIN_CODE);
+    tx.prepareToSend();
+    const sendTx = new SendTransaction({ storage: hWallet.storage, transaction: tx });
+    await sendTx.runFromMining();
+    await waitForTxReceived(hWallet, tx.hash, null);
+    expect(tx.hash).toBeDefined();
+  });
+
+  it('should be able to complete a transaction change', async () => {
+    const address = await hWallet.getAddressAtIndex(25);
+    const template = new TransactionTemplateBuilder()
+      .addSetVarAction({ name: 'addr', value: address })
+      .addSetVarAction({ name: 'token', value: tokenUid })
+      .addSetVarAction({
+        name: 'tk_balance',
+        call: { method: 'get_wallet_balance', token: '{token}' },
+      })
+      .addUtxoSelect({ fill: '{tk_balance}', token: '{token}', autoChange: false })
+      .addAuthoritySelect({ token: '{token}', authority: 'mint' })
+      .addAuthoritySelect({ token: '{token}', authority: 'melt' })
+      .addTokenOutput({ address: '{addr}', amount: 1, token: '{token}' })
+      .addCompleteAction({})
+      .build();
+
+    const tx = await interpreter.build(template, DEBUG);
+    await transactionUtils.signTransaction(tx, hWallet.storage, DEFAULT_PIN_CODE);
+    tx.prepareToSend();
+    const sendTx = new SendTransaction({ storage: hWallet.storage, transaction: tx });
+    await sendTx.runFromMining();
+    await waitForTxReceived(hWallet, tx.hash, null);
+    expect(tx.hash).toBeDefined();
+  });
+
+  it('should be able to complete change', async () => {
+    const address = await hWallet.getAddressAtIndex(25);
+    const template = new TransactionTemplateBuilder()
+      .addSetVarAction({ name: 'addr', value: address })
+      .addSetVarAction({ name: 'token', value: tokenUid })
+      .addUtxoSelect({ fill: 100, token: '{token}', autoChange: false })
+      .addTokenOutput({ address: '{addr}', amount: 1, token: '{token}' })
+      .addDataOutput({ data: 'cafe', token: '{token}' })
+      .addChangeAction({})
+      .build();
+
+    const tx = await interpreter.build(template, DEBUG);
+    await transactionUtils.signTransaction(tx, hWallet.storage, DEFAULT_PIN_CODE);
+    tx.prepareToSend();
+    const sendTx = new SendTransaction({ storage: hWallet.storage, transaction: tx });
+    await sendTx.runFromMining();
+    await waitForTxReceived(hWallet, tx.hash, null);
+    expect(tx.hash).toBeDefined();
+  });
+});