ox 0.0.1 → 0.1.0

package/_test/AbiFunction.snap-d.ts

@@ -0,0 +1,262 @@
+import { attest } from '@ark/attest'
+import { Abi, AbiFunction, AbiParameters } from 'ox'
+import { describe, test } from 'vitest'
+import { erc20Abi, wagmiContractConfig } from '../../test/constants/abis.js'
+import { address } from '../../test/constants/addresses.js'
+
+describe('decodeData', () => {
+  test('default', () => {
+    const abiItem = AbiFunction.fromAbi(erc20Abi, 'decimals')
+    const data = AbiFunction.encodeData(abiItem)
+    const input = AbiFunction.decodeData(abiItem, data)
+    attest(input).type.toString.snap('undefined')
+  })
+
+  test('behavior: with data', () => {
+    const abiItem = AbiFunction.fromAbi(erc20Abi, 'approve', {
+      prepare: false,
+    })
+    const data = AbiFunction.encodeData(abiItem, [address.vitalik, 1n])
+    const input = AbiFunction.decodeData(abiItem, data)
+    attest(input).type.toString.snap('readonly [`0x${string}`, bigint]')
+  })
+
+  test('behavior: with overloads', () => {
+    const abi = Abi.from([
+      {
+        inputs: [{ type: 'bytes' }],
+        name: 'balanceOf',
+        outputs: [{ type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+      },
+      {
+        inputs: [{ name: 'x', type: 'uint256' }],
+        name: 'balanceOf',
+        outputs: [{ name: '', type: 'uint256' }],
+        stateMutability: 'view',
+        type: 'function',
+      },
+    ])
+    const abiItem = AbiFunction.fromAbi(abi, 'balanceOf')
+    attest(
+      AbiFunction.decodeData(
+        abiItem,
+        '0x9cc7f7080000000000000000000000000000000000000000000000000000000000000001',
+      ),
+    ).type.toString.snap('readonly [bigint] | readonly [`0x${string}`]')
+    attest(
+      AbiFunction.decodeData(
+        abiItem,
+        '0x7841536500000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000004deadbeef00000000000000000000000000000000000000000000000000000000',
+      ),
+    ).type.toString.snap('readonly [bigint] | readonly [`0x${string}`]')
+  })
+})
+
+describe('decodeResult', () => {
+  test('default', () => {
+    const abiItem = AbiFunction.from(
+      'function test() returns (uint a, (uint x, string y) b)',
+    )
+    const args = [420n, { x: 420n, y: 'lol' }] as const
+    const result = AbiFunction.decodeResult(
+      abiItem,
+      AbiParameters.encode(abiItem.outputs, args),
+    )
+    attest(result).type.toString.snap(
+      'readonly [bigint, { x: bigint; y: string }]',
+    )
+  })
+
+  test('behavior: single output parameter', () => {
+    const abiItem = AbiFunction.from('function test() returns (uint a)')
+    const args = [420n] as const
+    const result = AbiFunction.decodeResult(
+      abiItem,
+      AbiParameters.encode(abiItem.outputs, args),
+    )
+    attest(result).type.toString.snap('bigint')
+  })
+
+  test('behavior: no output parameter', () => {
+    const abiItem = AbiFunction.from('function test()')
+    const result = AbiFunction.decodeResult(abiItem, '0x')
+    attest(result).type.toString.snap('undefined')
+  })
+
+  test('behavior: widened', () => {
+    const abiItem = AbiFunction.from('function test() returns (uint a)')
+    const args = [420n] as const
+    const result = AbiFunction.decodeResult(
+      abiItem as AbiFunction.AbiFunction,
+      AbiParameters.encode(abiItem.outputs, args),
+    )
+    attest(result).type.toString.snap('unknown')
+  })
+
+  test('options: as = Object', () => {
+    const abiItem = AbiFunction.from(
+      'function test() returns (uint a, (uint x, string y) b)',
+    )
+    const args = [420n, { x: 420n, y: 'lol' }] as const
+    const result = AbiFunction.decodeResult(
+      abiItem,
+      AbiParameters.encode(abiItem.outputs, args),
+      { as: 'Object' },
+    )
+    attest(result).type.toString.snap(
+      '{ a: bigint; b: { x: bigint; y: string } }',
+    )
+  })
+
+  test('options: as = Object, behavior: single output parameter', () => {
+    const abiItem = AbiFunction.from('function test() returns (uint a)')
+    const args = [420n] as const
+    const result = AbiFunction.decodeResult(
+      abiItem,
+      AbiParameters.encode(abiItem.outputs, args),
+      { as: 'Object' },
+    )
+    attest(result).type.toString.snap('bigint')
+  })
+
+  test('options: as = Object, behavior: no output parameter', () => {
+    const abiItem = AbiFunction.from('function test()')
+    const result = AbiFunction.decodeResult(abiItem, '0x', { as: 'Object' })
+    attest(result).type.toString.snap('undefined')
+  })
+
+  test('behavior: abiItem union', () => {
+    const abi = Abi.from(wagmiContractConfig.abi)
+    const abiItem = AbiFunction.fromAbi(
+      abi,
+      'totalSupply' as AbiFunction.Name<typeof abi>,
+    )
+    if (abiItem.type === 'function') {
+      const result = AbiFunction.decodeResult(
+        abiItem,
+        '0x000000000000000000000000000000000000000000000000000000000000000000000001',
+      )
+      attest(result).type.toString.snap('string | bigint | boolean | undefined')
+    }
+  })
+})
+
+describe('fromAbi', () => {
+  test('default', () => {
+    const item = AbiFunction.fromAbi(wagmiContractConfig.abi, 'balanceOf', {
+      args: ['0x0000000000000000000000000000000000000000'],
+    })
+    attest(item).type.toString.snap(`{
+  readonly inputs: readonly [
+    { readonly name: "owner"; readonly type: "address" }
+  ]
+  readonly name: "balanceOf"
+  readonly outputs: readonly [
+    { readonly name: ""; readonly type: "uint256" }
+  ]
+  readonly stateMutability: "view"
+  readonly type: "function"
+}`)
+  })
+
+  test('behavior: unknown abi', () => {
+    const item = AbiFunction.fromAbi(
+      wagmiContractConfig.abi as readonly unknown[],
+      'balanceOf',
+      {
+        args: ['0x0000000000000000000000000000000000000000'],
+      },
+    )
+    attest(item).type.toString.snap('AbiFunction')
+  })
+
+  test('behavior: data', () => {
+    const item = AbiFunction.fromAbi(wagmiContractConfig.abi, 'approve')
+    const data = AbiFunction.encodeData(item, [
+      '0x0000000000000000000000000000000000000000',
+      1n,
+    ])
+    const item_2 = AbiFunction.fromAbi(wagmiContractConfig.abi, data)
+    attest(item_2.name).type.toString.snap(`  | "symbol"
+  | "name"
+  | "approve"
+  | "balanceOf"
+  | "totalSupply"
+  | "transferFrom"
+  | "getApproved"
+  | "isApprovedForAll"
+  | "ownerOf"
+  | "safeTransferFrom"
+  | "setApprovalForAll"
+  | "supportsInterface"
+  | "tokenURI"
+  | "mint"`)
+  })
+
+  test('behavior: overloads', () => {
+    const abi = Abi.from([
+      'function bar()',
+      'function foo()',
+      'function foo(uint256)',
+    ])
+    const item = AbiFunction.fromAbi(abi, 'foo')
+    attest(item).type.toString.snap(`{
+  readonly name: "foo"
+  readonly type: "function"
+  readonly stateMutability: "nonpayable"
+  readonly inputs: readonly []
+  readonly outputs: readonly []
+}`)
+  })
+
+  test('behavior: overloads: no inputs or args', () => {
+    const abi = Abi.from([
+      'function bar()',
+      'function foo(bytes)',
+      'function foo(uint256)',
+    ])
+    const item = AbiFunction.fromAbi(abi, 'foo')
+    attest(item).type.toString.snap(`{
+  readonly name: "foo"
+  readonly type: "function"
+  readonly stateMutability: "nonpayable"
+  readonly inputs: readonly [{ readonly type: "bytes" }]
+  readonly outputs: readonly []
+  readonly overloads: [
+    {
+      readonly name: "foo"
+      readonly type: "function"
+      readonly stateMutability: "nonpayable"
+      readonly inputs: readonly [
+        { readonly type: "uint256" }
+      ]
+      readonly outputs: readonly []
+    }
+  ]
+}`)
+  })
+
+  test('behavior: widened name', () => {
+    const abi = Abi.from(wagmiContractConfig.abi)
+    const abiItem = AbiFunction.fromAbi(
+      abi,
+      'totalSupply' as AbiFunction.Name<typeof abi>,
+    )
+    attest(abiItem.name).type.toString.snap(`  | "symbol"
+  | "name"
+  | "approve"
+  | "balanceOf"
+  | "totalSupply"
+  | "transferFrom"
+  | "getApproved"
+  | "isApprovedForAll"
+  | "ownerOf"
+  | "safeTransferFrom"
+  | "setApprovalForAll"
+  | "supportsInterface"
+  | "tokenURI"
+  | "mint"`)
+  })
+})

package/_test/AbiItem.snap-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/AbiItem.snap-d.d.ts",
+  "main": "../_cjs/_test/AbiItem.snap-d.js",
+  "module": "../_esm/_test/AbiItem.snap-d.js"
+}

package/_test/AbiItem.snap-d.ts

@@ -0,0 +1,131 @@
+import { attest } from '@ark/attest'
+import { Abi, AbiFunction, AbiItem } from 'ox'
+import { describe, test } from 'vitest'
+
+import { wagmiContractConfig } from '../../test/constants/abis.js'
+
+describe('fromAbi', () => {
+  test('default', () => {
+    const item = AbiItem.fromAbi(wagmiContractConfig.abi, 'balanceOf')
+    attest(item).type.toString.snap(`{
+    readonly inputs: readonly [
+      { readonly name: "owner"; readonly type: "address" }
+    ]
+    readonly name: "balanceOf"
+    readonly outputs: readonly [
+      { readonly name: ""; readonly type: "uint256" }
+    ]
+    readonly stateMutability: "view"
+    readonly type: "function"
+  }`)
+  })
+
+  test('behavior: unknown abi', () => {
+    const item = AbiItem.fromAbi(
+      wagmiContractConfig.abi as readonly unknown[],
+      'balanceOf',
+      {
+        args: ['0x0000000000000000000000000000000000000000'],
+      },
+    )
+    attest(item).type.toString.snap(`  | AbiConstructor
+    | AbiError
+    | AbiEvent
+    | AbiFallback
+    | AbiFunction
+    | AbiReceive`)
+  })
+
+  test('behavior: data', () => {
+    const data = AbiFunction.encodeData(
+      AbiFunction.fromAbi(wagmiContractConfig.abi, 'approve'),
+      ['0x0000000000000000000000000000000000000000', 1n],
+    )
+    const item_2 = AbiItem.fromAbi(wagmiContractConfig.abi, data)
+    attest(item_2.name).type.toString.snap(`  | "symbol"
+    | "Transfer"
+    | "name"
+    | "approve"
+    | "Approval"
+    | "ApprovalForAll"
+    | "balanceOf"
+    | "totalSupply"
+    | "transferFrom"
+    | "getApproved"
+    | "isApprovedForAll"
+    | "ownerOf"
+    | "safeTransferFrom"
+    | "setApprovalForAll"
+    | "supportsInterface"
+    | "tokenURI"
+    | "mint"`)
+  })
+
+  test('behavior: overloads', () => {
+    const abi = Abi.from([
+      'function bar()',
+      'function foo()',
+      'function foo(uint256)',
+    ])
+    const item = AbiItem.fromAbi(abi, 'foo')
+    attest(item).type.toString.snap(`{
+    readonly name: "foo"
+    readonly type: "function"
+    readonly stateMutability: "nonpayable"
+    readonly inputs: readonly []
+    readonly outputs: readonly []
+  }`)
+  })
+
+  test('behavior: overloads: no inputs or args', () => {
+    const abi = Abi.from([
+      'function bar()',
+      'function foo(bytes)',
+      'function foo(uint256)',
+    ])
+    const item = AbiItem.fromAbi(abi, 'foo')
+    attest(item).type.toString.snap(`{
+    readonly name: "foo"
+    readonly type: "function"
+    readonly stateMutability: "nonpayable"
+    readonly inputs: readonly [{ readonly type: "bytes" }]
+    readonly outputs: readonly []
+    readonly overloads: [
+      {
+        readonly name: "foo"
+        readonly type: "function"
+        readonly stateMutability: "nonpayable"
+        readonly inputs: readonly [
+          { readonly type: "uint256" }
+        ]
+        readonly outputs: readonly []
+      }
+    ]
+  }`)
+  })
+
+  test('behavior: widened name', () => {
+    const abi = Abi.from(wagmiContractConfig.abi)
+    const abiItem = AbiItem.fromAbi(
+      abi,
+      'totalSupply' as AbiItem.Name<typeof abi>,
+    )
+    attest(abiItem.name).type.toString.snap(`  | "symbol"
+    | "Transfer"
+    | "name"
+    | "approve"
+    | "Approval"
+    | "ApprovalForAll"
+    | "balanceOf"
+    | "totalSupply"
+    | "transferFrom"
+    | "getApproved"
+    | "isApprovedForAll"
+    | "ownerOf"
+    | "safeTransferFrom"
+    | "setApprovalForAll"
+    | "supportsInterface"
+    | "tokenURI"
+    | "mint"`)
+  })
+})

package/_test/AbiParameters.bench/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/AbiParameters.bench.d.ts",
+  "main": "../_cjs/_test/AbiParameters.bench.js",
+  "module": "../_esm/_test/AbiParameters.bench.js"
+}

package/_test/AbiParameters.snap-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/AbiParameters.snap-d.d.ts",
+  "main": "../_cjs/_test/AbiParameters.snap-d.js",
+  "module": "../_esm/_test/AbiParameters.snap-d.js"
+}

package/_test/AbiParameters.snap-d.ts

@@ -0,0 +1,66 @@
+import { attest } from '@ark/attest'
+import { AbiParameters } from 'ox'
+import { describe, test } from 'vitest'
+
+describe('decode', () => {
+  test('default', () => {
+    {
+      const result = AbiParameters.decode([], '0x')
+      attest(result).type.toString.snap('[]')
+    }
+
+    {
+      const parameters = AbiParameters.from('bool a, (uint32 x, string y) b')
+      const data = AbiParameters.encode(parameters, [
+        true,
+        { x: 123, y: 'lol' },
+      ])
+      const result = AbiParameters.decode(parameters, data)
+      attest(result).type.toString.snap(
+        'readonly [boolean, { y: string; x: number }]',
+      )
+    }
+  })
+
+  test('options: as = Object', () => {
+    {
+      const result = AbiParameters.decode([], '0x', { as: 'Object' })
+      attest(result).type.toString.snap('{}')
+    }
+
+    {
+      const parameters = AbiParameters.from('bool a, (uint32 x, string y) b')
+      const data = AbiParameters.encode(parameters, [
+        true,
+        { x: 123, y: 'lol' },
+      ])
+      const result = AbiParameters.decode(parameters, data, {
+        as: 'Object',
+      })
+      attest(result).type.toString.snap(
+        '{ a: boolean; b: { y: string; x: number } }',
+      )
+    }
+  })
+
+  test('behavior: widened', () => {
+    {
+      const result = AbiParameters.decode(
+        [] as AbiParameters.AbiParameters,
+        '0x',
+      )
+      attest(result).type.toString.snap('readonly unknown[]')
+    }
+
+    {
+      const result = AbiParameters.decode(
+        [] as AbiParameters.AbiParameters,
+        '0x',
+        {
+          as: 'Object',
+        },
+      )
+      attest(result).type.toString.snap('unknown')
+    }
+  })
+})

package/_test/Address.bench/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/Address.bench.d.ts",
+  "main": "../_cjs/_test/Address.bench.js",
+  "module": "../_esm/_test/Address.bench.js"
+}

package/_test/Base58.bench/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/Base58.bench.d.ts",
+  "main": "../_cjs/_test/Base58.bench.js",
+  "module": "../_esm/_test/Base58.bench.js"
+}

package/_test/Hex.bench/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/Hex.bench.d.ts",
+  "main": "../_cjs/_test/Hex.bench.js",
+  "module": "../_esm/_test/Hex.bench.js"
+}

package/_test/Hex.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/Hex.test-d.d.ts",
+  "main": "../_cjs/_test/Hex.test-d.js",
+  "module": "../_esm/_test/Hex.test-d.js"
+}

package/_test/PublicKey.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/PublicKey.test-d.d.ts",
+  "main": "../_cjs/_test/PublicKey.test-d.js",
+  "module": "../_esm/_test/PublicKey.test-d.js"
+}

package/_test/Rlp.bench/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/Rlp.bench.d.ts",
+  "main": "../_cjs/_test/Rlp.bench.js",
+  "module": "../_esm/_test/Rlp.bench.js"
+}

package/_test/Rlp.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/Rlp.test-d.d.ts",
+  "main": "../_cjs/_test/Rlp.test-d.js",
+  "module": "../_esm/_test/Rlp.test-d.js"
+}

package/_test/Signature.snap-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/Signature.snap-d.d.ts",
+  "main": "../_cjs/_test/Signature.snap-d.js",
+  "module": "../_esm/_test/Signature.snap-d.js"
+}

package/_test/Signature.snap-d.ts

@@ -0,0 +1,96 @@
+import { attest } from '@ark/attest'
+import { Hex, Signature } from 'ox'
+import { test } from 'vitest'
+
+test('default', () => {
+  const signature = Signature.from({
+    r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+    s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+    yParity: 1,
+  })
+
+  attest(signature).type.toString.snap(`{
+  readonly r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n
+  readonly s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n
+  readonly yParity: 1
+}`)
+})
+
+test('behavior: unrecovered', () => {
+  const signature = Signature.from({
+    r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+    s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+  })
+
+  attest(signature).type.toString.snap(`{
+  readonly r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n
+  readonly s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n
+}`)
+})
+
+test('behavior: legacy', () => {
+  const signature = Signature.from({
+    r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+    s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+    v: 27,
+  })
+
+  attest(signature).type.toString.snap(
+    '{ r: bigint; s: bigint; yParity: number }',
+  )
+})
+
+test('behavior: rpc', () => {
+  const signature = Signature.from({
+    r: Hex.fromNumber(
+      49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+    ),
+    s: Hex.fromNumber(
+      33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+    ),
+    yParity: Hex.fromNumber(1),
+  })
+
+  attest(signature).type.toString.snap(
+    '{ r: bigint; s: bigint; yParity: number }',
+  )
+})
+
+test('behavior: rpc legacy', () => {
+  const signature = Signature.from({
+    r: Hex.fromNumber(
+      49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+    ),
+    s: Hex.fromNumber(
+      33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+    ),
+    v: Hex.fromNumber(27),
+  })
+
+  attest(signature).type.toString.snap(
+    '{ r: bigint; s: bigint; yParity: number }',
+  )
+})
+
+test('behavior: widened', () => {
+  const signature = Signature.from({
+    r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+    s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+    yParity: 1,
+  } as Signature.Signature)
+
+  attest(signature).type.toString.snap(
+    '{ r: bigint; s: bigint; yParity: number }',
+  )
+})
+
+test('behavior: widened, unrecovered', () => {
+  const signature = Signature.from({
+    r: 49782753348462494199823712700004552394425719014458918871452329774910450607807n,
+    s: 33726695977844476214676913201140481102225469284307016937915595756355928419768n,
+  } as Signature.Signature<false>)
+
+  attest(signature).type.toString.snap(
+    '{ r: bigint; s: bigint; yParity?: undefined }',
+  )
+})

package/_test/TransactionEnvelopeEip1559.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/TransactionEnvelopeEip1559.test-d.d.ts",
+  "main": "../_cjs/_test/TransactionEnvelopeEip1559.test-d.js",
+  "module": "../_esm/_test/TransactionEnvelopeEip1559.test-d.js"
+}

package/_test/TransactionEnvelopeEip2930.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/TransactionEnvelopeEip2930.test-d.d.ts",
+  "main": "../_cjs/_test/TransactionEnvelopeEip2930.test-d.js",
+  "module": "../_esm/_test/TransactionEnvelopeEip2930.test-d.js"
+}

package/_test/TransactionEnvelopeEip4844.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/TransactionEnvelopeEip4844.test-d.d.ts",
+  "main": "../_cjs/_test/TransactionEnvelopeEip4844.test-d.js",
+  "module": "../_esm/_test/TransactionEnvelopeEip4844.test-d.js"
+}

package/_test/TransactionEnvelopeEip7702.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/TransactionEnvelopeEip7702.test-d.d.ts",
+  "main": "../_cjs/_test/TransactionEnvelopeEip7702.test-d.js",
+  "module": "../_esm/_test/TransactionEnvelopeEip7702.test-d.js"
+}

package/_test/TransactionEnvelopeLegacy.test-d/package.json

@@ -0,0 +1,6 @@
+{
+  "type": "module",
+  "types": "../_types/_test/TransactionEnvelopeLegacy.test-d.d.ts",
+  "main": "../_cjs/_test/TransactionEnvelopeLegacy.test-d.js",
+  "module": "../_esm/_test/TransactionEnvelopeLegacy.test-d.js"
+}