Validate functionAbi using ethers ABI parser (#228)

src/conditions/base/contract.ts

@@ -1,3 +1,4 @@
+import { ethers } from 'ethers';
 import Joi from 'joi';
 
 import { ETH_ADDRESS_REGEXP } from '../const';
@@ -6,31 +7,58 @@ import { RpcCondition, rpcConditionRecord } from './rpc';
 
 export const STANDARD_CONTRACT_TYPES = ['ERC20', 'ERC721'];
 
-const functionAbiVariable = Joi.object({
- internalType: Joi.string(), // TODO is this needed?
- name: Joi.string().required(),
- type: Joi.string().required(),
-});
-
 const functionAbiSchema = Joi.object({
  name: Joi.string().required(),
  type: Joi.string().valid('function').required(),
- inputs: Joi.array().items(functionAbiVariable),
- outputs: Joi.array().items(functionAbiVariable),
- // TODO: Should we restrict this to 'view'?
- stateMutability: Joi.string(),
+ inputs: Joi.array(),
+ outputs: Joi.array(),
+ stateMutability: Joi.string().valid('view', 'pure').required(),
 }).custom((functionAbi, helper) => {
+ // Is `functionABI` a valid function fragment?
+ let asInterface;
+ try {
+ asInterface = new ethers.utils.Interface([functionAbi]);
+ } catch (e: unknown) {
+ const { message } = e as Error;
+ return helper.message({
+ custom: message,
+ });
+ }
+
+ if (!asInterface.functions) {
+ return helper.message({
+ custom: '"functionAbi" is missing a function fragment',
+ });
+ }
+
+ if (Object.values(asInterface.functions).length !== 1) {
+ return helper.message({
+ custom: '"functionAbi" must contain exactly one function fragment',
+ });
+ }
+
+ // Now we just need to validate against the parent schema
  // Validate method name
  const method = helper.state.ancestors[0].method;
- if (functionAbi.name !== method) {
+
+ let functionFragment;
+ try {
+ functionFragment = asInterface.getFunction(method);
+ } catch (e) {
+ return helper.message({
+ custom: `"functionAbi" has no matching function for "${method}"`,
+ });
+ }
+
+ if (!functionFragment) {
  return helper.message({
- custom: '"method" must be the same as "functionAbi.name"',
+ custom: `"functionAbi" not valid for method: "${method}"`,
  });
  }
 
  // Validate nr of parameters
  const parameters = helper.state.ancestors[0].parameters;
- if (functionAbi.inputs?.length !== parameters.length) {
+ if (functionFragment.inputs.length !== parameters.length) {
  return helper.message({
  custom: '"parameters" must have the same length as "functionAbi.inputs"',
  });
@@ -39,7 +67,7 @@ const functionAbiSchema = Joi.object({
  return functionAbi;
 });
 
-export const contractConditionRecord: Record<string, Joi.Schema> = {
+export const contractConditionRecord = {
  ...rpcConditionRecord,
  contractAddress: Joi.string().pattern(ETH_ADDRESS_REGEXP).required(),
  standardContractType: Joi.string()

test/unit/conditions/base/contract.test.ts

@@ -7,7 +7,7 @@ import {
 import { ContractCondition } from '../../../../src/conditions/base';
 import { USER_ADDRESS_PARAM } from '../../../../src/conditions/const';
 import { fakeWeb3Provider } from '../../../utils';
-import { testContractConditionObj } from '../../testVariables';
+import { testContractConditionObj, testFunctionAbi } from '../../testVariables';
 
 describe('validation', () => {
  it('accepts on a valid schema', () => {
@@ -103,30 +103,10 @@ describe('accepts either standardContractType or functionAbi but not both or non
 });
 
 describe('supports custom function abi', () => {
- const fakeFunctionAbi = {
- name: 'myFunction',
- type: 'function',
- inputs: [
- {
- name: 'account',
- type: 'address',
- },
- {
- name: 'myCustomParam',
- type: 'uint256',
- },
- ],
- outputs: [
- {
- name: 'someValue',
- type: 'uint256',
- },
- ],
- };
  const contractConditionObj = {
  ...testContractConditionObj,
  standardContractType: undefined,
- functionAbi: fakeFunctionAbi,
+ functionAbi: testFunctionAbi,
  method: 'myFunction',
  parameters: [USER_ADDRESS_PARAM, ':customParam'],
  returnValueTest: {
@@ -143,12 +123,117 @@ describe('supports custom function abi', () => {
  const customParams: Record<string, CustomContextParam> = {};
  customParams[myCustomParam] = 1234;
 
- it('accepts custom function abi', async () => {
+ it('accepts custom function abi with a custom parameter', async () => {
  const asJson = await conditionContext
  .withCustomParams(customParams)
  .toJson();
  expect(asJson).toBeDefined();
  expect(asJson).toContain(USER_ADDRESS_PARAM);
  expect(asJson).toContain(myCustomParam);
  });
+
+ it.each([
+ {
+ method: 'balanceOf',
+ functionAbi: {
+ name: 'balanceOf',
+ type: 'function',
+ inputs: [{ name: '_owner', type: 'address' }],
+ outputs: [{ name: 'balance', type: 'uint256' }],
+ stateMutability: 'view',
+ },
+ },
+ {
+ method: 'get',
+ functionAbi: {
+ name: 'get',
+ type: 'function',
+ inputs: [],
+ outputs: [],
+ stateMutability: 'pure',
+ },
+ },
+ ])('accepts well-formed functionAbi', ({ method, functionAbi }) => {
+ expect(() =>
+ new ContractCondition({
+ ...contractConditionObj,
+ parameters: functionAbi.inputs.map(
+ (input) => `fake_parameter_${input}`
+ ), //
+ functionAbi,
+ method,
+ }).toObj()
+ ).not.toThrow();
+ });
+
+ it.each([
+ {
+ method: '1234',
+ expectedError: '"functionAbi.name" must be a string',
+ functionAbi: {
+ name: 1234, // invalid value
+ type: 'function',
+ inputs: [{ name: '_owner', type: 'address' }],
+ outputs: [{ name: 'balance', type: 'uint256' }],
+ stateMutability: 'view',
+ },
+ },
+ {
+ method: 'transfer',
+ expectedError: '"functionAbi.inputs" must be an array',
+ functionAbi: {
+ name: 'transfer',
+ type: 'function',
+ inputs: 'invalid value', // invalid value
+ outputs: [{ name: '_status', type: 'bool' }],
+ stateMutability: 'pure',
+ },
+ },
+ {
+ method: 'get',
+ expectedError:
+ '"functionAbi.stateMutability" must be one of [view, pure]',
+ functionAbi: {
+ name: 'get',
+ type: 'function',
+ inputs: [],
+ outputs: [],
+ stateMutability: 'invalid', // invalid value
+ },
+ },
+ {
+ method: 'test',
+ expectedError: '"functionAbi.outputs" must be an array',
+ functionAbi: {
+ name: 'test',
+ type: 'function',
+ inputs: [],
+ outputs: 'invalid value', // Invalid value
+ stateMutability: 'pure',
+ },
+ },
+ {
+ method: 'calculatePow',
+ expectedError:
+ 'Invalid condition: "parameters" must have the same length as "functionAbi.inputs"',
+ functionAbi: {
+ name: 'calculatePow',
+ type: 'function',
+ // 'inputs': [] // Missing inputs array
+ outputs: [{ name: 'result', type: 'uint256' }],
+ stateMutability: 'view',
+ },
+ },
+ ])(
+ 'rejects malformed functionAbi',
+ ({ method, expectedError, functionAbi }) => {
+ expect(() =>
+ new ContractCondition({
+ ...contractConditionObj,
+ functionAbi,
+ method,
+ }).toObj()
+ ).toThrow(expectedError);
+ }
+ );
 });

test/unit/testVariables.ts

@@ -48,6 +48,7 @@ export const testContractConditionObj = {
 export const testFunctionAbi = {
  name: 'myFunction',
  type: 'function',
+ stateMutability: 'view',
  inputs: [
  {
  internalType: 'address',
@@ -67,5 +68,4 @@ export const testFunctionAbi = {
  type: 'uint256',
  },
  ],
- stateMutability: 'view',
 };