fix: correctly set action amount for authority actions

Author: pedroferreira1

src/nano_contracts/builder.ts

@@ -16,13 +16,12 @@ import {
   NATIVE_TOKEN_UID,
   NANO_CONTRACTS_INITIALIZE_METHOD,
   TOKEN_MINT_MASK,
-  TOKEN_MELT_MASK
+  TOKEN_MELT_MASK,
 } from '../constants';
 import Serializer from './serializer';
 import HathorWallet from '../new/wallet';
 import { NanoContractTransactionError, UtxoError } from '../errors';
 import {
-  ActionTypeToActionHeaderType,
   NanoContractActionHeader,
   NanoContractActionType,
   NanoContractAction,
@@ -32,9 +31,9 @@ import {
   NanoContractBuilderCreateTokenOptions,
   NanoContractVertexType,
 } from './types';
-import { IDataInput, IDataOutput, ITokenData } from '../types';
+import { IDataInput, IDataOutput } from '../types';
 import ncApi from '../api/nano';
-import { validateAndUpdateBlueprintMethodArgs } from './utils';
+import { mapActionToActionHeader, validateAndUpdateBlueprintMethodArgs } from './utils';
 import NanoContractHeader from './header';
 
 class NanoContractTransactionBuilder {
@@ -350,7 +349,9 @@ class NanoContractTransactionBuilder {
     }
 
     if (!action.authority || !action.token) {
-      throw new NanoContractTransactionError('Authority and token are required for grant authority action.');
+      throw new NanoContractTransactionError(
+        'Authority and token are required for grant authority action.'
+      );
     }
 
     const authorityAddressParam = action.authorityAddress;
@@ -359,10 +360,16 @@ class NanoContractTransactionBuilder {
     }
 
     // Get the utxos with the authority of the action and create the input
-    const utxos = await this.wallet.getAuthorityUtxo(action.token, action.authority, { many: false, only_available_utxos: true, filter_address: action.address });
+    const utxos = await this.wallet.getAuthorityUtxo(action.token, action.authority, {
+      many: false,
+      only_available_utxos: true,
+      filter_address: action.address,
+    });
 
     if (!utxos || utxos.length === 0) {
-      throw new NanoContractTransactionError('Not enough authority utxos to execute the grant authority.');
+      throw new NanoContractTransactionError(
+        'Not enough authority utxos to execute the grant authority.'
+      );
     }
 
     const inputs: IDataInput[] = [];
@@ -533,17 +540,35 @@ class NanoContractTransactionBuilder {
       tokens = Array.from(tokenSet);
       for (const action of this.actions) {
         // Call action
-        if (action.type === NanoContractActionType.DEPOSIT) {
-          const ret = await this.executeDeposit(action, tokens);
-          inputs = concat(inputs, ret[0]);
-          outputs = concat(outputs, ret[1]);
-        } else if (action.type === NanoContractActionType.WITHDRAWAL) {
-          const output = this.executeWithdrawal(action, tokens);
-          if (output) {
-            outputs = concat(outputs, output);
+        switch (action.type) {
+          case NanoContractActionType.DEPOSIT: {
+            const retDeposit = await this.executeDeposit(action);
+            inputs = concat(inputs, retDeposit[0]);
+            outputs = concat(outputs, retDeposit[1]);
+            break;
+          }
+          case NanoContractActionType.WITHDRAWAL: {
+            const outputWithdrawal = this.executeWithdrawal(action);
+            if (outputWithdrawal) {
+              outputs = concat(outputs, outputWithdrawal);
+            }
+            break;
+          }
+          case NanoContractActionType.GRANT_AUTHORITY: {
+            const retGrant = await this.executeGrantAuthority(action);
+            inputs = concat(inputs, retGrant[0]);
+            outputs = concat(outputs, retGrant[1]);
+            break;
+          }
+          case NanoContractActionType.INVOKE_AUTHORITY: {
+            const outputInvoke = this.executeInvokeAuthority(action);
+            if (outputInvoke) {
+              outputs = concat(outputs, outputInvoke);
+            }
+            break;
           }
-        } else {
-          throw new Error('Invalid type for nano contract action.');
+          default:
+            throw new Error('Invalid type for nano contract action.');
         }
       }
     }
@@ -646,21 +671,7 @@ class NanoContractTransactionBuilder {
 
     if (this.actions) {
       nanoHeaderActions = this.actions.map(action => {
-        const headerActionType = ActionTypeToActionHeaderType[action.type];
-
-        const mappedTokens: ITokenData[] = tokens.map(token => {
-          return {
-            uid: token,
-            name: '',
-            symbol: '',
-          };
-        });
-
-        return {
-          type: headerActionType,
-          amount: action.amount,
-          tokenIndex: tokensUtils.getTokenIndex(mappedTokens, action.token),
-        };
+        return mapActionToActionHeader(action, tokens);
       });
     }
 

src/nano_contracts/types.ts

@@ -24,7 +24,7 @@ export enum NanoContractActionType {
   DEPOSIT = 'deposit',
   WITHDRAWAL = 'withdrawal',
   GRANT_AUTHORITY = 'grant_authority',
-  INVOKE_AUTHORITY = 'invoke_authority'
+  INVOKE_AUTHORITY = 'invoke_authority',
 }
 
 export enum NanoContractHeaderActionType {

src/nano_contracts/utils.ts

@@ -8,6 +8,7 @@
 import { get } from 'lodash';
 import { crypto } from 'bitcore-lib';
 import transactionUtils from '../utils/transaction';
+import tokensUtils from '../utils/tokens';
 import SendTransaction from '../new/sendTransaction';
 import HathorWallet from '../new/wallet';
 import Network from '../models/network';
@@ -20,10 +21,17 @@ import Address from '../models/address';
 import Transaction from '../models/transaction';
 import { NanoContractTransactionError, OracleParseError, WalletFromXPubGuard } from '../errors';
 import { OutputType } from '../wallet/types';
-import { IHistoryTx, IStorage } from '../types';
+import { IHistoryTx, IStorage, ITokenData } from '../types';
 import { parseScript } from '../utils/scripts';
-import { MethodArgInfo, NanoContractArgumentType } from './types';
-import { NANO_CONTRACTS_INITIALIZE_METHOD } from '../constants';
+import {
+  ActionTypeToActionHeaderType,
+  MethodArgInfo,
+  NanoContractArgumentType,
+  NanoContractAction,
+  NanoContractActionHeader,
+  NanoContractActionType,
+} from './types';
+import { NANO_CONTRACTS_INITIALIZE_METHOD, TOKEN_MELT_MASK, TOKEN_MINT_MASK } from '../constants';
 
 /**
  * Sign a transaction and create a send transaction object
@@ -258,3 +266,47 @@ export const validateAndUpdateBlueprintMethodArgs = async (
 export const isNanoContractCreateTx = (tx: IHistoryTx): boolean => {
   return tx.nc_method === NANO_CONTRACTS_INITIALIZE_METHOD;
 };
+
+/**
+ * Map a NanoContractAction object to NanoContractActionHeader
+ *
+ * @param action The action object to be mapped
+ * @param tokens The tokens array to be used in the mapping
+ *
+ * @return The mapped action header object
+ */
+export const mapActionToActionHeader = (
+  action: NanoContractAction,
+  tokens: string[]
+): NanoContractActionHeader => {
+  const headerActionType = ActionTypeToActionHeaderType[action.type];
+
+  const mappedTokens: ITokenData[] = tokens.map(token => {
+    return {
+      uid: token,
+      name: '',
+      symbol: '',
+    };
+  });
+
+  let amount;
+  if (
+    action.type === NanoContractActionType.GRANT_AUTHORITY ||
+    action.type === NanoContractActionType.INVOKE_AUTHORITY
+  ) {
+    amount = action.authority === 'mint' ? TOKEN_MINT_MASK : TOKEN_MELT_MASK;
+  } else if (
+    action.type === NanoContractActionType.DEPOSIT ||
+    action.type === NanoContractActionType.WITHDRAWAL
+  ) {
+    amount = action.amount;
+  } else {
+    throw new Error('Invalid nano contract action type');
+  }
+
+  return {
+    type: headerActionType,
+    amount,
+    tokenIndex: tokensUtils.getTokenIndex(mappedTokens, action.token),
+  };
+};