feat: introduce contract class

to help with contract calls, especially invoking functions

.eslintrc

@@ -5,7 +5,7 @@
     "node": true,
     "jest": true
   },
-  "extends": ["airbnb-base", "airbnb-typescript/base", "prettier", "plugin:prettier/recommended", ],
+  "extends": ["airbnb-base", "airbnb-typescript/base", "prettier", "plugin:prettier/recommended"],
   "globals": {
     "Atomics": "readonly",
     "SharedArrayBuffer": "readonly"
@@ -16,5 +16,9 @@
     "sourceType": "module",
     "project": "./tsconfig.eslint.json"
   },
-  "plugins": ["@typescript-eslint"]
+  "plugins": ["@typescript-eslint"],
+  "rules": {
+    "import/prefer-default-export": 0,
+    "@typescript-eslint/naming-convention": 0
+  }
 }

__tests__/contracts.test.ts

@@ -0,0 +1,31 @@
+import fs from 'fs';
+import { CompiledContract, Contract, deployContract, JsonParser, randomAddress } from '../src';
+
+const compiledERC20: CompiledContract = JsonParser.parse(
+  fs.readFileSync('./__mocks__/ERC20.json').toString('ascii')
+);
+
+describe('new Contract()', () => {
+  const address = randomAddress();
+  //   const address = "";
+  const wallet = randomAddress();
+  const contract = new Contract(compiledERC20.abi, address);
+  beforeAll(async () => {
+    const { code, tx_id } = await deployContract(compiledERC20, address);
+    // I want to show the tx number to the tester, so he/she can trace the transaction in the explorer.
+    // eslint-disable-next-line no-console
+    console.log('deployed erc20 contract', tx_id);
+    expect(code).toBe('TRANSACTION_RECEIVED');
+  });
+  test('initialize ERC20 mock contract', async () => {
+    const response = await contract.invoke('mint', {
+      recipient: wallet,
+      amount: '10',
+    });
+    expect(response.code).toBe('TRANSACTION_RECEIVED');
+
+    // I want to show the tx number to the tester, so he/she can trace the transaction in the explorer.
+    // eslint-disable-next-line no-console
+    console.log('txId:', response.tx_id, ', funded wallet:', wallet);
+  });
+});

__tests__/index.test.ts

@@ -1,11 +1,18 @@
 import fs from 'fs';
-import starknet, {
+import {
   CompiledContract,
   compressProgram,
   randomAddress,
-  makeAddress,
   JsonParser,
-} from '..';
+  getContractAddresses,
+  getBlock,
+  getCode,
+  getStorageAt,
+  getTransactionStatus,
+  getTransaction,
+  addTransaction,
+  deployContract,
+} from '../src';
 
 const compiledArgentAccount = JsonParser.parse(
   fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')
@@ -14,31 +21,27 @@ const compiledArgentAccount = JsonParser.parse(
 describe('starknet endpoints', () => {
   describe('feeder gateway endpoints', () => {
     test('getContractAddresses()', () => {
-      return expect(starknet.getContractAddresses()).resolves.not.toThrow();
+      return expect(getContractAddresses()).resolves.not.toThrow();
     });
     xtest('callContract()', () => {});
     test('getBlock()', () => {
-      return expect(starknet.getBlock(46500)).resolves.not.toThrow();
+      return expect(getBlock(46500)).resolves.not.toThrow();
     });
     test('getCode()', () => {
       return expect(
-        starknet.getCode('0x5f778a983bf8760ad37868f4c869d70247c5546044a7f0386df96d8043d4e9d', 46500)
+        getCode('0x5f778a983bf8760ad37868f4c869d70247c5546044a7f0386df96d8043d4e9d', 46500)
       ).resolves.not.toThrow();
     });
     test('getStorageAt()', () => {
       return expect(
-        starknet.getStorageAt(
-          '0x5f778a983bf8760ad37868f4c869d70247c5546044a7f0386df96d8043d4e9d',
-          0,
-          46500
-        )
+        getStorageAt('0x5f778a983bf8760ad37868f4c869d70247c5546044a7f0386df96d8043d4e9d', 0, 46500)
       ).resolves.not.toThrow();
     });
     test('getTransactionStatus()', () => {
-      return expect(starknet.getTransactionStatus(286136)).resolves.not.toThrow();
+      return expect(getTransactionStatus(286136)).resolves.not.toThrow();
     });
     test('getTransaction()', () => {
-      return expect(starknet.getTransaction(286136)).resolves.not.toThrow();
+      return expect(getTransaction(286136)).resolves.not.toThrow();
     });
   });
 
@@ -51,7 +54,7 @@ describe('starknet endpoints', () => {
         program: compressProgram(inputContract.program),
       };
 
-      const response = await starknet.addTransaction({
+      const response = await addTransaction({
         type: 'DEPLOY',
         contract_address: randomAddress(),
         contract_definition: contractDefinition,
@@ -63,15 +66,11 @@ describe('starknet endpoints', () => {
       // eslint-disable-next-line no-console
       console.log('txId:', response.tx_id);
     });
-    xtest('type: "INVOKE_FUNCTION"', () => {});
 
     test('deployContract()', async () => {
       const inputContract = compiledArgentAccount as unknown as CompiledContract;
 
-      const response = await starknet.deployContract(
-        inputContract,
-        makeAddress('0x20b5B1b8aFd65F1FCB755a449000cFC4aBCA0D40')
-      );
+      const response = await deployContract(inputContract);
       expect(response.code).toBe('TRANSACTION_RECEIVED');
       expect(response.tx_id).toBeGreaterThan(0);
 

__tests__/utils.browser.test.ts

@@ -3,7 +3,7 @@
  */
 
 import fs from 'fs';
-import { compressProgram, isBrowser, JsonParser } from '..';
+import { compressProgram, isBrowser, JsonParser } from '../src';
 
 const compiledArgentAccount = JsonParser.parse(
   fs.readFileSync('./__mocks__/ArgentAccount.json').toString('ascii')

__tests__/utils.test.ts

@@ -44,4 +44,9 @@ describe('starknetKeccak()', () => {
       '0x79dc0da7c54b95f10aa182ad0a46400db63156920adb65eca2654c0945a463'
     );
   });
+  test('hash works for value="mint"', () => {
+    expect(getSelectorFromName('mint')).toBe(
+      '0x02f0b3c5710379609eb5495f1ecd348cb28167711b73609fe565a72734550354'
+    );
+  });
 });

package.json

@@ -55,6 +55,7 @@
     "typescript": "^4.4.4"
   },
   "dependencies": {
+    "@ethersproject/bignumber": "^5.5.0",
     "axios": "^0.23.0",
     "ethereum-cryptography": "^0.2.0",
     "json-bigint": "^1.0.0",

src/contract.ts

@@ -0,0 +1,109 @@
+import assert from 'assert';
+import { BigNumber } from '@ethersproject/bignumber';
+import { Abi } from './types';
+import { getSelectorFromName } from './utils';
+import { addTransaction } from './starknet';
+
+type Args = { [inputName: string]: string | string[] };
+type Calldata = string[];
+
+const parseFelt = (candidate: string): BigNumber => {
+  try {
+    return BigNumber.from(candidate);
+  } catch (e) {
+    throw Error('Couldnt parse felt');
+  }
+};
+
+const isFelt = (candidate: string): boolean => {
+  try {
+    parseFelt(candidate);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+export class Contract {
+  connectedTo: string | null = null;
+
+  abi: Abi[];
+
+  /**
+   * Contract class to handle contract methods
+   *
+   * @param abi - Abi of the contract object
+   * @param address (optional) - address to connect to
+   */
+  constructor(abi: Abi[], address: string | null = null) {
+    this.connectedTo = address;
+    this.abi = abi;
+  }
+
+  public connect(address: string): Contract {
+    this.connectedTo = address;
+    return this;
+  }
+
+  private static compileCalldata(args: Args): Calldata {
+    return Object.values(args).flatMap((value) => {
+      if (Array.isArray(value))
+        return [
+          BigNumber.from(value.length).toString(),
+          ...value.map((x) => BigNumber.from(x).toString()),
+        ];
+      return BigNumber.from(value).toString();
+    });
+  }
+
+  public invoke(method: string, args: Args = {}) {
+    // ensure contract is connected
+    assert(this.connectedTo !== null, 'contract isnt connected to an address');
+
+    // ensure provided method exists
+    const invokeableFunctionNames = this.abi
+      .filter((abi) => {
+        const isView = abi.stateMutability === 'view';
+        const isFunction = abi.type === 'function';
+        return isFunction && !isView;
+      })
+      .map((abi) => abi.name);
+    assert(invokeableFunctionNames.includes(method), 'invokeable method not found in abi');
+
+    // ensure args match abi type
+    const methodAbi = this.abi.find((abi) => abi.name === method)!;
+    methodAbi.inputs.forEach((input) => {
+      assert(args[input.name] !== undefined, `no arg for "${input.name}" provided`);
+      if (input.type === 'felt') {
+        assert(typeof args[input.name] === 'string', `arg ${input.name} should be a felt (string)`);
+        assert(
+          isFelt(args[input.name] as string),
+          `arg ${input.name} should be decimal or hexadecimal`
+        );
+      } else {
+        assert(Array.isArray(args[input.name]), `arg ${input.name} should be a felt* (string[])`);
+        (args[input.name] as string[]).forEach((felt, i) => {
+          assert(
+            typeof felt === 'string',
+            `arg ${input.name}[${i}] should be a felt (string) as part of a felt* (string[])`
+          );
+          assert(
+            isFelt(felt),
+            `arg ${input.name}[${i}] should be decimal or hexadecimal as part of a felt* (string[])`
+          );
+        });
+      }
+    });
+
+    // compile calldata
+    const entrypointSelector = getSelectorFromName(method);
+    const calldata = Contract.compileCalldata(args);
+
+    return addTransaction({
+      type: 'INVOKE_FUNCTION',
+      contract_address: this.connectedTo,
+      calldata,
+      entry_point_selector: entrypointSelector,
+    });
+  }
+}