viem 0.0.1-alpha.14 → 0.0.1-alpha.16

package/src/utils/data/slice.test.ts

@@ -0,0 +1,203 @@
+import { expect, test } from 'vitest'
+
+import { slice, sliceBytes, sliceHex } from './slice'
+
+test('hex', () => {
+  expect(sliceHex('0x')).toMatchInlineSnapshot('"0x"')
+  expect(sliceHex('0x0123456789')).toMatchInlineSnapshot('"0x0123456789"')
+
+  expect(sliceHex('0x', 0)).toMatchInlineSnapshot('"0x"')
+  expect(sliceHex('0x0123456789', 0, 4)).toMatchInlineSnapshot('"0x01234567"')
+  expect(sliceHex('0x0123456789', 1, 4)).toMatchInlineSnapshot('"0x234567"')
+  expect(sliceHex('0x0123456789', 2, 5)).toMatchInlineSnapshot('"0x456789"')
+  expect(sliceHex('0x0123456789', 2)).toMatchInlineSnapshot('"0x456789"')
+  expect(slice('0x0123456789', 2)).toMatchInlineSnapshot('"0x456789"')
+  expect(
+    slice(
+      '0x0000000000000000000000000000000000000000000000000000000000010f2c000000000000000000000000000000000000000000000000000000000000a45500000000000000000000000000000000000000000000000000000000190f1b44',
+      33,
+      65,
+    ),
+  ).toBe('0x0000000000000000000000000000000000000000000000000000000000a45500')
+
+  expect(sliceHex('0x0123456789', -1)).toMatchInlineSnapshot('"0x89"')
+  expect(sliceHex('0x0123456789', -3, -1)).toMatchInlineSnapshot('"0x4567"')
+  expect(sliceHex('0x0123456789', -5)).toMatchInlineSnapshot('"0x0123456789"')
+  expect(slice('0x0123456789', -5)).toMatchInlineSnapshot('"0x0123456789"')
+
+  expect(sliceHex('0x0123456789', 0, 10)).toMatchInlineSnapshot(
+    '"0x0123456789"',
+  )
+  expect(sliceHex('0x0123456789', -10)).toMatchInlineSnapshot('"0x0123456789"')
+
+  expect(() => sliceHex('0x0123456789', 5)).toThrowErrorMatchingInlineSnapshot(
+    '"Slice starting at offset \\"5\\" is out-of-bounds (size: 5)."',
+  )
+})
+
+test('bytes', () => {
+  expect(sliceBytes(new Uint8Array([]))).toMatchInlineSnapshot('Uint8Array []')
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])),
+  ).toMatchInlineSnapshot(`
+    Uint8Array [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+    ]
+  `)
+
+  expect(sliceBytes(new Uint8Array([]), 0)).toMatchInlineSnapshot(
+    'Uint8Array []',
+  )
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 0, 4),
+  ).toMatchInlineSnapshot(`
+    Uint8Array [
+      0,
+      1,
+      2,
+      3,
+    ]
+  `)
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 2, 8),
+  ).toMatchInlineSnapshot(`
+      Uint8Array [
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+      ]
+    `)
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 5, 9),
+  ).toMatchInlineSnapshot(`
+      Uint8Array [
+        5,
+        6,
+        7,
+        8,
+      ]
+    `)
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 2),
+  ).toMatchInlineSnapshot(`
+    Uint8Array [
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+    ]
+  `)
+  expect(
+    slice(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 2),
+  ).toMatchInlineSnapshot(`
+    Uint8Array [
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+    ]
+  `)
+
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -1),
+  ).toMatchInlineSnapshot(`
+    Uint8Array [
+      9,
+    ]
+  `)
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -3, -1),
+  ).toMatchInlineSnapshot(`
+    Uint8Array [
+      7,
+      8,
+    ]
+  `)
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -8),
+  ).toMatchInlineSnapshot(`
+      Uint8Array [
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+      ]
+    `)
+  expect(
+    slice(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -8),
+  ).toMatchInlineSnapshot(`
+      Uint8Array [
+        2,
+        3,
+        4,
+        5,
+        6,
+        7,
+        8,
+        9,
+      ]
+    `)
+
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 0, 10),
+  ).toMatchInlineSnapshot(`
+    Uint8Array [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+    ]
+  `)
+  expect(
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), -10),
+  ).toMatchInlineSnapshot(`
+    Uint8Array [
+      0,
+      1,
+      2,
+      3,
+      4,
+      5,
+      6,
+      7,
+      8,
+      9,
+    ]
+  `)
+
+  expect(() =>
+    sliceBytes(new Uint8Array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]), 10),
+  ).toThrowErrorMatchingInlineSnapshot(
+    '"Slice starting at offset \\"10\\" is out-of-bounds (size: 10)."',
+  )
+})

package/src/utils/data/slice.ts

@@ -0,0 +1,60 @@
+import type { ByteArray, Hex } from '../../types'
+import { isHex } from './isHex'
+import { size } from './size'
+
+type SliceResult<TValue extends ByteArray | Hex> = TValue extends Hex
+  ? Hex
+  : ByteArray
+
+/**
+ * @description Returns a section of the hex or byte array given a start/end bytes offset.
+ *
+ * @param value The hex or byte array to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+export function slice<TValue extends ByteArray | Hex>(
+  value: TValue,
+  start?: number,
+  end?: number,
+): SliceResult<TValue> {
+  if (isHex(value))
+    return sliceHex(value as Hex, start, end) as SliceResult<TValue>
+  return sliceBytes(value as ByteArray, start, end) as SliceResult<TValue>
+}
+
+function assertStartOffset(value: Hex | ByteArray, start?: number) {
+  if (typeof start === 'number' && start > 0 && start > size(value) - 1)
+    throw new Error(
+      `Slice starting at offset "${start}" is out-of-bounds (size: ${size(
+        value,
+      )}).`,
+    )
+}
+
+/**
+ * @description Returns a section of the byte array given a start/end bytes offset.
+ *
+ * @param value The byte array to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+export function sliceBytes(value: ByteArray, start?: number, end?: number) {
+  assertStartOffset(value, start)
+  return value.slice(start, end)
+}
+
+/**
+ * @description Returns a section of the hex value given a start/end bytes offset.
+ *
+ * @param value The hex value to slice.
+ * @param start The start offset (in bytes).
+ * @param end The end offset (in bytes).
+ */
+export function sliceHex(value_: Hex, start?: number, end?: number) {
+  assertStartOffset(value_, start)
+  const value = value_
+    .replace('0x', '')
+    .slice((start ?? 0) * 2, (end ?? value_.length) * 2)
+  return `0x${value}`
+}

package/src/utils/data/trim.bench.ts

@@ -0,0 +1,50 @@
+import { hexStripZeros, stripZeros } from 'ethers/lib/utils'
+import {
+  hexStripZeros as hexStripZeros2,
+  stripZeros as stripZeros2,
+} from 'essential-eth'
+
+import { bench, describe } from 'vitest'
+
+import { trim } from './trim'
+
+describe('Trim Hex', () => {
+  bench('viem: `trimHex`', () => {
+    trim('0x00000000000000000000000a4e12a45')
+  })
+
+  bench('ethers: `hexStripZeros`', () => {
+    hexStripZeros('0x00000000000000000000000a4e12a45')
+  })
+
+  bench('essential-eth: `hexStripZeros`', () => {
+    hexStripZeros2('0x00000000000000000000000a4e12a45')
+  })
+})
+
+describe('Trim Bytes', () => {
+  bench('viem: `trimBytes`', () => {
+    trim(
+      new Uint8Array([
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 122, 51, 123,
+      ]),
+    )
+  })
+
+  bench('ethers: `stripZeros`', () => {
+    stripZeros(
+      new Uint8Array([
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 122, 51,
+        123,
+      ]),
+    )
+  })
+
+  bench('essential-eth: `stripZeros`', () => {
+    stripZeros2(
+      new Uint8Array([
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 122, 51, 123,
+      ]),
+    )
+  })
+})

package/src/utils/data/trim.test.ts

@@ -0,0 +1,175 @@
+import { describe, expect, test } from 'vitest'
+
+import { trim } from './trim'
+
+test('default', () => {
+  expect(trim('0x000000')).toMatchInlineSnapshot('"0x0"')
+  expect(trim(new Uint8Array([0, 0, 0, 0, 0]))).toMatchInlineSnapshot(
+    `
+    Uint8Array [
+      0,
+    ]
+  `,
+  )
+
+  expect(
+    trim('0x00000000000000000000000000000000000000000000000000000000a4e12a45'),
+  ).toMatchInlineSnapshot('"0xa4e12a45"')
+
+  expect(
+    trim(
+      new Uint8Array([
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 1, 122, 51, 123,
+      ]),
+    ),
+  ).toMatchInlineSnapshot(
+    `
+    Uint8Array [
+      1,
+      122,
+      51,
+      123,
+    ]
+  `,
+  )
+})
+
+describe('hex', () => {
+  test('default', () => {
+    expect(
+      trim(
+        '0x0000000000000000000000000000000000000000000000000000000000000001',
+      ),
+    ).toMatchInlineSnapshot('"0x1"')
+
+    expect(
+      trim(
+        '0x00000000000000000000000000000000000000000000000000000000a4e12a45',
+      ),
+    ).toMatchInlineSnapshot('"0xa4e12a45"')
+
+    expect(
+      trim(
+        '0x00000000000000000000000000000000000000000000000000000001a4e12a45',
+      ),
+    ).toMatchInlineSnapshot('"0x1a4e12a45"')
+  })
+
+  test('args: dir', () => {
+    expect(
+      trim(
+        '0x1000000000000000000000000000000000000000000000000000000000000000',
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot('"0x10"')
+
+    expect(
+      trim(
+        '0xa4e12a4500000000000000000000000000000000000000000000000000000000',
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot('"0xa4e12a45"')
+
+    expect(
+      trim(
+        '0x1a4e12a450000000000000000000000000000000000000000000000000000000',
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot('"0x1a4e12a45"')
+  })
+})
+
+describe('bytes', () => {
+  test('default', () => {
+    expect(
+      trim(
+        new Uint8Array([
+          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 0, 0, 0, 1,
+        ]),
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+      ]
+    `,
+    )
+
+    expect(
+      trim(
+        new Uint8Array([
+          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 1, 122, 51, 123,
+        ]),
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+        122,
+        51,
+        123,
+      ]
+    `,
+    )
+  })
+
+  test('args: dir', () => {
+    expect(
+      trim(
+        new Uint8Array([
+          1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ]),
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+      ]
+    `,
+    )
+
+    expect(
+      trim(
+        new Uint8Array([
+          1, 122, 51, 123, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ]),
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+        122,
+        51,
+        123,
+      ]
+    `,
+    )
+
+    expect(
+      trim(
+        new Uint8Array([
+          1, 122, 51, 123, 11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+          0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        ]),
+        { dir: 'right' },
+      ),
+    ).toMatchInlineSnapshot(
+      `
+      Uint8Array [
+        1,
+        122,
+        51,
+        123,
+        11,
+      ]
+    `,
+    )
+  })
+})

package/src/utils/data/trim.ts

@@ -0,0 +1,33 @@
+import type { ByteArray, Hex } from '../../types'
+
+type TrimOptions = {
+  dir?: 'left' | 'right'
+}
+type TrimResult<TValue extends ByteArray | Hex> = TValue extends Hex
+  ? Hex
+  : ByteArray
+
+export function trim<TValue extends ByteArray | Hex>(
+  hexOrBytes: TValue,
+  { dir = 'left' }: TrimOptions = {},
+): TrimResult<TValue> {
+  let data: any =
+    typeof hexOrBytes === 'string' ? hexOrBytes.replace('0x', '') : hexOrBytes
+
+  let sliceLength = 0
+  for (let i = 0; i < data.length - 1; i++) {
+    if (data[dir === 'left' ? i : data.length - i - 1].toString() === '0')
+      sliceLength++
+    else break
+  }
+  data =
+    dir === 'left'
+      ? data.slice(sliceLength)
+      : data.slice(0, data.length - sliceLength)
+
+  if (typeof hexOrBytes === 'string') {
+    if (data.length === 1 && dir === 'right') data = `${data}0`
+    return `0x${data}` as TrimResult<TValue>
+  }
+  return data as TrimResult<TValue>
+}

package/src/utils/encoding/decodeBytes.bench.ts

@@ -0,0 +1,40 @@
+import { hexlify, toUtf8String } from 'ethers/lib/utils'
+
+import { bench, describe } from 'vitest'
+import Web3 from 'web3'
+
+import { bytesToHex, bytesToString } from './decodeBytes'
+
+describe('Bytes to Hex', () => {
+  bench('viem: `bytesToHex`', () => {
+    bytesToHex(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    )
+  })
+
+  bench('ethers: `hexlify`', () => {
+    hexlify(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    )
+  })
+
+  bench('web3.js: `bytesToHex`', () => {
+    Web3.utils.bytesToHex([
+      72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33,
+    ])
+  })
+})
+
+describe('Bytes to String', () => {
+  bench('viem: `bytesToString`', () => {
+    bytesToString(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    )
+  })
+
+  bench('ethers: `toUtf8String`', () => {
+    toUtf8String(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    )
+  })
+})

package/src/utils/encoding/decodeBytes.test.ts

@@ -0,0 +1,144 @@
+import { expect, test } from 'vitest'
+
+import {
+  bytesToBigint,
+  bytesToBool,
+  bytesToHex,
+  bytesToNumber,
+  bytesToString,
+  decodeBytes,
+} from './decodeBytes'
+
+test('converts bytes to number', () => {
+  expect(decodeBytes(new Uint8Array([0]), 'number')).toMatchInlineSnapshot('0')
+  expect(decodeBytes(new Uint8Array([7]), 'number')).toMatchInlineSnapshot('7')
+  expect(decodeBytes(new Uint8Array([69]), 'number')).toMatchInlineSnapshot(
+    '69',
+  )
+  expect(decodeBytes(new Uint8Array([1, 164]), 'number')).toMatchInlineSnapshot(
+    '420',
+  )
+
+  expect(bytesToNumber(new Uint8Array([0]))).toMatchInlineSnapshot('0')
+  expect(bytesToNumber(new Uint8Array([7]))).toMatchInlineSnapshot('7')
+  expect(bytesToNumber(new Uint8Array([69]))).toMatchInlineSnapshot('69')
+  expect(bytesToNumber(new Uint8Array([1, 164]))).toMatchInlineSnapshot('420')
+})
+
+test('converts bytes to bigint', () => {
+  expect(decodeBytes(new Uint8Array([0]), 'bigint')).toMatchInlineSnapshot('0n')
+  expect(decodeBytes(new Uint8Array([7]), 'bigint')).toMatchInlineSnapshot('7n')
+  expect(decodeBytes(new Uint8Array([69]), 'bigint')).toMatchInlineSnapshot(
+    '69n',
+  )
+  expect(decodeBytes(new Uint8Array([1, 164]), 'bigint')).toMatchInlineSnapshot(
+    '420n',
+  )
+  expect(
+    decodeBytes(
+      new Uint8Array([
+        12, 92, 243, 146, 17, 135, 111, 181, 229, 136, 67, 39, 250, 86, 252, 11,
+        117,
+      ]),
+      'bigint',
+    ),
+  ).toMatchInlineSnapshot('4206942069420694206942069420694206942069n')
+
+  expect(bytesToBigint(new Uint8Array([0]))).toMatchInlineSnapshot('0n')
+  expect(bytesToBigint(new Uint8Array([7]))).toMatchInlineSnapshot('7n')
+  expect(bytesToBigint(new Uint8Array([69]))).toMatchInlineSnapshot('69n')
+  expect(bytesToBigint(new Uint8Array([1, 164]))).toMatchInlineSnapshot('420n')
+  expect(
+    bytesToBigint(
+      new Uint8Array([
+        12, 92, 243, 146, 17, 135, 111, 181, 229, 136, 67, 39, 250, 86, 252, 11,
+        117,
+      ]),
+    ),
+  ).toMatchInlineSnapshot('4206942069420694206942069420694206942069n')
+})
+
+test('converts bytes to boolean', () => {
+  expect(decodeBytes(new Uint8Array([0]), 'boolean')).toMatchInlineSnapshot(
+    'false',
+  )
+  expect(decodeBytes(new Uint8Array([1]), 'boolean')).toMatchInlineSnapshot(
+    'true',
+  )
+
+  expect(bytesToBool(new Uint8Array([0]))).toMatchInlineSnapshot('false')
+  expect(bytesToBool(new Uint8Array([1]))).toMatchInlineSnapshot('true')
+
+  expect(() =>
+    bytesToBool(new Uint8Array([69])),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Bytes value \\"69\\" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.
+
+    Version: viem@1.0.2"
+  `)
+  expect(() =>
+    bytesToBool(new Uint8Array([1, 2])),
+  ).toThrowErrorMatchingInlineSnapshot(`
+    "Bytes value \\"1,2\\" is not a valid boolean. The bytes array must contain a single byte of either a 0 or 1 value.
+
+    Version: viem@1.0.2"
+  `)
+})
+
+test('converts bytes to string', () => {
+  expect(decodeBytes(new Uint8Array([]), 'string')).toMatchInlineSnapshot(`""`)
+  expect(decodeBytes(new Uint8Array([97]), 'string')).toMatchInlineSnapshot(
+    `"a"`,
+  )
+  expect(
+    decodeBytes(new Uint8Array([97, 98, 99]), 'string'),
+  ).toMatchInlineSnapshot(`"abc"`)
+  expect(
+    decodeBytes(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+      'string',
+    ),
+  ).toMatchInlineSnapshot(`"Hello World!"`)
+
+  expect(bytesToString(new Uint8Array([]))).toMatchInlineSnapshot(`""`)
+  expect(bytesToString(new Uint8Array([97]))).toMatchInlineSnapshot(`"a"`)
+  expect(bytesToString(new Uint8Array([97, 98, 99]))).toMatchInlineSnapshot(
+    `"abc"`,
+  )
+  expect(
+    bytesToString(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    ),
+  ).toMatchInlineSnapshot(`"Hello World!"`)
+})
+
+test('converts bytes to hex', () => {
+  expect(
+    decodeBytes(new Uint8Array([97, 98, 99]), 'hex'),
+  ).toMatchInlineSnapshot('"0x616263"')
+  expect(decodeBytes(new Uint8Array([97]), 'hex')).toMatchInlineSnapshot(
+    '"0x61"',
+  )
+  expect(
+    decodeBytes(new Uint8Array([97, 98, 99]), 'hex'),
+  ).toMatchInlineSnapshot('"0x616263"')
+  expect(
+    decodeBytes(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+      'hex',
+    ),
+  ).toMatchInlineSnapshot('"0x48656c6c6f20576f726c6421"')
+
+  expect(bytesToHex(new Uint8Array([97, 98, 99]))).toMatchInlineSnapshot(
+    '"0x616263"',
+  )
+  expect(bytesToHex(new Uint8Array([97]))).toMatchInlineSnapshot('"0x61"')
+  expect(bytesToHex(new Uint8Array([97, 98, 99]))).toMatchInlineSnapshot(
+    '"0x616263"',
+  )
+  expect(
+    bytesToHex(
+      new Uint8Array([72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100, 33]),
+    ),
+  ).toMatchInlineSnapshot('"0x48656c6c6f20576f726c6421"')
+})