feat: add check for sender account balance

package.json

@@ -77,6 +77,7 @@
         "typescript-transform-paths": "^3.4.7"
     },
     "dependencies": {
+        "bignumber.js": "^9.1.2",
         "bn.js": "^5.2.1",
         "chalk": "^4.1.2",
         "commander": "^12.0.0",

src/action.test.ts

@@ -13,14 +13,14 @@ import { localnet } from '@app/configs';
 import { ExitCodeEnum } from '@app/enums';
 
 // helpers
-import convertNearToYoctoNear from '@test/utils/convertNearToYoctoNear';
 import createTestAccount from '@test/utils/createTestAccount';
 import deployToken from '@test/utils/deployToken';
 
 // types
 import type { IActionResponse, IActionOptions, TNetworkIDs } from '@app/types';
 
 // utils
+import convertNEARToYoctoNEAR from '@app/utils/convertNEARToYoctoNEAR';
 import createLogger from '@app/utils/createLogger';
 import createNearConnection from '@app/utils/createNearConnection';
 
@@ -61,7 +61,7 @@ describe('when running the cli action', () => {
     // create the token account
     tokenAccount = await createTestAccount({
       creatorAccount,
-      initialBalanceInAtomicUnits: convertNearToYoctoNear(new BN('10')),
+      initialBalanceInAtomicUnits: new BN(convertNEARToYoctoNEAR('10')),
       newAccountID: tokenAccountID,
       newAccountPublicKey: tokenPublicKey,
       nearConnection,
@@ -168,6 +168,18 @@ describe('when running the cli action', () => {
     expect(response.exitCode).toBe(ExitCodeEnum.FileReadError);
   });
 
+  it('should fail if there is not enough funds in the account', async () => {
+    // arrange
+    // act
+    const response: IActionResponse = await action({
+      ...defaultOptions,
+      accountId: account1AccountID,
+    });
+
+    // assert
+    expect(response.exitCode).toBe(ExitCodeEnum.InsufficientFundsError);
+  });
+
   it('should record failed transfers', async () => {
     // arrange
     // act

src/action.ts

@@ -1,13 +1,20 @@
 import BN from 'bn.js';
 import { Account, Contract, Near } from 'near-api-js';
-import { PublicKey } from 'near-api-js/lib/utils';
+import type { AccountBalance } from 'near-api-js/lib/account';
+import type { PublicKey } from 'near-api-js/lib/utils';
 import { existsSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { extname } from 'node:path';
 
 // configs
 import { localnet, mainnet, testnet } from '@app/configs';
 
+// constants
+import {
+  GAS_FEE_IN_ATOMIC_UNITS,
+  STORAGE_FEE_IN_ATOMIC_UNITS,
+} from '@app/constants';
+
 // enums
 import { ExitCodeEnum } from '@app/enums';
 
@@ -22,6 +29,7 @@ import type {
 
 // utils
 import accountAccessKey from '@app/utils/accountAccessKey';
+import convertYoctoNEARToNEAR from '@app/utils/convertYoctoNEARToNEAR';
 import createNearConnection from '@app/utils/createNearConnection';
 import transferToAccount from '@app/utils/transferToAccount';
 import validateAccountID from '@app/utils/validateAccountID';
@@ -38,12 +46,14 @@ export default async function action({
 }: IActionOptions): Promise<IActionResponse> {
   const completedTransfers: Record<string, string> = {};
   const failedTransfers: Record<string, string> = {};
+  let accountBalance: AccountBalance;
   let configuration: IConfiguration;
   let contract: ITokenContract;
   let nearConnection: Near;
   let signer: Account;
   let signerAccessKey: IAccessKeyResponse;
   let signerPublicKey: PublicKey | null;
+  let totalFeesInAtomicUnits: BN;
   let transactionID: string | null;
   let transfers: Record<string, string>;
 
@@ -148,6 +158,24 @@ export default async function action({
     };
   }
 
+  accountBalance = await signer.getAccountBalance();
+  totalFeesInAtomicUnits = new BN(GAS_FEE_IN_ATOMIC_UNITS)
+    .add(new BN(STORAGE_FEE_IN_ATOMIC_UNITS))
+    .mul(new BN(Object.entries(transfers).length));
+
+  // if the signer does not have funds tio cover the fees, error
+  if (totalFeesInAtomicUnits.gt(new BN(accountBalance.available))) {
+    logger.error(
+      `there are insufficient funds in account "${signer.accountId}" to cover the fees, you need at least "${convertYoctoNEARToNEAR(totalFeesInAtomicUnits.toString())}", you have "${convertYoctoNEARToNEAR(accountBalance.available)}" available`
+    );
+
+    return {
+      completedTransfers,
+      exitCode: ExitCodeEnum.InsufficientFundsError,
+      failedTransfers,
+    };
+  }
+
   logger.info(
     `starting transfers for ${Object.entries(transfers).length} accounts`
   );

src/constants/Fees.ts

@@ -1,2 +1,2 @@
 export const GAS_FEE_IN_ATOMIC_UNITS = '30000000000000';
-export const STORAGE_FEE_IN_STANDARD_UNITS = '0.00125';
+export const STORAGE_FEE_IN_ATOMIC_UNITS = '1250000000000000000000';

src/enums/ExitCodeEnum.ts

@@ -7,6 +7,7 @@ enum ExitCodeEnum {
   DirectoryWriteError,
   FileReadError,
   FileWriteError,
+  InsufficientFundsError,
 }
 
 export default ExitCodeEnum;

src/utils/convertNEARToYoctoNEAR/convertNEARToYoctoNEAR.test.ts

@@ -0,0 +1,33 @@
+// utils
+import convertNEARToYoctoNEAR from './convertNEARToYoctoNEAR';
+
+interface ITestParams {
+  expected: string;
+  standardUnit: string;
+}
+
+describe('convertNEARToYoctoNEAR()', () => {
+  it.each([
+    {
+      standardUnit: '0.00000000000001',
+      expected: '10000000000',
+    },
+    {
+      standardUnit: '1.000000000000001',
+      expected: '1000000000000001000000000',
+    },
+    {
+      standardUnit: '3.2',
+      expected: '3200000000000000000000000',
+    },
+    {
+      standardUnit: '3.200000000000000001',
+      expected: '3200000000000000001000000',
+    },
+  ])(
+    `should convert the near unit of "$standardUnit" to yoctonear unit of "$expected"`,
+    ({ expected, standardUnit }: ITestParams) => {
+      expect(convertNEARToYoctoNEAR(standardUnit)).toBe(expected);
+    }
+  );
+});

src/utils/convertNEARToYoctoNEAR/convertNEARToYoctoNEAR.ts

@@ -0,0 +1,17 @@
+import BigNumber from 'bignumber.js';
+import { utils } from 'near-api-js';
+
+/**
+ * Convenience function that converts a NEAR amount (standard unit) to the yoctoNEAR amount (atomic unit).
+ * @param {string} standardAmount - the NEAR amount to convert.
+ * @returns {string} the yoctoNEAR amount.
+ */
+export default function convertNEARToYoctoNEAR(standardAmount: string): string {
+  BigNumber.config({
+    ROUNDING_MODE: 0,
+  });
+
+  return new BigNumber(standardAmount)
+    .multipliedBy(new BigNumber('10').pow(utils.format.NEAR_NOMINATION_EXP))
+    .toFixed();
+}

src/utils/convertNEARToYoctoNEAR/index.ts

@@ -0,0 +1 @@
+export { default } from './convertNEARToYoctoNEAR';

src/utils/convertYoctoNEARToNEAR/convertYoctoNEARToNEAR.test.ts

@@ -0,0 +1,33 @@
+// utils
+import convertYoctoNEARToNEAR from './convertYoctoNEARToNEAR';
+
+interface ITestParams {
+  atomicUnit: string;
+  expected: string;
+}
+
+describe('convertYoctoNEARToNEARtest()', () => {
+  it.each([
+    {
+      atomicUnit: '10000',
+      expected: '0.00000000000000000001',
+    },
+    {
+      atomicUnit: '1000000000000000000001000',
+      expected: '1.00000000000000000001',
+    },
+    {
+      atomicUnit: '3200000000000000000000000',
+      expected: '3.2',
+    },
+    {
+      atomicUnit: '3200000000000000000000001',
+      expected: '3.20000000000000000001',
+    },
+  ])(
+    `should convert the yoctonear unit of "$atomicUnit" to near unit of "$expected"`,
+    ({ atomicUnit, expected }: ITestParams) => {
+      expect(convertYoctoNEARToNEAR(atomicUnit)).toBe(expected);
+    }
+  );
+});

src/utils/convertYoctoNEARToNEAR/convertYoctoNEARToNEAR.ts

@@ -0,0 +1,17 @@
+import BigNumber from 'bignumber.js';
+import { utils } from 'near-api-js';
+
+/**
+ * Convenience function that converts a yoctoNEAR amount (atomic unit) to the NEAR amount (standard unit).
+ * @param {BigNumber} atomicAmount - the yoctoNEAR amount to convert.
+ * @returns {BigNumber} the NEAR amount.
+ */
+export default function convertYoctoNEARToNEAR(atomicAmount: string): string {
+  BigNumber.config({
+    ROUNDING_MODE: 0,
+  });
+
+  return new BigNumber(atomicAmount)
+    .dividedBy(new BigNumber(10).pow(utils.format.NEAR_NOMINATION_EXP))
+    .toFixed();
+}

src/utils/convertYoctoNEARToNEAR/index.ts

@@ -0,0 +1 @@
+export { default } from './convertYoctoNEARToNEAR';

src/utils/transferToAccount/transferToAccount.ts

@@ -8,7 +8,7 @@ import {
   GAS_FEE_IN_ATOMIC_UNITS,
   MAX_RETRIES,
   RETRY_DELAY_IN_MILLISECONDS,
-  STORAGE_FEE_IN_STANDARD_UNITS,
+  STORAGE_FEE_IN_ATOMIC_UNITS,
 } from '@app/constants';
 
 // types
@@ -54,9 +54,7 @@ export default async function transferToAccount({
                 registration_only: true,
               },
               gasFee,
-              new BN(
-                utils.format.parseNearAmount(STORAGE_FEE_IN_STANDARD_UNITS)!
-              )
+              new BN(STORAGE_FEE_IN_ATOMIC_UNITS!)
             )
           );
         }

yarn.lock

@@ -3953,6 +3953,11 @@ big.js@^5.2.2:
   resolved "https://registry.yarnpkg.com/big.js/-/big.js-5.2.2.tgz#65f0af382f578bcdc742bd9c281e9cb2d7768328"
   integrity sha512-vyL2OymJxmarO8gxMr0mhChsO9QGwhynfuu4+MHTAW6czfq9humCB7rKpUjDd9YUiDPU4mzpyupFSvOClAwbmQ==
 
+bignumber.js@^9.1.2:
+  version "9.1.2"
+  resolved "https://registry.yarnpkg.com/bignumber.js/-/bignumber.js-9.1.2.tgz#b7c4242259c008903b13707983b5f4bbd31eda0c"
+  integrity sha512-2/mKyZH9K85bzOEfhXDBFZTGd1CTs+5IHpeFQo9luiBG7hghdC851Pj2WAhb6E3R6b9tZj/XKhbg4fum+Kepug==
+
 bin-links@^4.0.1:
   version "4.0.4"
   resolved "https://registry.yarnpkg.com/bin-links/-/bin-links-4.0.4.tgz#c3565832b8e287c85f109a02a17027d152a58a63"