@subsquid/evm-codec 0.3.0 → 1.0.0

package/src/src/bytes.test.ts

@@ -0,0 +1,114 @@
+import {describe, expect, it} from 'vitest'
+import {BytesSink, BytesSrc} from '..'
+
+describe('src', () => {
+  it('negative numbers', () => {
+    const sink = new BytesSink(6)
+    sink.i8(-1)
+    sink.i16(-123)
+    sink.i32(-123456)
+    sink.i64(-1234567890n)
+    sink.i128(-12345678901234567890n)
+    sink.i256(-1234567890123456789012345678901234567890n)
+
+    const src = new BytesSrc(sink.result())
+    expect(src.i8()).toBe(-1)
+    expect(src.i16()).toBe(-123)
+    expect(src.i32()).toBe(-123456)
+    expect(src.i64()).toBe(-1234567890n)
+    expect(src.i128()).toBe(-12345678901234567890n)
+    expect(src.i256()).toBe(-1234567890123456789012345678901234567890n)
+  })
+
+  it('positive signed numbers', () => {
+    const sink = new BytesSink(6)
+    sink.i8(1)
+    sink.i16(123)
+    sink.i32(123456)
+    sink.i64(1234567890n)
+    sink.i128(12345678901234567890n)
+    sink.i256(1234567890123456789012345678901234567890n)
+
+    const src = new BytesSrc(sink.result())
+    expect(src.i8()).toBe(1)
+    expect(src.i16()).toBe(123)
+    expect(src.i32()).toBe(123456)
+    expect(src.i64()).toBe(1234567890n)
+    expect(src.i128()).toBe(12345678901234567890n)
+    expect(src.i256()).toBe(1234567890123456789012345678901234567890n)
+  })
+
+  it('mixed static types', () => {
+    const sink = new BytesSink(4)
+    sink.u8(1)
+    sink.i8(-2)
+    sink.address('0x1234567890123456789012345678901234567890')
+    sink.u256(3n)
+
+    const src = new BytesSrc(sink.result())
+    expect(src.u8()).toBe(1)
+    expect(src.i8()).toBe(-2)
+    expect(src.address()).toBe('0x1234567890123456789012345678901234567890')
+    expect(src.u256()).toBe(3n)
+  })
+
+  it('mixed dynamic types', () => {
+    const str1 = 'abc'.repeat(100)
+    const bytes1 = Buffer.alloc(100).fill('321')
+    const bytes7 = Buffer.from('1234567890abcd', 'hex')
+    const str2 = 'hello'
+    const addressValue = '0xabc4567890123456789012345678901234567890'
+
+    // Build a 7-field ABI-encoded tuple: each dynamic field (string/bytes) gets its
+    // own head slot (openTail writes the pointer) + tail data, while static fields
+    // (u8, staticBytes, i128, address) are written directly into the head.
+    const sink = new BytesSink(7)
+    sink.u8(69)
+    sink.openTail()
+    sink.string(str1)
+    sink.closeTail()
+    sink.staticBytes(7, bytes7)
+    sink.i128(-21312312452243312424534213123123123123n)
+    sink.openTail()
+    sink.bytes(bytes1)
+    sink.closeTail()
+    sink.address(addressValue)
+    sink.openTail()
+    sink.string(str2)
+    sink.closeTail()
+
+    const src = new BytesSrc(sink.result())
+    expect(src.u8()).toBe(69)
+    expect(src.string()).toBe(str1)
+    expect(src.staticBytes(7)).toStrictEqual(new Uint8Array(bytes7))
+    expect(src.i128()).toBe(-21312312452243312424534213123123123123n)
+    expect(src.bytes()).toStrictEqual(new Uint8Array(bytes1))
+    expect(src.address()).toBe(addressValue)
+    expect(src.string()).toBe(str2)
+  })
+
+  describe('string', () => {
+    function testString(str: string) {
+      const sink = new BytesSink(1)
+      sink.openTail()
+      sink.string(str)
+      sink.closeTail()
+      expect(new BytesSrc(sink.result()).string()).toBe(str)
+    }
+
+    it('short string', () => testString('hello'))
+    it('32 byte string', () => testString('this string length is 32 bytes!!'))
+    it('longer string', () => testString('this string length is 33 bytes!!!'))
+    it('UTF', () => testString('привет 👍'))
+  })
+
+  it('bytes', () => {
+    const buffer = Buffer.alloc(150)
+    buffer.fill('xd')
+    const sink = new BytesSink(1)
+    sink.openTail()
+    sink.bytes(buffer)
+    sink.closeTail()
+    expect(new BytesSrc(sink.result()).bytes()).toStrictEqual(new Uint8Array(buffer))
+  })
+})

package/src/src/bytes.ts

@@ -0,0 +1,187 @@
+import {WORD_SIZE, type Src} from '../codec'
+import {toHex} from '@subsquid/util-internal-hex'
+
+const I64_SIGN_BIT = 1n << 63n
+const I64_RANGE = 1n << 64n
+const I128_SIGN_BIT = 1n << 127n
+const I128_RANGE = 1n << 128n
+const I256_SIGN_BIT = 1n << 255n
+const I256_RANGE = 1n << 256n
+
+const TEXT_DECODER = new TextDecoder('utf-8')
+
+export class BytesSrc implements Src {
+    private view: DataView
+    private pos = 0
+    private oldPos = 0
+
+    constructor(private buf: Uint8Array) {
+        this.view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength)
+    }
+
+    slice(start: number, end?: number): BytesSrc {
+        return new BytesSrc(this.buf.subarray(start, end))
+    }
+
+    u8(): number {
+        this.pos += WORD_SIZE - 1
+        let val = this.view.getUint8(this.pos)
+        this.pos += 1
+        return val
+    }
+
+    i8(): number {
+        return Number(this.i256())
+    }
+
+    u16(): number {
+        this.pos += WORD_SIZE - 2
+        let val = this.view.getUint16(this.pos, false)
+        this.pos += 2
+        return val
+    }
+
+    i16(): number {
+        return Number(this.i256())
+    }
+
+    u32(): number {
+        this.pos += WORD_SIZE - 4
+        let val = this.view.getUint32(this.pos, false)
+        this.pos += 4
+        return val
+    }
+
+    i32(): number {
+        return Number(this.i256())
+    }
+
+    u64(): bigint {
+        this.pos += WORD_SIZE - 8
+        return this.#u64()
+    }
+
+    #u64(): bigint {
+        let val = this.view.getBigUint64(this.pos, false)
+        this.pos += 8
+        return val
+    }
+
+    i64(): bigint {
+        this.pos += WORD_SIZE - 8
+        const raw = this.#u64()
+        return raw < I64_SIGN_BIT ? raw : raw - I64_RANGE
+    }
+
+    u128(): bigint {
+        this.pos += WORD_SIZE - 16
+        return this.#u128()
+    }
+
+    #u128(): bigint {
+        const hi = this.view.getBigUint64(this.pos, false)
+        const lo = this.view.getBigUint64(this.pos + 8, false)
+        this.pos += 16
+        return (hi << 64n) | lo
+    }
+
+    i128(): bigint {
+        this.pos += WORD_SIZE - 16
+        const raw = this.#u128()
+        return raw < I128_SIGN_BIT ? raw : raw - I128_RANGE
+    }
+
+    u256(): bigint {
+        const hi = this.#u128()
+        const lo = this.#u128()
+        return (hi << 128n) | lo
+    }
+
+    i256(): bigint {
+        const hi = this.#u128()
+        const lo = this.#u128()
+        const raw = (hi << 128n) | lo
+        return raw < I256_SIGN_BIT ? raw : raw - I256_RANGE
+    }
+
+    address(): string {
+        const start = this.pos + WORD_SIZE - 20
+        this.pos += WORD_SIZE
+        return toHex(this.buf, start, 20)
+    }
+
+    bytes(): Uint8Array {
+        const ptr = this.u32()
+        this.jump(ptr)
+        const len = Number(this.u256())
+        this.#assertLength(len, 'bytes')
+        const val = this.buf.subarray(this.pos, this.pos + len)
+        this.jumpBack()
+        return val
+    }
+
+    bytesHex(): string {
+        const ptr = this.u32()
+        this.jump(ptr)
+        const len = Number(this.u256())
+        this.#assertLength(len, 'bytes')
+        const val = toHex(this.buf, this.pos, len)
+        this.jumpBack()
+        return val
+    }
+
+    staticBytes(len: number): Uint8Array {
+        if (len > 32) {
+            throw new Error(`bytes${len} is not a valid type`)
+        }
+        const val = this.buf.subarray(this.pos, this.pos + len)
+        this.pos += WORD_SIZE
+        return val
+    }
+
+    staticBytesHex(len: number): string {
+        if (len > 32) {
+            throw new Error(`bytes${len} is not a valid type`)
+        }
+        const start = this.pos
+        this.pos += WORD_SIZE
+        return toHex(this.buf, start, len)
+    }
+
+    string(): string {
+        const ptr = this.u32()
+        this.jump(ptr, 'string')
+        const len = Number(this.u256())
+        this.#assertLength(len, 'string')
+        const val = TEXT_DECODER.decode(this.buf.subarray(this.pos, this.pos + len))
+        this.jumpBack()
+        return val
+    }
+
+    bool(): boolean {
+        return !!this.u8()
+    }
+
+    #assertLength(len: number, typeName: string): void {
+        if (this.buf.length - this.pos < len) {
+            throw new RangeError(
+                `Unexpected end of input. Attempting to read ${typeName} of length ${len} from ${toHex(this.buf)}`,
+            )
+        }
+    }
+
+    jump(pos: number, typeName?: string): void {
+        if (pos < 0 || pos >= this.buf.length) {
+            const what = typeName ? `${typeName} ` : ''
+            throw new RangeError(
+                `Unexpected pointer location: 0x${pos.toString(16)}. Attempting to read ${what}from ${toHex(this.buf)}`,
+            )
+        }
+        this.oldPos = this.pos
+        this.pos = pos
+    }
+
+    jumpBack(): void {
+        this.pos = this.oldPos
+    }
+}

package/src/src/hex.ts

@@ -0,0 +1,191 @@
+import {WORD_SIZE, type Src} from '../codec'
+
+const HEX_BYTE = 2
+const WORD_HEX = WORD_SIZE * HEX_BYTE
+
+const I64_SIGN_BIT = 1n << 63n
+const I64_RANGE = 1n << 64n
+const I128_SIGN_BIT = 1n << 127n
+const I128_RANGE = 1n << 128n
+const I256_SIGN_BIT = 1n << 255n
+const I256_RANGE = 1n << 256n
+
+const TEXT_DECODER = new TextDecoder('utf-8')
+
+export class HexSrc implements Src {
+    private readonly buf: string
+    private readonly base: number
+    private readonly endChar: number
+    private pos: number
+    private oldPos: number
+
+    constructor(hex: string, strOffset = 2, strEnd: number = hex.length) {
+        this.buf = hex
+        this.base = strOffset
+        this.endChar = strEnd
+        this.pos = strOffset
+        this.oldPos = strOffset
+    }
+
+    slice(start: number, end?: number): HexSrc {
+        const s = this.base + HEX_BYTE * start
+        const e = end == null ? this.endChar : this.base + HEX_BYTE * end
+        return new HexSrc(this.buf, s, e)
+    }
+
+    u8(): number {
+        const start = this.pos + WORD_HEX - 2
+        const val = Number.parseInt(this.buf.slice(start, start + 2), 16)
+        this.pos += WORD_HEX
+        return val
+    }
+
+    i8(): number {
+        return Number(this.i256())
+    }
+
+    u16(): number {
+        const start = this.pos + WORD_HEX - 4
+        const val = Number.parseInt(this.buf.slice(start, start + 4), 16)
+        this.pos += WORD_HEX
+        return val
+    }
+
+    i16(): number {
+        return Number(this.i256())
+    }
+
+    u32(): number {
+        const start = this.pos + WORD_HEX - 8
+        const val = Number.parseInt(this.buf.slice(start, start + 8), 16)
+        this.pos += WORD_HEX
+        return val
+    }
+
+    i32(): number {
+        return Number(this.i256())
+    }
+
+    u64(): bigint {
+        const start = this.pos + WORD_HEX - 16
+        const val = BigInt(`0x${this.buf.slice(start, start + 16)}`)
+        this.pos += WORD_HEX
+        return val
+    }
+
+    i64(): bigint {
+        const raw = this.u64()
+        return raw < I64_SIGN_BIT ? raw : raw - I64_RANGE
+    }
+
+    u128(): bigint {
+        const start = this.pos + WORD_HEX - 32
+        const val = BigInt(`0x${this.buf.slice(start, start + 32)}`)
+        this.pos += WORD_HEX
+        return val
+    }
+
+    i128(): bigint {
+        const raw = this.u128()
+        return raw < I128_SIGN_BIT ? raw : raw - I128_RANGE
+    }
+
+    u256(): bigint {
+        const val = BigInt(`0x${this.buf.slice(this.pos, this.pos + WORD_HEX)}`)
+        this.pos += WORD_HEX
+        return val
+    }
+
+    i256(): bigint {
+        const raw = this.u256()
+        return raw < I256_SIGN_BIT ? raw : raw - I256_RANGE
+    }
+
+    address(): string {
+        const start = this.pos + WORD_HEX - 40
+        const val = `0x${this.buf.slice(start, start + 40)}`
+        this.pos += WORD_HEX
+        return val
+    }
+
+    bytes(): Uint8Array {
+        const ptr = this.u32()
+        this.jump(ptr)
+        const len = Number(this.u256())
+        this.#assertLength(len, 'bytes')
+        const sub = this.buf.slice(this.pos, this.pos + HEX_BYTE * len)
+        const val = Buffer.from(sub, 'hex')
+        this.jumpBack()
+        return val
+    }
+
+    bytesHex(): string {
+        const ptr = this.u32()
+        this.jump(ptr)
+        const len = Number(this.u256())
+        this.#assertLength(len, 'bytes')
+        const val = `0x${this.buf.slice(this.pos, this.pos + HEX_BYTE * len)}`
+        this.jumpBack()
+        return val
+    }
+
+    staticBytes(len: number): Uint8Array {
+        if (len > 32) {
+            throw new Error(`bytes${len} is not a valid type`)
+        }
+        const sub = this.buf.slice(this.pos, this.pos + HEX_BYTE * len)
+        this.pos += WORD_HEX
+        return Buffer.from(sub, 'hex')
+    }
+
+    staticBytesHex(len: number): string {
+        if (len > 32) {
+            throw new Error(`bytes${len} is not a valid type`)
+        }
+        const val = `0x${this.buf.slice(this.pos, this.pos + HEX_BYTE * len)}`
+        this.pos += WORD_HEX
+        return val
+    }
+
+    string(): string {
+        const ptr = this.u32()
+        this.jump(ptr, 'string')
+        const len = Number(this.u256())
+        this.#assertLength(len, 'string')
+        const sub = this.buf.slice(this.pos, this.pos + HEX_BYTE * len)
+        const val = TEXT_DECODER.decode(Buffer.from(sub, 'hex'))
+        this.jumpBack()
+        return val
+    }
+
+    bool(): boolean {
+        const a = this.buf.charCodeAt(this.pos + WORD_HEX - 2)
+        const b = this.buf.charCodeAt(this.pos + WORD_HEX - 1)
+        this.pos += WORD_HEX
+        return a !== 48 /* '0' */ || b !== 48
+    }
+
+    #assertLength(len: number, typeName: string): void {
+        if (this.endChar - this.pos < HEX_BYTE * len) {
+            throw new RangeError(
+                `Unexpected end of input. Attempting to read ${typeName} of length ${len} from 0x${this.buf.slice(this.base, this.endChar)}`,
+            )
+        }
+    }
+
+    jump(pos: number, typeName?: string): void {
+        const target = this.base + HEX_BYTE * pos
+        if (pos < 0 || target >= this.endChar) {
+            const what = typeName ? `${typeName} ` : ''
+            throw new RangeError(
+                `Unexpected pointer location: 0x${pos.toString(16)}. Attempting to read ${what}from 0x${this.buf.slice(this.base, this.endChar)}`,
+            )
+        }
+        this.oldPos = this.pos
+        this.pos = target
+    }
+
+    jumpBack(): void {
+        this.pos = this.oldPos
+    }
+}

package/src/util.ts

@@ -0,0 +1,19 @@
+export type Pretty<T> = {[K in keyof T]: T[K]} & unknown
+
+export function propName(prop: string): string {
+    if (isValidProperty(prop)) {
+        return prop
+    }
+    return `[${JSON.stringify(prop)}]`
+}
+
+export function propAccess(prop: string): string {
+    if (isValidProperty(prop)) {
+        return `.${prop}`
+    }
+    return `[${JSON.stringify(prop)}]`
+}
+
+function isValidProperty(s: string): boolean {
+    return /^[a-zA-Z_$][0-9a-zA-Z_$]*$/.test(s)
+}

package/lib/safeToNumber.d.ts

@@ -1,2 +0,0 @@
-export declare function safeToNumber(value: number | bigint): number;
-//# sourceMappingURL=safeToNumber.d.ts.map

package/lib/safeToNumber.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"safeToNumber.d.ts","sourceRoot":"","sources":["../src/safeToNumber.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAK3D"}

package/lib/safeToNumber.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.safeToNumber = void 0;
-function safeToNumber(value) {
-    if (value < Number.MIN_SAFE_INTEGER || value > Number.MAX_SAFE_INTEGER) {
-        throw new Error(`${value} is not a safe integer`);
-    }
-    return Number(value);
-}
-exports.safeToNumber = safeToNumber;
-//# sourceMappingURL=safeToNumber.js.map

package/lib/safeToNumber.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"safeToNumber.js","sourceRoot":"","sources":["../src/safeToNumber.ts"],"names":[],"mappings":";;;AAAA,SAAgB,YAAY,CAAC,KAAsB;IACjD,IAAK,KAAK,GAAG,MAAM,CAAC,gBAAgB,IAAI,KAAK,GAAG,MAAM,CAAC,gBAAgB,EAAE,CAAC;QACxE,MAAM,IAAI,KAAK,CAAC,GAAG,KAAK,wBAAwB,CAAC,CAAA;IACnD,CAAC;IACD,OAAO,MAAM,CAAC,KAAK,CAAC,CAAA;AACtB,CAAC;AALD,oCAKC"}

package/lib/sink.d.ts

@@ -1,43 +0,0 @@
-/// <reference types="node" />
-export declare class Sink {
-    #private;
-    private pos;
-    private buf;
-    private view;
-    private stack;
-    constructor(fields: number, capacity?: number);
-    result(): Buffer;
-    toString(): string;
-    reserve(additional: number): void;
-    size(): number;
-    private _allocate;
-    private checkNumberBounds;
-    u8(val: number): void;
-    i8(val: number): void;
-    u16(val: number): void;
-    i16(val: number): void;
-    u32(val: number): void;
-    i32(val: number): void;
-    u64(val: bigint): void;
-    i64(val: bigint): void;
-    u128(val: bigint): void;
-    i128(val: bigint): void;
-    u256(val: bigint): void;
-    i256(val: bigint): void;
-    bytes(val: Uint8Array): void;
-    staticBytes(len: number, val: Uint8Array): void;
-    address(val: string): void;
-    string(val: string): void;
-    bool(val: boolean): void;
-    /**
-     * @example
-     * @link [Solidity docs](https://docs.soliditylang.org/en/latest/abi-spec.html#use-of-dynamic-types)
-     */
-    newStaticDataArea(slotsCount?: number): void;
-    newDynamicDataArea(slotsCount: number): void;
-    private currentDataAreaStart;
-    increaseCurrentDataAreaSize(amount: number): void;
-    private pushDataArea;
-    endCurrentDataArea(): void;
-}
-//# sourceMappingURL=sink.d.ts.map

package/lib/sink.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"sink.d.ts","sourceRoot":"","sources":["../src/sink.ts"],"names":[],"mappings":";AAGA,qBAAa,IAAI;;IACf,OAAO,CAAC,GAAG,CAAI;IACf,OAAO,CAAC,GAAG,CAAQ;IACnB,OAAO,CAAC,IAAI,CAAU;IACtB,OAAO,CAAC,KAAK,CAA6D;gBAC9D,MAAM,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAa;IAUnD,MAAM,IAAI,MAAM;IAKhB,QAAQ;IAIR,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAMjC,IAAI;IAIJ,OAAO,CAAC,SAAS;IAQjB,OAAO,CAAC,iBAAiB;IAMzB,EAAE,CAAC,GAAG,EAAE,MAAM;IAQd,EAAE,CAAC,GAAG,EAAE,MAAM;IAKd,GAAG,CAAC,GAAG,EAAE,MAAM;IAQf,GAAG,CAAC,GAAG,EAAE,MAAM;IAKf,GAAG,CAAC,GAAG,EAAE,MAAM;IAQf,GAAG,CAAC,GAAG,EAAE,MAAM;IAKf,GAAG,CAAC,GAAG,EAAE,MAAM;IAQf,GAAG,CAAC,GAAG,EAAE,MAAM;IAUf,IAAI,CAAC,GAAG,EAAE,MAAM;IAQhB,IAAI,CAAC,GAAG,EAAE,MAAM;IAWhB,IAAI,CAAC,GAAG,EAAE,MAAM;IAOhB,IAAI,CAAC,GAAG,EAAE,MAAM;IAiBhB,KAAK,CAAC,GAAG,EAAE,UAAU;IAWrB,WAAW,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU;IAaxC,OAAO,CAAC,GAAG,EAAE,MAAM;IAInB,MAAM,CAAC,GAAG,EAAE,MAAM;IAWlB,IAAI,CAAC,GAAG,EAAE,OAAO;IAIjB;;;OAGG;IACH,iBAAiB,CAAC,UAAU,SAAI;IAShC,kBAAkB,CAAC,UAAU,EAAE,MAAM;IASrC,OAAO,CAAC,oBAAoB;IAIrB,2BAA2B,CAAC,MAAM,EAAE,MAAM;IAIjD,OAAO,CAAC,YAAY;IAUb,kBAAkB;CAM1B"}