ox 1.0.0-beta.2 → 1.0.0-beta.20

package/src/core/internal/human-readable/runtime/cache.ts

@@ -0,0 +1,96 @@
+import type { AbiItemType, AbiParameter } from 'abitype'
+import type { StructLookup } from '../types/structs.js'
+
+/**
+ * Gets the parameter cache key namespaced by `type` and `structs`. This prevents
+ * parameters from being accessible to types that don't allow them (e.g.
+ * `string indexed foo` not allowed outside of `type: 'event'`) and ensures
+ * different struct definitions with the same name are cached separately.
+ * @param param ABI parameter string
+ * @param type ABI parameter type
+ * @param structs Struct definitions to include in cache key
+ * @returns Cache key for `parameterCache`.
+ */
+export function getParameterCacheKey(
+  param: string,
+  type?: AbiItemType | 'struct',
+  structs?: StructLookup,
+) {
+  let structKey = ''
+  if (structs)
+    for (const struct of Object.entries(structs)) {
+      if (!struct) continue
+      let propertyKey = ''
+      for (const property of struct[1]) {
+        propertyKey += `[${property.type}${property.name ? `:${property.name}` : ''}]`
+      }
+      structKey += `(${struct[0]}{${propertyKey}})`
+    }
+  if (type) return `${type}:${param}${structKey}`
+  return `${param}${structKey}`
+}
+
+/**
+ * Basic cache seeded with common ABI parameter strings.
+ *
+ * **Note: When seeding more parameters, make sure you benchmark performance. The current number is the ideal balance between performance and having an already existing cache.**
+ */
+export const parameterCache = new Map<
+  string,
+  AbiParameter & { indexed?: boolean }
+>([
+  // Unnamed
+  ['address', { type: 'address' }],
+  ['bool', { type: 'bool' }],
+  ['bytes', { type: 'bytes' }],
+  ['bytes32', { type: 'bytes32' }],
+  ['int', { type: 'int256' }],
+  ['int256', { type: 'int256' }],
+  ['string', { type: 'string' }],
+  ['uint', { type: 'uint256' }],
+  ['uint8', { type: 'uint8' }],
+  ['uint16', { type: 'uint16' }],
+  ['uint24', { type: 'uint24' }],
+  ['uint32', { type: 'uint32' }],
+  ['uint64', { type: 'uint64' }],
+  ['uint96', { type: 'uint96' }],
+  ['uint112', { type: 'uint112' }],
+  ['uint160', { type: 'uint160' }],
+  ['uint192', { type: 'uint192' }],
+  ['uint256', { type: 'uint256' }],
+
+  // Named
+  ['address owner', { type: 'address', name: 'owner' }],
+  ['address to', { type: 'address', name: 'to' }],
+  ['bool approved', { type: 'bool', name: 'approved' }],
+  ['bytes _data', { type: 'bytes', name: '_data' }],
+  ['bytes data', { type: 'bytes', name: 'data' }],
+  ['bytes signature', { type: 'bytes', name: 'signature' }],
+  ['bytes32 hash', { type: 'bytes32', name: 'hash' }],
+  ['bytes32 r', { type: 'bytes32', name: 'r' }],
+  ['bytes32 root', { type: 'bytes32', name: 'root' }],
+  ['bytes32 s', { type: 'bytes32', name: 's' }],
+  ['string name', { type: 'string', name: 'name' }],
+  ['string symbol', { type: 'string', name: 'symbol' }],
+  ['string tokenURI', { type: 'string', name: 'tokenURI' }],
+  ['uint tokenId', { type: 'uint256', name: 'tokenId' }],
+  ['uint8 v', { type: 'uint8', name: 'v' }],
+  ['uint256 balance', { type: 'uint256', name: 'balance' }],
+  ['uint256 tokenId', { type: 'uint256', name: 'tokenId' }],
+  ['uint256 value', { type: 'uint256', name: 'value' }],
+
+  // Indexed
+  [
+    'event:address indexed from',
+    { type: 'address', name: 'from', indexed: true },
+  ],
+  ['event:address indexed to', { type: 'address', name: 'to', indexed: true }],
+  [
+    'event:uint indexed tokenId',
+    { type: 'uint256', name: 'tokenId', indexed: true },
+  ],
+  [
+    'event:uint256 indexed tokenId',
+    { type: 'uint256', name: 'tokenId', indexed: true },
+  ],
+])

package/src/core/internal/human-readable/runtime/signatures.test.ts

@@ -0,0 +1,236 @@
+import { expect, test } from 'vp/test'
+
+import {
+  execConstructorSignature,
+  execErrorSignature,
+  execEventSignature,
+  execFunctionSignature,
+  execStructSignature,
+  isConstructorSignature,
+  isErrorSignature,
+  isEventSignature,
+  isFallbackSignature,
+  isFunctionSignature,
+  isReceiveSignature,
+  isStructSignature,
+} from './signatures.js'
+
+test('isErrorSignature', () => {
+  expect(isErrorSignature('error Name(string)')).toMatchInlineSnapshot('true')
+  expect(isErrorSignature('error $(string)')).toMatchInlineSnapshot('true')
+  expect(isErrorSignature('error $_a9(string)')).toMatchInlineSnapshot('true')
+  expect(isErrorSignature('error _(string)')).toMatchInlineSnapshot('true')
+  expect(isErrorSignature('error abc$_9(string)')).toMatchInlineSnapshot('true')
+  expect(isErrorSignature('function name(string)')).toMatchInlineSnapshot(
+    'false',
+  )
+  expect(isErrorSignature('error 9abc(string)')).toMatchInlineSnapshot('false')
+})
+
+test('execErrorSignature', () => {
+  expect(execErrorSignature('error Name(string)')).toMatchInlineSnapshot(`
+    {
+      "name": "Name",
+      "parameters": "string",
+    }
+  `)
+  expect(execErrorSignature('function name(string)')).toMatchInlineSnapshot(
+    'undefined',
+  )
+})
+
+test('isEventSignature', () => {
+  expect(isEventSignature('event Name(string)')).toMatchInlineSnapshot('true')
+  expect(isEventSignature('event $(string)')).toMatchInlineSnapshot('true')
+  expect(isEventSignature('event $_a9(string)')).toMatchInlineSnapshot('true')
+  expect(isEventSignature('event _(string)')).toMatchInlineSnapshot('true')
+  expect(isEventSignature('event abc$_9(string)')).toMatchInlineSnapshot('true')
+  expect(isEventSignature('function name(string)')).toMatchInlineSnapshot(
+    'false',
+  )
+  expect(isEventSignature('event 9abc(string)')).toMatchInlineSnapshot('false')
+})
+
+test('execEventSignature', () => {
+  expect(execEventSignature('event Name(string)')).toMatchInlineSnapshot(`
+    {
+      "name": "Name",
+      "parameters": "string",
+    }
+  `)
+  expect(execEventSignature('event Name(string indexed foo)'))
+    .toMatchInlineSnapshot(`
+      {
+        "name": "Name",
+        "parameters": "string indexed foo",
+      }
+    `)
+  expect(execEventSignature('function name(string)')).toMatchInlineSnapshot(
+    'undefined',
+  )
+})
+
+test('isFunctionSignature', () => {
+  expect(isFunctionSignature('function name(string)')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(
+    isFunctionSignature('function name(string) returns (uint256)'),
+  ).toMatchInlineSnapshot('true')
+  expect(
+    isFunctionSignature('function name(string) returns(uint256)'),
+  ).toMatchInlineSnapshot('true')
+  expect(isFunctionSignature('function $(string)')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isFunctionSignature('function $_a9(string)')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isFunctionSignature('function _(string)')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isFunctionSignature('function abc$_9(string)')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isFunctionSignature('struct Name { string; }')).toMatchInlineSnapshot(
+    'false',
+  )
+  expect(isFunctionSignature('function 9abc(string)')).toMatchInlineSnapshot(
+    'false',
+  )
+})
+
+test('execFunctionSignature', () => {
+  expect(execFunctionSignature('function name(string)')).toMatchInlineSnapshot(`
+    {
+      "name": "name",
+      "parameters": "string",
+      "returns": undefined,
+      "scope": undefined,
+      "stateMutability": undefined,
+    }
+  `)
+  expect(execFunctionSignature('function foo() view returns (uint256)'))
+    .toMatchInlineSnapshot(`
+    {
+      "name": "foo",
+      "parameters": "",
+      "returns": "uint256",
+      "scope": undefined,
+      "stateMutability": "view",
+    }
+  `)
+  expect(execFunctionSignature('function foo() view returns(uint256)'))
+    .toMatchInlineSnapshot(`
+    {
+      "name": "foo",
+      "parameters": "",
+      "returns": "uint256",
+      "scope": undefined,
+      "stateMutability": "view",
+    }
+  `)
+  expect(
+    execFunctionSignature('struct Name { string; }'),
+  ).toMatchInlineSnapshot('undefined')
+})
+
+test('isStructSignature', () => {
+  expect(isStructSignature('struct Name { string; }')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isStructSignature('struct $ { string; }')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isStructSignature('struct $_a9 { string; }')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isStructSignature('struct _ { string; }')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isStructSignature('struct abc$_9 { string; }')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isStructSignature('function name(string)')).toMatchInlineSnapshot(
+    'false',
+  )
+  expect(isStructSignature('struct 9abc { string; }')).toMatchInlineSnapshot(
+    'false',
+  )
+})
+
+test('execStructSignature', () => {
+  expect(execStructSignature('struct Name { string; }')).toMatchInlineSnapshot(`
+    {
+      "name": "Name",
+      "properties": " string; ",
+    }
+  `)
+  expect(execStructSignature('function name(string)')).toMatchInlineSnapshot(
+    'undefined',
+  )
+})
+
+test('isConstructorSignature', () => {
+  expect(isConstructorSignature('constructor(string)')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(isConstructorSignature('function name(string)')).toMatchInlineSnapshot(
+    'false',
+  )
+})
+
+test('execConstructorSignature', () => {
+  expect(execConstructorSignature('constructor(string)')).toMatchInlineSnapshot(
+    `
+    {
+      "parameters": "string",
+      "stateMutability": undefined,
+    }
+  `,
+  )
+  expect(
+    execConstructorSignature('constructor(string) payable'),
+  ).toMatchInlineSnapshot(
+    `
+    {
+      "parameters": "string",
+      "stateMutability": "payable",
+    }
+  `,
+  )
+  expect(
+    execConstructorSignature('constructor(string) '),
+  ).toMatchInlineSnapshot('undefined')
+  expect(
+    execConstructorSignature('constructor(string) external'),
+  ).toMatchInlineSnapshot('undefined')
+  expect(
+    execConstructorSignature('constructor(string)external'),
+  ).toMatchInlineSnapshot('undefined')
+  expect(
+    execConstructorSignature('function name(string)'),
+  ).toMatchInlineSnapshot('undefined')
+})
+
+test('isFallbackSignature', () => {
+  expect(isFallbackSignature('fallback() external')).toMatchInlineSnapshot(
+    'true',
+  )
+  expect(
+    isFallbackSignature('fallback() external payable'),
+  ).toMatchInlineSnapshot('true')
+
+  expect(isFallbackSignature('function name(string)')).toMatchInlineSnapshot(
+    'false',
+  )
+})
+
+test('isReceiveSignature', () => {
+  expect(
+    isReceiveSignature('receive() external payable'),
+  ).toMatchInlineSnapshot('true')
+  expect(isReceiveSignature('function name(string)')).toMatchInlineSnapshot(
+    'false',
+  )
+})

package/src/core/internal/human-readable/runtime/signatures.ts

@@ -0,0 +1,106 @@
+import type { AbiStateMutability } from 'abitype'
+import { execTyped } from '../regex.js'
+import type {
+  EventModifier,
+  FunctionModifier,
+  Modifier,
+} from '../types/signatures.js'
+
+// https://regexr.com/7gmok
+const errorSignatureRegex =
+  /^error (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/
+export function isErrorSignature(signature: string) {
+  return errorSignatureRegex.test(signature)
+}
+export function execErrorSignature(signature: string) {
+  return execTyped<{ name: string; parameters: string }>(
+    errorSignatureRegex,
+    signature,
+  )
+}
+
+// https://regexr.com/7gmoq
+const eventSignatureRegex =
+  /^event (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)$/
+export function isEventSignature(signature: string) {
+  return eventSignatureRegex.test(signature)
+}
+export function execEventSignature(signature: string) {
+  return execTyped<{ name: string; parameters: string }>(
+    eventSignatureRegex,
+    signature,
+  )
+}
+
+// https://regexr.com/7gmot
+const functionSignatureRegex =
+  /^function (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*)\((?<parameters>.*?)\)(?: (?<scope>external|public{1}))?(?: (?<stateMutability>pure|view|nonpayable|payable{1}))?(?: returns\s?\((?<returns>.*?)\))?$/
+export function isFunctionSignature(signature: string) {
+  return functionSignatureRegex.test(signature)
+}
+export function execFunctionSignature(signature: string) {
+  return execTyped<{
+    name: string
+    parameters: string
+    stateMutability?: AbiStateMutability
+    returns?: string
+  }>(functionSignatureRegex, signature)
+}
+
+// https://regexr.com/7gmp3
+const structSignatureRegex =
+  /^struct (?<name>[a-zA-Z$_][a-zA-Z0-9$_]*) \{(?<properties>.*?)\}$/
+export function isStructSignature(signature: string) {
+  return structSignatureRegex.test(signature)
+}
+export function execStructSignature(signature: string) {
+  return execTyped<{ name: string; properties: string }>(
+    structSignatureRegex,
+    signature,
+  )
+}
+
+// https://regexr.com/78u01
+const constructorSignatureRegex =
+  /^constructor\((?<parameters>.*?)\)(?:\s(?<stateMutability>payable{1}))?$/
+export function isConstructorSignature(signature: string) {
+  return constructorSignatureRegex.test(signature)
+}
+export function execConstructorSignature(signature: string) {
+  return execTyped<{
+    parameters: string
+    stateMutability?: Extract<AbiStateMutability, 'payable'>
+  }>(constructorSignatureRegex, signature)
+}
+
+// https://regexr.com/7srtn
+const fallbackSignatureRegex =
+  /^fallback\(\) external(?:\s(?<stateMutability>payable{1}))?$/
+export function isFallbackSignature(signature: string) {
+  return fallbackSignatureRegex.test(signature)
+}
+export function execFallbackSignature(signature: string) {
+  return execTyped<{
+    parameters: string
+    stateMutability?: Extract<AbiStateMutability, 'payable'>
+  }>(fallbackSignatureRegex, signature)
+}
+
+// https://regexr.com/78u1k
+const receiveSignatureRegex = /^receive\(\) external payable$/
+export function isReceiveSignature(signature: string) {
+  return receiveSignatureRegex.test(signature)
+}
+
+export const modifiers = new Set<Modifier>([
+  'memory',
+  'indexed',
+  'storage',
+  'calldata',
+])
+export const eventModifiers = new Set<EventModifier>(['indexed'])
+export const functionModifiers = new Set<FunctionModifier>([
+  'calldata',
+  'memory',
+  'storage',
+])

package/src/core/internal/human-readable/runtime/structs.test.ts

@@ -0,0 +1,210 @@
+import { expect, test } from 'vp/test'
+
+import { parseStructs } from './structs.js'
+
+test('no structs', () => {
+  expect(parseStructs([])).toMatchInlineSnapshot('{}')
+  expect(parseStructs([''])).toMatchInlineSnapshot('{}')
+  expect(parseStructs(['function foo()', 'event Foo()'])).toMatchInlineSnapshot(
+    '{}',
+  )
+  expect(
+    parseStructs(['function addPerson(Person person)']),
+  ).toMatchInlineSnapshot('{}')
+})
+
+test('parses basic structs', () => {
+  expect(
+    parseStructs([
+      'struct Foo { string bar; address baz; }',
+      'struct FulfillmentComponent { uint256 orderIndex; uint256 itemIndex; }',
+    ]),
+  ).toMatchInlineSnapshot(`
+    {
+      "Foo": [
+        {
+          "name": "bar",
+          "type": "string",
+        },
+        {
+          "name": "baz",
+          "type": "address",
+        },
+      ],
+      "FulfillmentComponent": [
+        {
+          "name": "orderIndex",
+          "type": "uint256",
+        },
+        {
+          "name": "itemIndex",
+          "type": "uint256",
+        },
+      ],
+    }
+  `)
+})
+
+test('parses valid names', () => {
+  expect(
+    parseStructs([
+      'struct $ { string; }',
+      'struct $_a9 { string; }',
+      'struct _ { string; }',
+      'struct abc$_9 { string; }',
+    ]),
+  ).toMatchInlineSnapshot(`
+    {
+      "$": [
+        {
+          "type": "string",
+        },
+      ],
+      "$_a9": [
+        {
+          "type": "string",
+        },
+      ],
+      "_": [
+        {
+          "type": "string",
+        },
+      ],
+      "abc$_9": [
+        {
+          "type": "string",
+        },
+      ],
+    }
+  `)
+})
+
+test('parses and resolves nested structs', () => {
+  expect(
+    parseStructs([
+      'struct Fulfillment { FulfillmentComponent[] offerComponents; FulfillmentComponent[] considerationComponents; }',
+      'struct FulfillmentComponent { uint256 orderIndex; uint256 itemIndex; }',
+      'struct Foo { Fulfillment fulfillment; }',
+    ]),
+  ).toMatchInlineSnapshot(`
+    {
+      "Foo": [
+        {
+          "components": [
+            {
+              "components": [
+                {
+                  "name": "orderIndex",
+                  "type": "uint256",
+                },
+                {
+                  "name": "itemIndex",
+                  "type": "uint256",
+                },
+              ],
+              "name": "offerComponents",
+              "type": "tuple[]",
+            },
+            {
+              "components": [
+                {
+                  "name": "orderIndex",
+                  "type": "uint256",
+                },
+                {
+                  "name": "itemIndex",
+                  "type": "uint256",
+                },
+              ],
+              "name": "considerationComponents",
+              "type": "tuple[]",
+            },
+          ],
+          "name": "fulfillment",
+          "type": "tuple",
+        },
+      ],
+      "Fulfillment": [
+        {
+          "components": [
+            {
+              "name": "orderIndex",
+              "type": "uint256",
+            },
+            {
+              "name": "itemIndex",
+              "type": "uint256",
+            },
+          ],
+          "name": "offerComponents",
+          "type": "tuple[]",
+        },
+        {
+          "components": [
+            {
+              "name": "orderIndex",
+              "type": "uint256",
+            },
+            {
+              "name": "itemIndex",
+              "type": "uint256",
+            },
+          ],
+          "name": "considerationComponents",
+          "type": "tuple[]",
+        },
+      ],
+      "FulfillmentComponent": [
+        {
+          "name": "orderIndex",
+          "type": "uint256",
+        },
+        {
+          "name": "itemIndex",
+          "type": "uint256",
+        },
+      ],
+    }
+  `)
+})
+
+test('no properties', () => {
+  expect(() =>
+    parseStructs(['struct Foo {}']),
+  ).toThrowErrorMatchingInlineSnapshot(
+    `
+    [Abi.InvalidStructSignatureError: Invalid struct signature.
+
+    No properties exist.
+
+    Details: struct Foo {}]
+  `,
+  )
+})
+
+test('struct does not exist when resolving', () => {
+  expect(() => parseStructs(['struct Foo { Bar bar; }']))
+    .toThrowErrorMatchingInlineSnapshot(`
+    [HumanReadableAbi.UnknownTypeError: Unknown type.
+
+    Type "Bar" is not a valid ABI type. Perhaps you forgot to include a struct signature?]
+  `)
+})
+
+test('throws if recursive structs are detected', () => {
+  expect(() =>
+    parseStructs(['struct Foo { Bar bar; }', 'struct Bar { Foo foo; }']),
+  ).toThrowErrorMatchingInlineSnapshot(
+    `
+    [Abi.CircularReferenceError: Circular reference detected.
+
+    Struct "Bar" is a circular reference.]
+  `,
+  )
+})
+
+test.todo('throws if property is missing semicolon', () => {
+  expect(() =>
+    parseStructs(['struct Foo { string bar; address baz }']),
+  ).toThrowErrorMatchingInlineSnapshot()
+})