@subsquid/evm-codec 0.2.1 → 1.0.0

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"}

package/lib/sink.js

@@ -1,215 +0,0 @@
-"use strict";
-var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _Sink_instances, _Sink_u64, _Sink_u128, _Sink_i256;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sink = void 0;
-const node_assert_1 = __importDefault(require("node:assert"));
-const codec_1 = require("./codec");
-class Sink {
-    constructor(fields, capacity = 1280) {
-        _Sink_instances.add(this);
-        this.pos = 0;
-        this.stack = [];
-        this.stack.push({
-            start: 0,
-            jumpBackPtr: 0,
-            size: fields * codec_1.WORD_SIZE,
-        });
-        this.buf = Buffer.alloc(capacity);
-        this.view = new DataView(this.buf.buffer, this.buf.byteOffset, this.buf.byteLength);
-    }
-    result() {
-        (0, node_assert_1.default)(this.stack.length === 1, 'Cannot get result during dynamic encoding');
-        return this.buf.subarray(0, this.size());
-    }
-    toString() {
-        return '0x' + this.result().toString('hex');
-    }
-    reserve(additional) {
-        if (this.buf.length - this.pos < additional) {
-            this._allocate(this.pos + additional);
-        }
-    }
-    size() {
-        return this.stack[this.stack.length - 1].size;
-    }
-    _allocate(cap) {
-        cap = Math.max(cap, this.buf.length * 2);
-        let buf = Buffer.alloc(cap);
-        buf.set(this.buf);
-        this.buf = buf;
-        this.view = new DataView(this.buf.buffer, this.buf.byteOffset, this.buf.byteLength);
-    }
-    checkNumberBounds(val, min, max, typeName) {
-        if (val < min || val > max) {
-            throw new Error(`${val} is out of bounds for ${typeName}[${min}, ${max}]`);
-        }
-    }
-    u8(val) {
-        this.checkNumberBounds(val, 0n, 255n, 'uint8');
-        this.reserve(codec_1.WORD_SIZE);
-        this.pos += codec_1.WORD_SIZE - 1;
-        this.view.setUint8(this.pos, val);
-        this.pos += 1;
-    }
-    i8(val) {
-        this.checkNumberBounds(val, -128n, 127n, 'int8');
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_i256).call(this, BigInt(val));
-    }
-    u16(val) {
-        this.checkNumberBounds(val, 0n, 65535n, 'uint16');
-        this.reserve(codec_1.WORD_SIZE);
-        this.pos += codec_1.WORD_SIZE - 2;
-        this.view.setUint16(this.pos, val, false);
-        this.pos += 2;
-    }
-    i16(val) {
-        this.checkNumberBounds(val, -32768n, 32767n, 'int16');
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_i256).call(this, BigInt(val));
-    }
-    u32(val) {
-        this.checkNumberBounds(val, 0n, 4294967295n, 'uint32');
-        this.reserve(codec_1.WORD_SIZE);
-        this.pos += codec_1.WORD_SIZE - 4;
-        this.view.setUint32(this.pos, val, false);
-        this.pos += 4;
-    }
-    i32(val) {
-        this.checkNumberBounds(val, -2147483648n, 2147483647n, 'int32');
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_i256).call(this, BigInt(val));
-    }
-    u64(val) {
-        this.checkNumberBounds(val, 0n, 18446744073709551615n, 'uint64');
-        this.reserve(codec_1.WORD_SIZE);
-        this.pos += codec_1.WORD_SIZE - 8;
-        this.view.setBigUint64(this.pos, val, false);
-        this.pos += 8;
-    }
-    i64(val) {
-        this.checkNumberBounds(val, -9223372036854775808n, 9223372036854775807n, 'int64');
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_i256).call(this, val);
-    }
-    u128(val) {
-        this.checkNumberBounds(val, 0n, 340282366920938463463374607431768211455n, 'uint128');
-        this.reserve(codec_1.WORD_SIZE);
-        this.pos += codec_1.WORD_SIZE - 16;
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_u64).call(this, val & 0xffffffffffffffffn);
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_u64).call(this, val >> 64n);
-    }
-    i128(val) {
-        this.checkNumberBounds(val, -170141183460469231731687303715884105728n, 170141183460469231731687303715884105727n, 'int128');
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_i256).call(this, val);
-    }
-    u256(val) {
-        this.checkNumberBounds(val, 0n, 115792089237316195423570985008687907853269984665640564039457584007913129639935n, 'uint256');
-        this.reserve(codec_1.WORD_SIZE);
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_u128).call(this, val >> 128n);
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_u128).call(this, val & (2n ** 128n - 1n));
-    }
-    i256(val) {
-        this.checkNumberBounds(val, -57896044618658097711785492504343953926634992332820282019728792003956564819968n, 57896044618658097711785492504343953926634992332820282019728792003956564819967n, 'int256');
-        __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_i256).call(this, val);
-    }
-    bytes(val) {
-        const size = Buffer.byteLength(val);
-        this.u32(size);
-        const wordsCount = Math.ceil(size / codec_1.WORD_SIZE);
-        const reservedSize = codec_1.WORD_SIZE * wordsCount;
-        this.reserve(reservedSize);
-        this.buf.set(val, this.pos);
-        this.pos += reservedSize;
-        this.increaseCurrentDataAreaSize(reservedSize + codec_1.WORD_SIZE);
-    }
-    staticBytes(len, val) {
-        if (len > 32) {
-            throw new Error(`bytes${len} is not a valid type`);
-        }
-        const size = Buffer.byteLength(val);
-        if (size > len) {
-            throw new Error(`invalid data size for bytes${len}`);
-        }
-        this.reserve(codec_1.WORD_SIZE);
-        this.buf.set(val, this.pos);
-        this.pos += codec_1.WORD_SIZE;
-    }
-    address(val) {
-        this.u256(BigInt(val));
-    }
-    string(val) {
-        const size = Buffer.byteLength(val);
-        this.u32(size);
-        const wordsCount = Math.ceil(size / codec_1.WORD_SIZE);
-        const reservedSize = codec_1.WORD_SIZE * wordsCount;
-        this.reserve(reservedSize);
-        this.buf.write(val, this.pos);
-        this.pos += reservedSize;
-        this.increaseCurrentDataAreaSize(reservedSize + codec_1.WORD_SIZE);
-    }
-    bool(val) {
-        this.u8(val ? 1 : 0);
-    }
-    /**
-     * @example
-     * @link [Solidity docs](https://docs.soliditylang.org/en/latest/abi-spec.html#use-of-dynamic-types)
-     */
-    newStaticDataArea(slotsCount = 0) {
-        const offset = this.size();
-        this.u32(offset);
-        const dataAreaStart = this.currentDataAreaStart();
-        this.pushDataArea(dataAreaStart + offset, slotsCount);
-        this.pos = dataAreaStart + offset;
-    }
-    // Adds elements count before the data area in an additional slot
-    newDynamicDataArea(slotsCount) {
-        const offset = this.size();
-        this.u32(offset);
-        const dataAreaStart = this.currentDataAreaStart();
-        this.pushDataArea(dataAreaStart + offset + codec_1.WORD_SIZE, slotsCount);
-        this.pos = dataAreaStart + offset;
-        this.u32(slotsCount);
-    }
-    currentDataAreaStart() {
-        return this.stack[this.stack.length - 1].start;
-    }
-    increaseCurrentDataAreaSize(amount) {
-        this.stack[this.stack.length - 1].size += amount;
-    }
-    pushDataArea(dataAreaStart, slotsCount) {
-        const size = slotsCount * codec_1.WORD_SIZE;
-        this.reserve(dataAreaStart + size);
-        this.stack.push({
-            start: dataAreaStart,
-            jumpBackPtr: this.pos,
-            size,
-        });
-    }
-    endCurrentDataArea() {
-        (0, node_assert_1.default)(this.stack.length > 1, 'No dynamic encoding started');
-        const { jumpBackPtr, size } = this.stack.pop();
-        this.increaseCurrentDataAreaSize(size);
-        this.pos = jumpBackPtr;
-    }
-}
-exports.Sink = Sink;
-_Sink_instances = new WeakSet(), _Sink_u64 = function _Sink_u64(val) {
-    this.view.setBigUint64(this.pos, val, false);
-    this.pos += 8;
-}, _Sink_u128 = function _Sink_u128(val) {
-    this.reserve(codec_1.WORD_SIZE);
-    __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_u64).call(this, val >> 64n);
-    __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_u64).call(this, val & 0xffffffffffffffffn);
-}, _Sink_i256 = function _Sink_i256(val) {
-    let base = 2n ** 256n;
-    const uval = (val + base) % base;
-    this.reserve(codec_1.WORD_SIZE);
-    __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_u128).call(this, uval >> 128n);
-    __classPrivateFieldGet(this, _Sink_instances, "m", _Sink_u128).call(this, uval & (2n ** 128n - 1n));
-};
-//# sourceMappingURL=sink.js.map