@layerzerolabs/common-encoding-utils 0.2.68 → 0.2.69

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/common-encoding-utils",
-  "version": "0.2.68",
+  "version": "0.2.69",
   "private": false,
   "license": "MIT",
   "type": "module",
@@ -13,16 +13,24 @@
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**/*"
+  ],
   "devDependencies": {
     "tsup": "^8.4.0",
     "vitest": "^3.2.3",
-    "@layerzerolabs/tsup-configuration": "0.2.68",
-    "@layerzerolabs/typescript-configuration": "0.2.68"
+    "@layerzerolabs/tsup-configuration": "0.2.69",
+    "@layerzerolabs/typescript-configuration": "0.2.69"
   },
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
+  "externalRepoConfig": {
+    "targets": [
+      "onesig-client"
+    ]
+  },
   "scripts": {
     "build": "tsup",
     "lint": "eslint . --max-warnings 0 || (eslint . --fix --max-warnings 0 && false)",

package/.turbo/turbo-build.log

@@ -1,27 +0,0 @@
- WARN  Issue while reading "/home/runner/work/monorepo-internal/monorepo-internal/.npmrc". Failed to replace env in config: ${NPM_TOKEN}
-
-> @layerzerolabs/common-encoding-utils@0.0.0 build /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-encoding-utils
-> tsup
-
-CLI Building entry: src/byte-codec.ts, src/index.ts
-CLI Using tsconfig: tsconfig.json
-CLI tsup v8.5.1
-CLI Using tsup config: /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-encoding-utils/tsup.config.ts
-CLI Target: ES2023
-CLI Cleaning output folder
-CJS Build start
-ESM Build start
-CJS dist/byte-codec.cjs     267.00 B
-CJS dist/DF2CBFKF.cjs       7.67 KB
-CJS dist/index.cjs          5.61 KB
-CJS dist/byte-codec.cjs.map 75.00 B
-CJS dist/DF2CBFKF.cjs.map   19.07 KB
-CJS dist/index.cjs.map      12.44 KB
-CJS ⚡️ Build success in 178ms
-ESM dist/2BTCXNB3.js       7.63 KB
-ESM dist/index.js          4.85 KB
-ESM dist/byte-codec.js     120.00 B
-ESM dist/2BTCXNB3.js.map   19.06 KB
-ESM dist/index.js.map      12.42 KB
-ESM dist/byte-codec.js.map 74.00 B
-ESM ⚡️ Build success in 178ms

package/.turbo/turbo-lint.log

@@ -1,8 +0,0 @@
-
-> @layerzerolabs/common-encoding-utils@0.0.0 lint /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-encoding-utils
-> eslint . --max-warnings 0 || (eslint . --fix --max-warnings 0 && false)
-
-(node:65531) [MODULE_TYPELESS_PACKAGE_JSON] Warning: Module type of file:///home/runner/work/monorepo-internal/monorepo-internal/eslint.config.js?mtime=1775770562286 is not specified and it doesn't parse as CommonJS.
-Reparsing as ES module because module syntax was detected. This incurs a performance overhead.
-To eliminate this warning, add "type": "module" to /home/runner/work/monorepo-internal/monorepo-internal/package.json.
-(Use `node --trace-warnings ...` to show where the warning was created)

package/.turbo/turbo-test.log

@@ -1,16 +0,0 @@
-
-> @layerzerolabs/common-encoding-utils@0.0.0 test /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-encoding-utils
-> vitest --run --pass-with-no-tests --typecheck
-
-Testing types with tsc and vue-tsc is an experimental feature.
-Breaking changes might not follow SemVer, please pin Vitest's version when using it.
-
- RUN  v3.2.4 /home/runner/work/monorepo-internal/monorepo-internal/packages/common/common-encoding-utils
-
-No test files found, exiting with code 0
-
-include: **/*.{test,spec}.?(c|m)[jt]s?(x)
-exclude:  **/node_modules/**, **/dist/**, **/cypress/**, **/.{idea,git,cache,output,temp}/**, **/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*
-typecheck include: **/*.{test,spec}-d.?(c|m)[jt]s?(x)
-typecheck exclude: **/node_modules/**, **/dist/**, **/cypress/**, **/.{idea,git,cache,output,temp}/**, **/{karma,rollup,webpack,vite,vitest,jest,ava,babel,nyc,cypress,tsup,build,eslint,prettier}.config.*
-

package/src/byte-codec.ts

@@ -1,265 +0,0 @@
-/**
- * Growable byte codec backed by `ArrayBuffer` + `DataView`.
- *
- * Low-level building block for constructing byte payloads deterministically.
- * Higher-level concerns (e.g. hashing, ABI encoding, function signatures) should
- * live in wrappers/subclasses.
- */
-
-function uMax(bits: number): bigint {
-    if (!Number.isInteger(bits) || bits < 0) {
-        throw new RangeError(`ByteCodec: invalid bit width: ${bits}`);
-    }
-    // (2^bits) - 1, as bigint
-    return bits === 0 ? 0n : (1n << BigInt(bits)) - 1n;
-}
-
-// TODO: add tests for this class — currently has zero test coverage
-export class ByteCodec {
-    // Start with a small-ish initial capacity to avoid frequent reallocations for
-    // common short payloads (e.g. function selector + a few fixed-width fields),
-    // while still staying tiny in memory terms. Buffer grows by doubling as needed.
-    #buf = new ArrayBuffer(128);
-    #view = new DataView(this.#buf);
-    #cursor = 0;
-
-    static readonly #ZERO = 0n;
-    static readonly #U8_MAX = uMax(8);
-    static readonly #U16_MAX = uMax(16);
-    static readonly #U32_MAX = uMax(32);
-    static readonly #U64_MAX = uMax(64);
-    static readonly #U128_MAX = uMax(128);
-    static readonly #U256_MAX = uMax(256);
-
-    static #outOfRange(targetLength: number, value: bigint): RangeError {
-        return new RangeError(`ByteCodec: value out of range for u${targetLength * 8}: ${value}`);
-    }
-
-    /**
-     * Read helpers (big-endian). These are intentionally small/low-level so other
-     * packages can share a single implementation for parsing encoded payloads.
-     */
-    static readU16be(buf: Uint8Array, offset: number): number {
-        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-        return view.getUint16(offset, false);
-    }
-
-    static readU8(buf: Uint8Array, offset: number): number {
-        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-        return view.getUint8(offset);
-    }
-
-    static readU32be(buf: Uint8Array, offset: number): number {
-        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-        return view.getUint32(offset, false);
-    }
-
-    static readU128be(buf: Uint8Array, offset: number): bigint {
-        return ByteCodec.readUNbe(buf, offset, 16);
-    }
-
-    static readUNbe(buf: Uint8Array, offset: number, length: number): bigint {
-        const view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
-
-        let out = 0n;
-        const end = offset + length;
-
-        // Fast path: read 8 bytes at a time
-        let cursor = offset;
-        while (cursor + 8 <= end) {
-            out = (out << 64n) | view.getBigUint64(cursor, false);
-            cursor += 8;
-        }
-
-        // Tail: 0..7 bytes
-        while (cursor < end) {
-            out = (out << 8n) | BigInt(view.getUint8(cursor));
-            cursor += 1;
-        }
-
-        return out;
-    }
-
-    static readBytes32(buf: Uint8Array, offset: number): Uint8Array {
-        if (offset + 32 > buf.length) throw new RangeError(`ByteCodec: out of bounds at ${offset}`);
-        return buf.slice(offset, offset + 32);
-    }
-
-    /**
-     * Left-pad `bytes` to `targetLength` using `padByte` (default 0x00).
-     *
-     * Commonly used to mimic Solidity's `bytes32(bytesN)`-style left zero padding.
-     */
-    static leftPad(bytes: Uint8Array, targetLength: number, padByte = 0): Uint8Array {
-        if (!Number.isInteger(targetLength) || targetLength < 0) {
-            throw new RangeError(`ByteCodec: invalid length: target=${targetLength}`);
-        }
-        if (!Number.isInteger(padByte) || padByte < 0 || padByte > 255) {
-            throw new RangeError(`ByteCodec: invalid pad byte: ${padByte}`);
-        }
-        if (bytes.length > targetLength) {
-            throw new RangeError(
-                `ByteCodec: bytes length ${bytes.length} exceeds target ${targetLength}`,
-            );
-        }
-
-        const out = new Uint8Array(targetLength);
-        if (padByte !== 0) out.fill(padByte);
-        out.set(bytes, targetLength - bytes.length);
-        return out;
-    }
-
-    /**
-     * Cast an unsigned big-endian integer in `bytes` into a fixed-width uint (by bytes),
-     * reverting on overflow.
-     *
-     * This mirrors Solidity-style safe casts like `SafeCast.toUint128(uint256)`:
-     * - if `bytes.length > targetLength`, the high (bytes.length - targetLength) bytes must be all zero
-     * - returns the low `targetLength` bytes as the result
-     *
-     * Examples:
-     * - cast bytes32 -> u128: castUNbe(bytes32, 16)
-     * - cast bytesN -> u64:   castUNbe(bytesN, 8)
-     */
-    static castUNbe(bytes: Uint8Array, targetLength: number): bigint {
-        if (!Number.isInteger(targetLength) || targetLength < 0) {
-            throw new RangeError(`ByteCodec: invalid length: target=${targetLength}`);
-        }
-
-        const len = bytes.length;
-        if (len <= targetLength) return ByteCodec.readUNbe(bytes, 0, len);
-
-        // Overflow check: any excess high bytes must be 0x00.
-        const excess = len - targetLength;
-        for (let i = 0; i < excess; i++) {
-            if (bytes[i] !== 0)
-                throw ByteCodec.#outOfRange(targetLength, ByteCodec.readUNbe(bytes, 0, len));
-        }
-
-        return ByteCodec.readUNbe(bytes, excess, targetLength);
-    }
-
-    static castU8be(bytes: Uint8Array): bigint {
-        return ByteCodec.castUNbe(bytes, 1);
-    }
-
-    static castU16be(bytes: Uint8Array): bigint {
-        return ByteCodec.castUNbe(bytes, 2);
-    }
-
-    static castU32be(bytes: Uint8Array): bigint {
-        return ByteCodec.castUNbe(bytes, 4);
-    }
-
-    static castU64be(bytes: Uint8Array): bigint {
-        return ByteCodec.castUNbe(bytes, 8);
-    }
-
-    static castU128be(bytes: Uint8Array): bigint {
-        return ByteCodec.castUNbe(bytes, 16);
-    }
-
-    protected ensureCapacity(additionalBytes: number): void {
-        const needed = this.#cursor + additionalBytes;
-        if (needed <= this.#buf.byteLength) return;
-
-        let nextCap = this.#buf.byteLength;
-        while (nextCap < needed) nextCap *= 2;
-
-        // Grow by allocating a new ArrayBuffer and copying the written prefix
-        // [0..cursor) into it. We then swap the backing buffer+view.
-        const next = new ArrayBuffer(nextCap);
-        new Uint8Array(next).set(new Uint8Array(this.#buf, 0, this.#cursor));
-        this.#buf = next;
-        this.#view = new DataView(this.#buf);
-    }
-
-    bytes(b: Uint8Array): this {
-        this.ensureCapacity(b.length);
-        new Uint8Array(this.#buf, this.#cursor, b.length).set(b);
-        this.#cursor += b.length;
-        return this;
-    }
-
-    bytes32(b: Uint8Array): this {
-        return this.bytes(ByteCodec.leftPad(b, 32));
-    }
-
-    bool(b: boolean): this {
-        return this.u8(b ? 1n : ByteCodec.#ZERO);
-    }
-
-    u8(v: bigint): this {
-        if (v < ByteCodec.#ZERO || v > ByteCodec.#U8_MAX)
-            throw new RangeError(`ByteCodec: value out of range for u8: ${v}`);
-        this.ensureCapacity(1);
-        this.#view.setUint8(this.#cursor, Number(v));
-        this.#cursor += 1;
-        return this;
-    }
-
-    u16be(v: bigint): this {
-        if (v < ByteCodec.#ZERO || v > ByteCodec.#U16_MAX)
-            throw new RangeError(`ByteCodec: value out of range for u16: ${v}`);
-        this.ensureCapacity(2);
-        this.#view.setUint16(this.#cursor, Number(v), false);
-        this.#cursor += 2;
-        return this;
-    }
-
-    u32be(v: bigint): this {
-        if (v < ByteCodec.#ZERO || v > ByteCodec.#U32_MAX) {
-            throw new RangeError(`ByteCodec: value out of range for u32: ${v}`);
-        }
-        this.ensureCapacity(4);
-        this.#view.setUint32(this.#cursor, Number(v), false);
-        this.#cursor += 4;
-        return this;
-    }
-
-    u64be(v: bigint): this {
-        if (v < ByteCodec.#ZERO || v > ByteCodec.#U64_MAX) {
-            throw new RangeError(`ByteCodec: value out of range for u64: ${v}`);
-        }
-        this.ensureCapacity(8);
-        this.#view.setBigUint64(this.#cursor, v, false);
-        this.#cursor += 8;
-        return this;
-    }
-
-    u128be(v: bigint): this {
-        if (v < ByteCodec.#ZERO || v > ByteCodec.#U128_MAX) {
-            throw new RangeError(`ByteCodec: value out of range for u128: ${v}`);
-        }
-        this.ensureCapacity(16);
-        const hi = (v >> 64n) & ByteCodec.#U64_MAX;
-        const lo = v & ByteCodec.#U64_MAX;
-        this.#view.setBigUint64(this.#cursor, hi, false);
-        this.#view.setBigUint64(this.#cursor + 8, lo, false);
-        this.#cursor += 16;
-        return this;
-    }
-
-    u256be(v: bigint): this {
-        if (v < ByteCodec.#ZERO || v > ByteCodec.#U256_MAX) {
-            throw new RangeError(`ByteCodec: value out of range for u256: ${v}`);
-        }
-        this.ensureCapacity(32);
-        const w0 = (v >> 192n) & ByteCodec.#U64_MAX;
-        const w1 = (v >> 128n) & ByteCodec.#U64_MAX;
-        const w2 = (v >> 64n) & ByteCodec.#U64_MAX;
-        const w3 = v & ByteCodec.#U64_MAX;
-        this.#view.setBigUint64(this.#cursor, w0, false);
-        this.#view.setBigUint64(this.#cursor + 8, w1, false);
-        this.#view.setBigUint64(this.#cursor + 16, w2, false);
-        this.#view.setBigUint64(this.#cursor + 24, w3, false);
-        this.#cursor += 32;
-        return this;
-    }
-    /**
-     * Returns a copy of the accumulated bytes (no shared backing buffer).
-     */
-    toBytes(): Uint8Array {
-        return new Uint8Array(this.#buf, 0, this.#cursor).slice();
-    }
-}

package/src/index.ts

@@ -1,183 +0,0 @@
-export * from './byte-codec';
-
-export type HexString = `0x${string}`;
-
-const base58regex = /^[A-HJ-NP-Za-km-z1-9]*$/;
-const base64regex = /^[A-Za-z0-9+/]*={0,2}$/;
-const hexStringRegex = /^(0x)?[0-9A-Fa-f]*$/;
-
-export function isBase58(address: string): boolean {
-    return base58regex.test(address);
-}
-
-export function isBase64(address: string): boolean {
-    return base64regex.test(address);
-}
-
-export function isHexString(value: any, length?: number): value is HexString {
-    if (typeof value !== 'string' || !value.match(hexStringRegex)) {
-        return false;
-    }
-    if (length && value.length !== 2 + 2 * length) {
-        return false;
-    }
-    return true;
-}
-
-export function hexZeroPad(value: string, length: number): HexString {
-    if (!isHexString(value)) {
-        throw new Error(`invalid hex string: ${value}`);
-    }
-
-    if (value.length > 2 * length + 2) {
-        throw new Error('value out of range');
-    }
-
-    return `0x${trim0x(value).padStart(2 * length, '0')}`;
-}
-
-export function trim0x(str: string): string {
-    return str.replace(/^0x/, '');
-}
-
-export function ensure0xPrefixed(str: string): HexString {
-    return `0x${trim0x(str)}`;
-}
-
-export function trimLeadingZeros(hexString: string): HexString {
-    // Remove the '0x' prefix
-    let withoutPrefix = trim0x(hexString);
-
-    // Trim leading zeros
-    withoutPrefix = withoutPrefix.replace(/^0+/, '');
-
-    // Add back the '0x' prefix
-    return ensure0xPrefixed(withoutPrefix);
-}
-
-export function hexToUint8Array(hexString: string): Uint8Array {
-    return Uint8Array.from(Buffer.from(trim0x(hexString), 'hex'));
-}
-
-export function hexToAscii(hex: string): string {
-    if (!isHexString(hex)) {
-        throw new Error(`Invalid hex string ${hex}`);
-    }
-
-    let str = '';
-    let i = 0;
-    const l = hex.length;
-    if (hex.startsWith('0x')) {
-        i = 2;
-    }
-    for (; i < l; i += 2) {
-        const code = parseInt(hex.slice(i, i + 2), 16);
-        str += String.fromCharCode(code);
-    }
-
-    return str;
-}
-
-export function stringToUint8Array(str: string): Uint8Array {
-    const value = str.replace(/^0x/i, '');
-    const len = value.length + 1 - ((value.length + 1) % 2);
-    return Uint8Array.from(Buffer.from(value.padStart(len, '0'), 'hex'));
-}
-
-/**
- * A function to convert hex string to Uint8Array (not prefixed)
- * @param hex hex string
- * @returns Uint8Array
- */
-export function hexToBytes(hex: string): Uint8Array {
-    const value = hex.replace(/^0x/i, '');
-    const len = value.length + 1 - ((value.length + 1) % 2);
-    return Uint8Array.from(Buffer.from(value.padStart(len, '0'), 'hex'));
-}
-
-export function bytesToHex(bytes: Uint8Array | ArrayBuffer): string {
-    return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString(
-        'hex',
-    );
-}
-
-/**
- * 0x prefixed hex string from Uint8Array
- * @param bytes
- */
-export function bytesToHexPrefixed(bytes: Uint8Array | ArrayBuffer): HexString {
-    return ensure0xPrefixed(bytesToHex(bytes));
-}
-
-export function bytesToBase64(bytes: Uint8Array | ArrayBuffer): string {
-    return Buffer.from(bytes instanceof ArrayBuffer ? new Uint8Array(bytes) : bytes).toString(
-        'base64',
-    );
-}
-
-export function base64ToBytes(base64: string): Uint8Array {
-    return Uint8Array.from(Buffer.from(base64, 'base64'));
-}
-
-export function hexToBase64(hexString: string): string {
-    const hex = trim0x(hexString);
-    // Validate that the input is a valid hex string
-    if (!/^[0-9a-fA-F]+$/.test(hex)) {
-        throw new Error(`Invalid hex string: ${hexString}`);
-    }
-
-    // Ensure the hex string has an even length
-    if (hex.length % 2 !== 0) {
-        throw new Error('Hex string must have an even length');
-    }
-
-    // Convert hex string to a byte array
-    const bytes = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < hex.length; i += 2) {
-        bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-    }
-
-    // Convert the byte array to a base64 string
-    const base64String = Buffer.from(bytes).toString('base64');
-
-    return base64String;
-}
-
-export function base64ToHex(base64String: string): HexString {
-    if (!/^[A-Za-z0-9+/=]*$/.test(base64String)) {
-        throw new Error(`Invalid base64 string: ${base64String}`);
-    }
-    return `0x${Buffer.from(base64String, 'base64').toString('hex')}`;
-}
-
-function padString(str: string, length: number, left: boolean, padding = '0') {
-    const diff = length - str.length;
-    let result = str;
-    if (diff > 0) {
-        const pad = padding.repeat(diff);
-        result = left ? pad + str : str + pad;
-    }
-    return result;
-}
-
-function padLeft(str: string, length: number, padding = '0') {
-    return padString(str, length, true, padding);
-}
-function calcByteLength(str: string, byteSize = 8) {
-    const { length } = str;
-    const remainder = length % byteSize;
-    return remainder ? ((length - remainder) / byteSize) * byteSize + byteSize : length;
-}
-
-/**
- * Pads a hex string on the left so its length is a multiple of `byteSize`.
- * Used to align hex strings.
- * @param str Hex string.
- * @param byteSize Group size to align to, in hex chars (default: 8).
- * @param padding Left-pad character (default: '0').
- * @returns Hex string left-padded to a multiple of `byteSize`.
- */
-export function padAlignHex(str: string, byteSize = 8, padding = '0') {
-    const trimmed = trim0x(str);
-    return padLeft(trimmed, calcByteLength(trimmed, byteSize), padding);
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-    "extends": "@layerzerolabs/typescript-configuration/tsconfig.base.json",
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "strictPropertyInitialization": false,
-        "noUnusedLocals": false,
-        "noUnusedParameters": false,
-        "jsx": "react-jsx"
-    },
-    "exclude": [
-        "node_modules",
-        "**/__mocks__/*",
-        "**/__tests__/*",
-        "**/*.spec.ts",
-        "**/*.test.ts",
-        "dist"
-    ],
-    "include": ["src/**/*"]
-}

package/tsup.config.ts

@@ -1,8 +0,0 @@
-import { defineConfig } from 'tsup';
-
-import { createPackageTsupConfig } from '@layerzerolabs/tsup-configuration';
-
-export default defineConfig(({ watch }) => ({
-    ...createPackageTsupConfig(),
-    clean: !watch,
-}));