starknet 3.12.1 → 3.13.0

package/__tests__/account.test.ts

@@ -1,49 +1,52 @@
 import { isBN } from 'bn.js';
 
 import typedDataExample from '../__mocks__/typedDataExample.json';
-import { Account, Contract, defaultProvider, ec, number, stark } from '../src';
+import { Account, Contract, Provider, ec, number, stark } from '../src';
 import { toBN } from '../src/utils/number';
-import { compiledArgentAccount, compiledErc20, compiledTestDapp } from './fixtures';
+import {
+  compiledErc20,
+  compiledOpenZeppelinAccount,
+  compiledTestDapp,
+  getTestAccount,
+  getTestProvider,
+} from './fixtures';
 
 describe('deploy and test Wallet', () => {
-  const privateKey = stark.randomAddress();
-
-  const starkKeyPair = ec.getKeyPair(privateKey);
-  const starkKeyPub = ec.getStarkKey(starkKeyPair);
-  let account: Account;
+  const account: Account = getTestAccount();
+  const provider = getTestProvider();
   let erc20: Contract;
   let erc20Address: string;
   let dapp: Contract;
 
   beforeAll(async () => {
-    const accountResponse = await defaultProvider.deployContract({
-      contract: compiledArgentAccount,
-      addressSalt: starkKeyPub,
-    });
-    const contract = new Contract(compiledArgentAccount.abi, accountResponse.address);
-    expect(accountResponse.code).toBe('TRANSACTION_RECEIVED');
-
-    const initializeResponse = await contract.initialize(starkKeyPub, '0');
-    expect(initializeResponse.code).toBe('TRANSACTION_RECEIVED');
-
-    account = new Account(defaultProvider, accountResponse.address, starkKeyPair);
+    expect(account).toBeInstanceOf(Account);
 
-    const erc20Response = await defaultProvider.deployContract({
+    const erc20Response = await provider.deployContract({
       contract: compiledErc20,
     });
     erc20Address = erc20Response.address;
     erc20 = new Contract(compiledErc20.abi, erc20Address);
     expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
 
-    const mintResponse = await erc20.mint(account.address, '1000');
+    await provider.waitForTransaction(erc20Response.transaction_hash);
+
+    const mintResponse = await account.execute({
+      contractAddress: erc20Address,
+      entrypoint: 'mint',
+      calldata: [account.address, '1000'],
+    });
+
     expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
 
-    const dappResponse = await defaultProvider.deployContract({
+    await provider.waitForTransaction(mintResponse.transaction_hash);
+
+    const dappResponse = await provider.deployContract({
       contract: compiledTestDapp,
     });
     dapp = new Contract(compiledTestDapp.abi, dappResponse.address);
     expect(dappResponse.code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(dappResponse.transaction_hash);
+
+    await provider.waitForTransaction(dappResponse.transaction_hash);
   });
 
   test('estimate fee', async () => {
@@ -56,20 +59,6 @@ describe('deploy and test Wallet', () => {
     expect(typeof unit).toBe('string');
   });
 
-  test('same wallet address', () => {
-    expect(account.address).toBe(account.address);
-  });
-
-  test('read nonce', async () => {
-    const { result } = await account.callContract({
-      contractAddress: account.address,
-      entrypoint: 'get_nonce',
-    });
-    const nonce = result[0];
-
-    expect(number.toBN(nonce).toString()).toStrictEqual(number.toBN(0).toString());
-  });
-
   test('read balance of wallet', async () => {
     const { res } = await erc20.balance_of(account.address);
 
@@ -77,18 +66,14 @@ describe('deploy and test Wallet', () => {
   });
 
   test('execute by wallet owner', async () => {
-    const { code, transaction_hash } = await account.execute(
-      {
-        contractAddress: erc20Address,
-        entrypoint: 'transfer',
-        calldata: [erc20.address, '10'],
-      },
-      undefined,
-      { maxFee: '0' }
-    );
+    const { code, transaction_hash } = await account.execute({
+      contractAddress: erc20Address,
+      entrypoint: 'transfer',
+      calldata: [erc20.address, '10'],
+    });
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash);
   });
 
   test('read balance of wallet after transfer', async () => {
@@ -110,33 +95,29 @@ describe('deploy and test Wallet', () => {
         calldata: [account.address, '10'],
       },
       undefined,
-      { nonce, maxFee: '0' }
+      { nonce }
     );
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash);
   });
 
   test('execute multiple transactions', async () => {
-    const { code, transaction_hash } = await account.execute(
-      [
-        {
-          contractAddress: dapp.address,
-          entrypoint: 'set_number',
-          calldata: ['47'],
-        },
-        {
-          contractAddress: dapp.address,
-          entrypoint: 'increase_number',
-          calldata: ['10'],
-        },
-      ],
-      undefined,
-      { maxFee: '0' }
-    );
+    const { code, transaction_hash } = await account.execute([
+      {
+        contractAddress: dapp.address,
+        entrypoint: 'set_number',
+        calldata: ['47'],
+      },
+      {
+        contractAddress: dapp.address,
+        entrypoint: 'increase_number',
+        calldata: ['10'],
+      },
+    ]);
 
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(transaction_hash);
+    await provider.waitForTransaction(transaction_hash);
 
     const response = await dapp.get_number(account.address);
     expect(toBN(response.number as string).toString()).toStrictEqual('57');
@@ -147,4 +128,60 @@ describe('deploy and test Wallet', () => {
 
     expect(await account.verifyMessage(typedDataExample, signature)).toBe(true);
   });
+
+  describe('new deployed account', () => {
+    let newAccount: Account;
+
+    beforeAll(async () => {
+      const starkKeyPair = ec.genKeyPair();
+      const starkKeyPub = ec.getStarkKey(starkKeyPair);
+
+      const accountResponse = await provider.deployContract({
+        contract: compiledOpenZeppelinAccount,
+        constructorCalldata: [starkKeyPub],
+      });
+
+      await provider.waitForTransaction(accountResponse.transaction_hash);
+
+      newAccount = new Account(provider, accountResponse.address, starkKeyPair);
+    });
+
+    test('read nonce', async () => {
+      const { result } = await account.callContract({
+        contractAddress: newAccount.address,
+        entrypoint: 'get_nonce',
+      });
+      const nonce = result[0];
+
+      expect(number.toBN(nonce).toString()).toStrictEqual(number.toBN(0).toString());
+    });
+  });
+
+  describe('Contract interaction with Account', () => {
+    const wallet = stark.randomAddress();
+
+    beforeAll(async () => {
+      const mintResponse = await account.execute({
+        contractAddress: erc20Address,
+        entrypoint: 'mint',
+        calldata: [wallet, '1000'],
+      });
+
+      expect(mintResponse.code).toBe('TRANSACTION_RECEIVED');
+
+      await provider.waitForTransaction(mintResponse.transaction_hash);
+    });
+
+    test('change from provider to account', async () => {
+      expect(erc20.providerOrAccount instanceof Provider);
+      erc20.connect(account);
+      expect(erc20.providerOrAccount instanceof Account);
+    });
+
+    test('estimate gas fee for `mint`', async () => {
+      const res = await erc20.estimateFee.mint(wallet, '10');
+      expect(res).toHaveProperty('amount');
+      expect(res).toHaveProperty('unit');
+    });
+  });
 });

package/__tests__/contract.test.ts

@@ -1,16 +1,19 @@
 import { isBN } from 'bn.js';
 
-import { Account, Contract, ContractFactory, Provider, defaultProvider, ec, stark } from '../src';
+import { Account, Contract, ContractFactory, Provider, stark } from '../src';
 import { getSelectorFromName } from '../src/utils/hash';
 import { BigNumberish, toBN } from '../src/utils/number';
 import { compileCalldata } from '../src/utils/stark';
 import {
-  compiledArgentAccount,
   compiledErc20,
   compiledMulticall,
   compiledTypeTransformation,
+  getTestAccount,
+  getTestProvider,
 } from './fixtures';
 
+const provider = getTestProvider();
+
 describe('class Contract {}', () => {
   const wallet = stark.randomAddress();
 
@@ -19,27 +22,27 @@ describe('class Contract {}', () => {
     let contract: Contract;
 
     beforeAll(async () => {
-      const { code, transaction_hash, address } = await defaultProvider.deployContract({
+      const { code, transaction_hash, address } = await provider.deployContract({
         contract: compiledErc20,
       });
-      erc20 = new Contract(compiledErc20.abi, address, defaultProvider);
+      erc20 = new Contract(compiledErc20.abi, address!, provider);
       expect(code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTransaction(transaction_hash);
+      await provider.waitForTransaction(transaction_hash);
       // Deploy Multicall
 
       const {
         code: m_code,
         transaction_hash: m_transaction_hash,
         address: multicallAddress,
-      } = await defaultProvider.deployContract({
+      } = await provider.deployContract({
         contract: compiledMulticall,
       });
 
-      contract = new Contract(compiledMulticall.abi, multicallAddress);
+      contract = new Contract(compiledMulticall.abi, multicallAddress!);
 
       expect(m_code).toBe('TRANSACTION_RECEIVED');
 
-      await defaultProvider.waitForTransaction(m_transaction_hash);
+      await provider.waitForTransaction(m_transaction_hash);
     });
 
     test('populate transaction for initial balance of that account', async () => {
@@ -61,20 +64,6 @@ describe('class Contract {}', () => {
       expect(res).toStrictEqual(result.res);
     });
 
-    test('add 10 test ERC20 to account', async () => {
-      const response = await erc20.mint(wallet, '10');
-      expect(response.code).toBe('TRANSACTION_RECEIVED');
-
-      await defaultProvider.waitForTransaction(response.transaction_hash);
-    });
-
-    test('read balance after mint of that account', async () => {
-      const result = await erc20.balance_of(wallet);
-      const [res] = result;
-      expect(res).toStrictEqual(toBN(10));
-      expect(res).toStrictEqual(result.res);
-    });
-
     test('read balance in a multicall', async () => {
       const args1 = { user: wallet };
       const args2 = {};
@@ -103,12 +92,12 @@ describe('class Contract {}', () => {
     let contract: Contract;
 
     beforeAll(async () => {
-      const { code, transaction_hash, address } = await defaultProvider.deployContract({
+      const { code, transaction_hash, address } = await provider.deployContract({
         contract: compiledTypeTransformation,
       });
-      contract = new Contract(compiledTypeTransformation.abi, address, defaultProvider);
+      contract = new Contract(compiledTypeTransformation.abi, address!, provider);
       expect(code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTransaction(transaction_hash);
+      await provider.waitForTransaction(transaction_hash);
     });
 
     describe('Request Type Transformation', () => {
@@ -208,39 +197,24 @@ describe('class Contract {}', () => {
   });
 
   describe('Contract interaction with Account', () => {
-    let account: Account;
+    const account = getTestAccount();
     let erc20: Contract;
     let erc20Address: string;
 
     beforeAll(async () => {
-      const starkKeyPair = ec.genKeyPair();
-      const starkKeyPub = ec.getStarkKey(starkKeyPair);
-      const { address } = await defaultProvider.deployContract({
-        contract: compiledArgentAccount,
-        addressSalt: starkKeyPub,
-      });
-      expect(address).toBeDefined();
-      account = new Account(defaultProvider, address, starkKeyPair);
-      const accountContract = new Contract(compiledArgentAccount.abi, address);
-      await accountContract.initialize(starkKeyPub, '0');
-
-      const erc20Response = await defaultProvider.deployContract({
+      const erc20Response = await provider.deployContract({
         contract: compiledErc20,
       });
-      erc20Address = erc20Response.address;
-      erc20 = new Contract(compiledErc20.abi, erc20Address, defaultProvider);
+      erc20Address = erc20Response.address!;
+      erc20 = new Contract(compiledErc20.abi, erc20Address, provider);
       expect(erc20Response.code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTransaction(erc20Response.transaction_hash);
-
-      const mintResponse = await erc20.mint(account.address, '1000');
-
-      await defaultProvider.waitForTransaction(mintResponse.transaction_hash);
+      await provider.waitForTransaction(erc20Response.transaction_hash);
     });
 
     test('read balance of wallet', async () => {
       const result = await erc20.balance_of(account.address);
       const [res] = result;
-      expect(res).toStrictEqual(toBN(1000));
+      expect(res).toStrictEqual(toBN(0));
       expect(res).toStrictEqual(result.res);
     });
 
@@ -255,34 +229,18 @@ describe('class Contract {}', () => {
       expect(res).toHaveProperty('amount');
       expect(res).toHaveProperty('unit');
     });
-
-    test('read balance of wallet', async () => {
-      const { res } = await erc20.balance_of(account.address);
-
-      expect(res).toStrictEqual(toBN(1000));
-    });
-
-    test('invoke contract by wallet owner', async () => {
-      const { transaction_hash, code } = await erc20.transfer(erc20Address, 10, {
-        maxFee: 0,
-      });
-      expect(code).toBe('TRANSACTION_RECEIVED');
-      await defaultProvider.waitForTransaction(transaction_hash);
-      const { res } = await erc20.balance_of(account.address);
-      expect(res).toStrictEqual(toBN(990));
-    });
   });
 });
 
 describe('class ContractFactory {}', () => {
   let erc20Address: string;
   beforeAll(async () => {
-    const { code, transaction_hash, address } = await defaultProvider.deployContract({
+    const { code, transaction_hash, address } = await provider.deployContract({
       contract: compiledErc20,
     });
     expect(code).toBe('TRANSACTION_RECEIVED');
-    await defaultProvider.waitForTransaction(transaction_hash);
-    erc20Address = address;
+    await provider.waitForTransaction(transaction_hash);
+    erc20Address = address!;
   });
   test('deployment of new contract', async () => {
     const factory = new ContractFactory(compiledErc20);

package/__tests__/fixtures.ts

@@ -1,13 +1,33 @@
 import fs from 'fs';
 
-import { json } from '../src';
+import { Account, defaultProvider, ec, json } from '../src';
 import { CompiledContract } from '../src/types';
 
 const readContract = (name: string): CompiledContract =>
   json.parse(fs.readFileSync(`./__mocks__/${name}.json`).toString('ascii'));
 
+export const compiledOpenZeppelinAccount = readContract('Account');
 export const compiledArgentAccount = readContract('ArgentAccount');
 export const compiledErc20 = readContract('ERC20');
 export const compiledTypeTransformation = readContract('contract');
 export const compiledMulticall = readContract('multicall');
 export const compiledTestDapp = readContract('TestDapp');
+
+const DEFAULT_TEST_ACCOUNT_ADDRESS =
+  '0x6c0a3ca4f79e978f3b7005898aaa49bef4a24aeaa5f10c6a97887516400197e';
+
+export const getTestAccount = () => {
+  const testAccountAddress = process.env.TEST_ACCOUNT_ADDRESS || DEFAULT_TEST_ACCOUNT_ADDRESS;
+  const testAccountPrivateKey = process.env.TEST_ACCOUNT_PRIVATE_KEY;
+
+  if (!testAccountPrivateKey) {
+    throw new Error('TEST_ACCOUNT_PRIVATE_KEY is not set');
+  }
+
+  return new Account(defaultProvider, testAccountAddress, ec.getKeyPair(testAccountPrivateKey));
+};
+
+export const getTestProvider = () => {
+  // Will support both local and remote providers in the future
+  return defaultProvider;
+};

package/__tests__/jest.setup.ts

@@ -1,9 +1,28 @@
-import axios from 'axios';
-import * as AxiosLogger from 'axios-logger';
+/* eslint-disable no-console */
+import { register } from 'fetch-intercept';
 
 jest.setTimeout(50 * 60 * 1000);
 
 if (process.env.DEBUG === 'true') {
-  axios.interceptors.request.use(AxiosLogger.requestLogger, AxiosLogger.errorLogger);
-  axios.interceptors.response.use(AxiosLogger.responseLogger, AxiosLogger.errorLogger);
+  register({
+    request(url, config) {
+      console.log('[fetch.request]', [url, config]);
+      return [url, config];
+    },
+
+    requestError(error) {
+      console.log('[fetch.requestError]', error);
+      return Promise.reject(error);
+    },
+
+    response(response) {
+      console.log('[fetch.response]', response);
+      return response;
+    },
+
+    responseError(error) {
+      console.log('[fetch.responseError]', error);
+      return Promise.reject(error);
+    },
+  });
 }

package/__tests__/provider.test.ts

@@ -1,4 +1,5 @@
 import { defaultProvider, stark } from '../src';
+import { toBN } from '../src/utils/number';
 import { compiledArgentAccount } from './fixtures';
 
 const { compileCalldata } = stark;
@@ -42,7 +43,7 @@ describe('defaultProvider', () => {
         )
       ).resolves.not.toThrow();
     });
-    test('getStorageAt()', () => {
+    test('getStorageAt() with "key" type of number', () => {
       return expect(
         defaultProvider.getStorageAt(
           '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
@@ -51,6 +52,24 @@ describe('defaultProvider', () => {
         )
       ).resolves.not.toThrow();
     });
+    test('getStorageAt() with "key" type of string', () => {
+      return expect(
+        defaultProvider.getStorageAt(
+          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
+          '0',
+          36663
+        )
+      ).resolves.not.toThrow();
+    });
+    test('getStorageAt() with "key" type of BN', () => {
+      return expect(
+        defaultProvider.getStorageAt(
+          '0x01d1f307c073bb786a66e6e042ec2a9bdc385a3373bb3738d95b966d5ce56166',
+          toBN('0x0'),
+          36663
+        )
+      ).resolves.not.toThrow();
+    });
     test('getStorageAt(blockHash=undefined, blockNumber=null)', () => {
       return expect(
         defaultProvider.getStorageAt(

package/account/index.js

@@ -4,12 +4,16 @@ var __createBinding =
   (Object.create
     ? function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;
-        Object.defineProperty(o, k2, {
-          enumerable: true,
-          get: function () {
-            return m[k];
-          },
-        });
+        var desc = Object.getOwnPropertyDescriptor(m, k);
+        if (!desc || ('get' in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+          desc = {
+            enumerable: true,
+            get: function () {
+              return m[k];
+            },
+          };
+        }
+        Object.defineProperty(o, k2, desc);
       }
     : function (o, m, k, k2) {
         if (k2 === undefined) k2 = k;

package/contract/default.js

@@ -287,10 +287,10 @@ var Contract = /** @class */ (function () {
    * @param providerOrAccount (optional) - Provider or Account to attach to
    */
   function Contract(abi, address, providerOrAccount) {
-    var _this = this;
     if (providerOrAccount === void 0) {
       providerOrAccount = provider_1.defaultProvider;
     }
+    var _this = this;
     this.address = address;
     this.providerOrAccount = providerOrAccount;
     this.abi = abi;
@@ -430,7 +430,7 @@ var Contract = /** @class */ (function () {
       });
     (0, minimalistic_assert_1.default)(
       invokeableFunctionNames.includes(method),
-      (type === 'INVOKE' ? 'invokeable' : 'viewable') + ' method not found in abi'
+      ''.concat(type === 'INVOKE' ? 'invokeable' : 'viewable', ' method not found in abi')
     );
     // ensure args match abi type
     var methodAbi = this.abi.find(function (abi) {
@@ -446,7 +446,7 @@ var Contract = /** @class */ (function () {
           typeof args[argPosition] === 'string' ||
             typeof args[argPosition] === 'number' ||
             args[argPosition] instanceof bn_js_1.default,
-          'arg ' + input.name + ' should be a felt (string, number, BigNumber)'
+          'arg '.concat(input.name, ' should be a felt (string, number, BigNumber)')
         );
         argPosition += 1;
       } else if (input.type in _this.structs && typeof args[argPosition] === 'object') {
@@ -454,36 +454,36 @@ var Contract = /** @class */ (function () {
           var structMembersLength = _this.calculateStructMembers(input.type);
           (0, minimalistic_assert_1.default)(
             args[argPosition].length === structMembersLength,
-            'arg should be of length ' + structMembersLength
+            'arg should be of length '.concat(structMembersLength)
           );
         } else {
           _this.structs[input.type].members.forEach(function (_a) {
             var name = _a.name;
             (0,
-            minimalistic_assert_1.default)(Object.keys(args[argPosition]).includes(name), 'arg should have a property ' + name);
+            minimalistic_assert_1.default)(Object.keys(args[argPosition]).includes(name), 'arg should have a property '.concat(name));
           });
         }
         argPosition += 1;
       } else {
         (0, minimalistic_assert_1.default)(
           Array.isArray(args[argPosition]),
-          'arg ' + input.name + ' should be an Array'
+          'arg '.concat(input.name, ' should be an Array')
         );
         if (input.type === 'felt*') {
           args[argPosition].forEach(function (felt) {
             (0,
-            minimalistic_assert_1.default)(typeof felt === 'string' || typeof felt === 'number' || felt instanceof bn_js_1.default, 'arg ' + input.name + ' should be an array of string, number or BigNumber');
+            minimalistic_assert_1.default)(typeof felt === 'string' || typeof felt === 'number' || felt instanceof bn_js_1.default, 'arg '.concat(input.name, ' should be an array of string, number or BigNumber'));
           });
           argPosition += 1;
         } else if (/\(felt/.test(input.type)) {
           var tupleLength = input.type.split(',').length;
           (0, minimalistic_assert_1.default)(
             args[argPosition].length === tupleLength,
-            'arg ' + input.name + ' should have ' + tupleLength + ' elements in tuple'
+            'arg '.concat(input.name, ' should have ').concat(tupleLength, ' elements in tuple')
           );
           args[argPosition].forEach(function (felt) {
             (0,
-            minimalistic_assert_1.default)(typeof felt === 'string' || typeof felt === 'number' || felt instanceof bn_js_1.default, 'arg ' + input.name + ' should be an array of string, number or BigNumber');
+            minimalistic_assert_1.default)(typeof felt === 'string' || typeof felt === 'number' || felt instanceof bn_js_1.default, 'arg '.concat(input.name, ' should be an array of string, number or BigNumber'));
           });
           argPosition += 1;
         } else {
@@ -495,12 +495,12 @@ var Contract = /** @class */ (function () {
                 var structMembersLength = _this.calculateStructMembers(arrayType_1);
                 (0, minimalistic_assert_1.default)(
                   struct.length === structMembersLength,
-                  'arg should be of length ' + structMembersLength
+                  'arg should be of length '.concat(structMembersLength)
                 );
               } else {
                 (0, minimalistic_assert_1.default)(
                   Object.keys(struct).includes(name),
-                  'arg ' + input.name + ' should be an array of ' + arrayType_1
+                  'arg '.concat(input.name, ' should be an array of ').concat(arrayType_1)
                 );
               }
             });
@@ -616,7 +616,7 @@ var Contract = /** @class */ (function () {
             return acc;
           }, parsedCalldata);
         }
-        throw Error('Expected ' + name + ' to be array');
+        throw Error('Expected '.concat(name, ' to be array'));
       case type in this.structs:
         return this.parseCalldataValue(value, type);
       case /\(felt/.test(type):
@@ -625,7 +625,7 @@ var Contract = /** @class */ (function () {
             return (0, number_1.toFelt)(el);
           });
         }
-        throw Error('Expected ' + name + ' to be array');
+        throw Error('Expected '.concat(name, ' to be array'));
       default:
         return (0, number_1.toFelt)(value);
     }
@@ -673,8 +673,8 @@ var Contract = /** @class */ (function () {
           return acc;
         }, []);
       case /\*/.test(type):
-        if (parsedResult && parsedResult[name + '_len']) {
-          var arrLen = parsedResult[name + '_len'];
+        if (parsedResult && parsedResult[''.concat(name, '_len')]) {
+          var arrLen = parsedResult[''.concat(name, '_len')];
           while (parsedDataArr.length < arrLen) {
             parsedDataArr.push(
               this.parseResponseStruct(responseIterator, output.type.replace('*', ''))
@@ -703,8 +703,8 @@ var Contract = /** @class */ (function () {
     var responseIterator = response.flat()[Symbol.iterator]();
     var resultObject = outputs.flat().reduce(function (acc, output) {
       acc[output.name] = _this.parseResponseField(responseIterator, output, acc);
-      if (acc[output.name] && acc[output.name + '_len']) {
-        delete acc[output.name + '_len'];
+      if (acc[output.name] && acc[''.concat(output.name, '_len')]) {
+        delete acc[''.concat(output.name, '_len')];
       }
       return acc;
     }, {});
@@ -742,10 +742,9 @@ var Contract = /** @class */ (function () {
     }, 0);
     if (args.length !== inputsLength) {
       throw Error(
-        'Invalid number of arguments, expected ' +
-          inputsLength +
-          ' arguments, but got ' +
-          args.length
+        'Invalid number of arguments, expected '
+          .concat(inputsLength, ' arguments, but got ')
+          .concat(args.length)
       );
     }
     // compile calldata