tests(integration): add change and complete tests

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

@@ -190,4 +190,48 @@ describe('Template execution', () => {
     expect(tx.outputs[1].tokenData).toBe(129);
     expect(tx.outputs[1].value).toBe(2n);
   });
+
+  /* eslint-disable jest/expect-expect */
+  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',
+        action: 'get_wallet_balance',
+        options: { token: '{token}' },
+      })
+      .addTokenOutput({ address: '{addr}', amount: '{tk_balance}', 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);
+  });
+
+  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}' })
+      .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);
+  });
+  /* eslint-enable jest/expect-expect */
 });

src/template/transaction/interpreter.ts

@@ -41,15 +41,18 @@
     this.txCache = {};
   }
 
-  async build(instructions: z.infer<typeof TransactionTemplate>, debug: boolean = false): Promise<Transaction> {
+  async build(
+    instructions: z.infer<typeof TransactionTemplate>,
+    debug: boolean = false
+  ): Promise<Transaction> {
     const context = new TxTemplateContext(this.wallet.logger, debug);
 
     for (const ins of TransactionTemplate.parse(instructions)) {
       await runInstruction(this, context, ins);
     }
 
     if (context.version === DEFAULT_TX_VERSION) {
       return new Transaction(context.inputs, context.outputs, {
         signalBits: context.signalBits,
         version: context.version,
         tokens: context.tokens,
@@ -57,9 +60,9 @@
     }
     if (context.version === CREATE_TOKEN_TX_VERSION) {
       if (!context.tokenName || !context.tokenSymbol) {
         throw new Error('Cannot create a token without a name or symbol');
       }
       return new CreateTokenTransaction(
         context.tokenName,
         context.tokenSymbol,
         context.inputs,
@@ -67,7 +70,7 @@
         { signalBits: context.signalBits }
       );
     }
     throw new Error('Unsupported Version byte provided');
   }
 
   async getAddress(markAsUsed: boolean = false): Promise<string> {
@@ -94,65 +97,65 @@
 
   async getUtxos(amount: OutputValueType, options: IGetUtxosOptions): Promise<IGetUtxoResponse> {
     // XXX: This may throw, but maybe we should let it.
     return this.wallet.getUtxosForAmount(amount, options);
   }
 
   async getAuthorities(count: number, options: IGetUtxosOptions): Promise<Utxo[]> {
     const newOptions = {
       ...options,
       max_utxos: count,
     };
     const utxos: Utxo[] = [];
     // XXX: This may throw, but maybe we should let it.
     for await (const utxo of this.wallet.storage.selectUtxos(newOptions)) {
       utxos.push(utxo);
     }
     return utxos;
   }
 
   async getTx(txId: string): Promise<IHistoryTx> {
     if (this.txCache[txId]) {
       return this.txCache[txId];
     }
 
     const histtx = await this.wallet.getTx(txId);
     if (histtx) {
       this.txCache[txId] = histtx as IHistoryTx;
       return this.txCache[txId];
     }
 
     function hidrateIOWithToken<T extends FullNodeInput | FullNodeOutput>(
       io: T,
       tokens: FullNodeToken[]
     ) {
       const { token_data } = io;
       if (token_data === 0) {
         return {
           ...io,
           token: NATIVE_TOKEN_UID,
         };
       }
 
       const tokenIdx = tokenUtils.getTokenIndexFromData(token_data);
       const tokenUid = tokens[tokenIdx - 1]?.uid;
       if (!tokenUid) {
         throw new Error(`Invalid token_data ${token_data}, token not found in tokens list`);
       }
 
       return { ...io, token: tokenUid } as T;
     }
 
     const resp = (await this.wallet.getFullTxById(txId)) as FullNodeTxResponse;
     // We can assume the wallet handles any network errors
     const { tx } = resp;
     tx.inputs = tx.inputs.map(i => hidrateIOWithToken<FullNodeInput>(i, tx.tokens));
     tx.outputs = tx.outputs.map(o => hidrateIOWithToken<FullNodeOutput>(o, tx.tokens));
     const normalizedTx = transactionUtils.convertFullNodeTxToHistoryTx(tx);
     this.txCache[txId] = normalizedTx;
     return this.txCache[txId];
   }
 
   getNetwork(): Network {
     return this.wallet.getNetworkObject();
   }
 }

src/template/transaction/types.ts

@@ -5,13 +5,13 @@
  * LICENSE file in the root directory of this source tree.
  */
 
+import { z } from 'zod';
 import { TransactionTemplate } from './instructions';
 import { TxTemplateContext } from './context';
 import { IHistoryTx, ITokenBalance, ITokenData, OutputValueType } from '../../types';
 import Transaction from '../../models/transaction';
 import Network from '../../models/network';
 import { Utxo } from '../../wallet/types';
-import { z } from 'zod';
 
 export interface IGetUtxosOptions {
   token?: string;