ox 1.2.0 → 1.3.0

package/dist/core/internal/abiParameters.js

@@ -3,7 +3,8 @@ import * as Address from '../Address.js';
 import * as Bytes from '../Bytes.js';
 import * as Errors from '../Errors.js';
 import * as Hex from '../Hex.js';
-import { integerRegex } from '../Solidity.js';
+import { bytesRegex, integerRegex } from '../Solidity.js';
+import { encoder } from './codec/utf8.js';
 /** @internal */
 export function decodeParameter(cursor, param, options) {
     const { checksumAddress, staticPosition } = options;
@@ -236,229 +237,373 @@ export function decodeString(cursor, { staticPosition }) {
     return [value, 32];
 }
 /** @internal */
-export function prepareParameters({ checksumAddress, parameters, values, }) {
-    const preparedParameters = [];
-    for (let i = 0; i < parameters.length; i++) {
-        preparedParameters.push(prepareParameter({
-            checksumAddress,
-            parameter: parameters[i],
-            value: values[i],
-        }));
+export function encodeParameters(parameters, values, options = {}) {
+    const { checksumAddress = false, prefix } = options;
+    if (parameters.length !== values.length)
+        throw new AbiParameters.LengthMismatchError({
+            expectedLength: parameters.length,
+            givenLength: values.length,
+        });
+    // Compile the wire shape before walking values so recursive writes only
+    // handle offsets and data.
+    const compiled = compileParameters(parameters);
+    const context = {
+        checksumAddress,
+    };
+    const size = measureParameters(compiled, values, context);
+    const prefixSize = prefix ? Hex.size(prefix) : 0;
+    const bytes = new Uint8Array(prefixSize + size);
+    const writer = {
+        bytes,
+        patches: [],
+        view: new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength),
+    };
+    if (prefix)
+        writeHex(writer, 0, prefix);
+    writeParameters(writer, prefixSize, compiled, values);
+    let data = Hex.fromBytes(bytes);
+    for (let i = 0; i < writer.patches.length; i++) {
+        const patch = writer.patches[i];
+        const start = 2 + patch.offset * 2;
+        data =
+            `${data.slice(0, start)}${patch.value}${data.slice(start + patch.value.length)}`;
     }
-    return preparedParameters;
+    return data;
 }
-/** @internal */
-export function prepareParameter({ checksumAddress = false, parameter: parameter_, value, }) {
-    const parameter = parameter_;
-    const arrayComponents = getArrayComponents(parameter.type);
-    if (arrayComponents) {
-        const [length, type] = arrayComponents;
-        return encodeArray(value, {
-            checksumAddress,
+function compileParameters(parameters) {
+    const compiled = [];
+    for (let i = 0; i < parameters.length; i++)
+        compiled.push(compileParameter(parameters[i]));
+    return compiled;
+}
+function compileParameter(parameter) {
+    const name = parameter.name;
+    const array = getArrayComponents(parameter.type);
+    if (array) {
+        const [length, type] = array;
+        const child = compileParameter({ ...parameter, type });
+        const dynamic = length === null || child.dynamic;
+        return {
+            child,
+            dynamic,
+            kind: 'array',
             length,
-            parameter: {
-                ...parameter,
-                type,
-            },
-        });
+            name,
+            staticSize: dynamic ? 32 : child.staticSize * length,
+            type: parameter.type,
+        };
     }
     if (parameter.type === 'tuple') {
-        return encodeTuple(value, {
-            checksumAddress,
-            parameter: parameter,
-        });
-    }
-    if (parameter.type === 'address') {
-        return encodeAddress(value, {
-            checksum: checksumAddress,
-        });
-    }
-    if (parameter.type === 'bool') {
-        return encodeBoolean(value);
+        const children = compileParameters(parameter.components);
+        let dynamic = false;
+        let staticSize = 0;
+        for (let i = 0; i < children.length; i++) {
+            const child = children[i];
+            if (child.dynamic)
+                dynamic = true;
+            staticSize += child.staticSize;
+        }
+        return {
+            children,
+            dynamic,
+            kind: 'tuple',
+            name,
+            staticSize: dynamic ? 32 : staticSize,
+        };
     }
+    if (parameter.type === 'address')
+        return {
+            dynamic: false,
+            kind: 'address',
+            name,
+            staticSize: 32,
+        };
+    if (parameter.type === 'bool')
+        return {
+            dynamic: false,
+            kind: 'boolean',
+            name,
+            staticSize: 32,
+        };
     if (parameter.type.startsWith('uint') || parameter.type.startsWith('int')) {
         const signed = parameter.type.startsWith('int');
         const [, , size = '256'] = integerRegex.exec(parameter.type) ?? [];
-        return encodeNumber(value, {
+        const size_ = Number(size);
+        const max = 2n ** (BigInt(size_) - (signed ? 1n : 0n)) - 1n;
+        return {
+            dynamic: false,
+            kind: 'integer',
+            max,
+            min: signed ? -max - 1n : 0n,
+            name,
             signed,
-            size: Number(size),
-        });
+            size: size_,
+            staticSize: 32,
+        };
     }
     if (parameter.type.startsWith('bytes')) {
-        return encodeBytes(value, { type: parameter.type });
-    }
-    if (parameter.type === 'string') {
-        return encodeString(value);
+        if (!bytesRegex.test(parameter.type))
+            throw new AbiParameters.InvalidTypeError(parameter.type);
+        const [, size] = parameter.type.split('bytes');
+        return {
+            dynamic: !size,
+            kind: 'bytes',
+            name,
+            size: size ? Number.parseInt(size, 10) : null,
+            staticSize: 32,
+        };
     }
-    throw new AbiParameters.InvalidTypeError(parameter.type);
+    if (parameter.type === 'string')
+        return {
+            dynamic: true,
+            kind: 'string',
+            name,
+            staticSize: 32,
+        };
+    return {
+        dynamic: false,
+        kind: 'invalid',
+        name,
+        staticSize: 0,
+        type: parameter.type,
+    };
 }
-/** @internal */
-export function encode(preparedParameters) {
-    // 1. Compute the size of the static part of the parameters.
-    let staticSize = 0;
-    for (let i = 0; i < preparedParameters.length; i++) {
-        const { dynamic, encoded } = preparedParameters[i];
-        if (dynamic)
-            staticSize += 32;
-        else
-            staticSize += Hex.size(encoded);
+function measureParameters(parameters, values, context) {
+    let size = getHeadSize(parameters);
+    for (let i = 0; i < parameters.length; i++) {
+        const parameter = parameters[i];
+        const parameterSize = measureParameter(parameter, getParameterValue(parameter, values, i), context);
+        if (parameter.dynamic)
+            size += parameterSize;
     }
-    // 2. Split the parameters into static and dynamic parts.
-    const staticParameters = [];
-    const dynamicParameters = [];
-    let dynamicSize = 0;
-    for (let i = 0; i < preparedParameters.length; i++) {
-        const { dynamic, encoded } = preparedParameters[i];
-        if (dynamic) {
-            staticParameters.push(Hex.fromNumber(staticSize + dynamicSize, { size: 32 }));
-            dynamicParameters.push(encoded);
-            dynamicSize += Hex.size(encoded);
-        }
-        else {
-            staticParameters.push(encoded);
+    return size;
+}
+function measureParameter(parameter, value, context) {
+    if (parameter.kind === 'array') {
+        if (!Array.isArray(value))
+            throw new AbiParameters.InvalidArrayError(value);
+        if (parameter.length !== null && value.length !== parameter.length)
+            throw new AbiParameters.ArrayLengthMismatchError({
+                expectedLength: parameter.length,
+                givenLength: value.length,
+                type: parameter.type,
+            });
+        let size = parameter.length === null ? 32 : 0;
+        size +=
+            value.length * (parameter.child.dynamic ? 32 : parameter.child.staticSize);
+        for (let i = 0; i < value.length; i++) {
+            const childSize = measureParameter(parameter.child, value[i], context);
+            if (parameter.child.dynamic)
+                size += childSize;
         }
+        return size;
     }
-    // 3. Concatenate static and dynamic parts.
-    return Hex.concat(...staticParameters, ...dynamicParameters);
+    if (parameter.kind === 'tuple')
+        return measureParameters(parameter.children, value, context);
+    if (parameter.kind === 'address') {
+        Address.assert(value, {
+            strict: context.checksumAddress,
+        });
+        return 32;
+    }
+    if (parameter.kind === 'boolean') {
+        if (typeof value !== 'boolean')
+            throw new Errors.BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
+        return 32;
+    }
+    if (parameter.kind === 'integer') {
+        const value_ = value;
+        if (value_ > parameter.max || value_ < parameter.min)
+            throw new Hex.IntegerOutOfRangeError({
+                max: parameter.max.toString(),
+                min: parameter.min.toString(),
+                signed: parameter.signed,
+                size: parameter.size / 8,
+                value: value_.toString(),
+            });
+        BigInt(value_);
+        return 32;
+    }
+    if (parameter.kind === 'bytes') {
+        const value_ = value;
+        const size = Hex.size(value_);
+        if (parameter.size !== null && size !== parameter.size)
+            throw new AbiParameters.BytesSizeMismatchError({
+                expectedSize: parameter.size,
+                value: value_,
+            });
+        if (parameter.size !== null)
+            return 32;
+        return 32 + Math.ceil(size / 32) * 32;
+    }
+    if (parameter.kind === 'string') {
+        const size = getUtf8Size(normalizeString(value));
+        return 32 + Math.ceil(size / 32) * 32;
+    }
+    throw new AbiParameters.InvalidTypeError(parameter.type);
 }
-/** @internal */
-export function encodeAddress(value, options) {
-    const { checksum } = options;
-    Address.assert(value, { strict: checksum });
-    return {
-        dynamic: false,
-        encoded: Hex.padLeft(value.toLowerCase()),
-    };
+function getHeadSize(parameters) {
+    let size = 0;
+    for (let i = 0; i < parameters.length; i++) {
+        const parameter = parameters[i];
+        size += parameter.dynamic ? 32 : parameter.staticSize;
+    }
+    return size;
 }
-/** @internal */
-export function encodeArray(value, options) {
-    const { checksumAddress, length, parameter } = options;
-    const dynamic = length === null;
-    if (!Array.isArray(value))
-        throw new AbiParameters.InvalidArrayError(value);
-    if (!dynamic && value.length !== length)
-        throw new AbiParameters.ArrayLengthMismatchError({
-            expectedLength: length,
-            givenLength: value.length,
-            type: `${parameter.type}[${length}]`,
-        });
-    // Zero-length fixed arrays of dynamic types (e.g. `string[0]`) are dynamic
-    // per the ABI spec, even though they have no elements to inspect.
-    let dynamicChild = value.length === 0 && hasDynamicChild(parameter);
-    const preparedParameters = [];
+function getParameterValue(parameter, values, index) {
+    if (Array.isArray(values))
+        return values[index];
+    return values[parameter.name];
+}
+function getUtf8Size(value) {
+    let size = 0;
     for (let i = 0; i < value.length; i++) {
-        const preparedParam = prepareParameter({
-            checksumAddress,
-            parameter,
-            value: value[i],
-        });
-        if (preparedParam.dynamic)
-            dynamicChild = true;
-        preparedParameters.push(preparedParam);
-    }
-    if (dynamic || dynamicChild) {
-        const data = encode(preparedParameters);
-        if (dynamic) {
-            const length = Hex.fromNumber(preparedParameters.length, { size: 32 });
-            return {
-                dynamic: true,
-                encoded: preparedParameters.length > 0 ? Hex.concat(length, data) : length,
-            };
+        const code = value.charCodeAt(i);
+        if (code < 0x80)
+            size++;
+        else if (code < 0x800)
+            size += 2;
+        else if (code >= 0xd800 &&
+            code <= 0xdbff &&
+            value.charCodeAt(i + 1) >= 0xdc00 &&
+            value.charCodeAt(i + 1) <= 0xdfff) {
+            size += 4;
+            i++;
         }
-        if (dynamicChild)
-            return { dynamic: true, encoded: data };
+        else
+            size += 3;
     }
-    return {
-        dynamic: false,
-        encoded: Hex.concat(...preparedParameters.map(({ encoded }) => encoded)),
-    };
+    return size;
 }
-/** @internal */
-export function encodeBytes(value, { type }) {
-    const [, parametersize] = type.split('bytes');
-    const bytesSize = Hex.size(value);
-    if (!parametersize) {
-        let value_ = value;
-        // If the size is not divisible by 32 bytes, pad the end
-        // with empty bytes to the ceiling 32 bytes.
-        if (bytesSize % 32 !== 0)
-            value_ = Hex.padRight(value_, Math.ceil((value.length - 2) / 2 / 32) * 32);
-        return {
-            dynamic: true,
-            encoded: Hex.concat(Hex.padLeft(Hex.fromNumber(bytesSize, { size: 32 })), value_),
-        };
-    }
-    if (bytesSize !== Number.parseInt(parametersize, 10))
-        throw new AbiParameters.BytesSizeMismatchError({
-            expectedSize: Number.parseInt(parametersize, 10),
-            value,
-        });
-    return { dynamic: false, encoded: Hex.padRight(value) };
+function normalizeString(value) {
+    if (value === undefined)
+        return '';
+    return `${value}`;
 }
-/** @internal */
-export function encodeBoolean(value) {
-    if (typeof value !== 'boolean')
-        throw new Errors.BaseError(`Invalid boolean value: "${value}" (type: ${typeof value}). Expected: \`true\` or \`false\`.`);
-    return { dynamic: false, encoded: Hex.padLeft(Hex.fromBoolean(value)) };
+function isWritableHex(value) {
+    if (typeof value !== 'string' ||
+        value.charCodeAt(0) !== 48 ||
+        value.charCodeAt(1) !== 120)
+        return false;
+    for (let i = 2; i < value.length; i++)
+        if (toNibble(value.charCodeAt(i)) === -1)
+            return false;
+    return true;
 }
-/** @internal */
-export function encodeNumber(value, { signed, size }) {
-    if (typeof size === 'number') {
-        const max = 2n ** (BigInt(size) - (signed ? 1n : 0n)) - 1n;
-        const min = signed ? -max - 1n : 0n;
-        if (value > max || value < min)
-            throw new Hex.IntegerOutOfRangeError({
-                max: max.toString(),
-                min: min.toString(),
-                signed,
-                size: size / 8,
-                value: value.toString(),
-            });
+function writeParameters(context, offset, parameters, values) {
+    let head = offset;
+    let tail = offset + getHeadSize(parameters);
+    for (let i = 0; i < parameters.length; i++) {
+        const parameter = parameters[i];
+        const value = getParameterValue(parameter, values, i);
+        if (parameter.dynamic) {
+            writeWord(context, head, tail - offset);
+            head += 32;
+            tail = writeParameter(context, tail, parameter, value);
+        }
+        else
+            head = writeParameter(context, head, parameter, value);
     }
-    return {
-        dynamic: false,
-        encoded: Hex.fromNumber(value, {
-            size: 32,
-            signed,
-        }),
-    };
+    return Math.max(head, tail);
 }
-/** @internal */
-export function encodeString(value) {
-    const hexValue = Hex.fromString(value);
-    const partsLength = Math.ceil(Hex.size(hexValue) / 32);
-    const parts = [];
-    for (let i = 0; i < partsLength; i++) {
-        parts.push(Hex.padRight(Hex.slice(hexValue, i * 32, (i + 1) * 32)));
+function writeParameter(context, offset, parameter, value) {
+    if (parameter.kind === 'array') {
+        const values = value;
+        let head = offset;
+        if (parameter.length === null) {
+            writeWord(context, head, values.length);
+            head += 32;
+        }
+        let tail = head +
+            values.length *
+                (parameter.child.dynamic ? 32 : parameter.child.staticSize);
+        for (let i = 0; i < values.length; i++) {
+            if (parameter.child.dynamic) {
+                writeWord(context, head, tail - (parameter.length === null ? offset + 32 : offset));
+                head += 32;
+                tail = writeParameter(context, tail, parameter.child, values[i]);
+            }
+            else
+                head = writeParameter(context, head, parameter.child, values[i]);
+        }
+        return Math.max(head, tail);
     }
-    return {
-        dynamic: true,
-        encoded: Hex.concat(Hex.padRight(Hex.fromNumber(Hex.size(hexValue), { size: 32 })), ...parts),
-    };
+    if (parameter.kind === 'tuple')
+        return writeParameters(context, offset, parameter.children, value);
+    if (parameter.kind === 'address') {
+        writeHex(context, offset + 12, value);
+        return offset + 32;
+    }
+    if (parameter.kind === 'boolean') {
+        context.bytes[offset + 31] = value ? 1 : 0;
+        return offset + 32;
+    }
+    if (parameter.kind === 'integer') {
+        writeWord(context, offset, value);
+        return offset + 32;
+    }
+    if (parameter.kind === 'bytes') {
+        const value_ = value;
+        if (parameter.size === null) {
+            const size = Hex.size(value_);
+            writeWord(context, offset, size);
+            writeHex(context, offset + 32, value_);
+            return offset + 32 + Math.ceil(size / 32) * 32;
+        }
+        writeHex(context, offset, value_);
+        return offset + 32;
+    }
+    if (parameter.kind === 'string') {
+        const value_ = normalizeString(value);
+        const size = getUtf8Size(value_);
+        writeWord(context, offset, size);
+        const { written } = encoder.encodeInto(value_, context.bytes.subarray(offset + 32, offset + 32 + size));
+        if (written !== size)
+            throw new Error('Failed to encode string.');
+        return offset + 32 + Math.ceil(size / 32) * 32;
+    }
+    return offset;
 }
-/** @internal */
-export function encodeTuple(value, options) {
-    const { checksumAddress, parameter } = options;
-    let dynamic = false;
-    const preparedParameters = [];
-    for (let i = 0; i < parameter.components.length; i++) {
-        const param_ = parameter.components[i];
-        const index = Array.isArray(value) ? i : param_.name;
-        const preparedParam = prepareParameter({
-            checksumAddress,
-            parameter: param_,
-            value: value[index],
-        });
-        preparedParameters.push(preparedParam);
-        if (preparedParam.dynamic)
-            dynamic = true;
+function writeHex(context, offset, value) {
+    if (!isWritableHex(value)) {
+        const patch = value.slice(2);
+        context.patches.push({ offset, value: patch });
+        return offset + Math.ceil(patch.length / 2);
     }
-    return {
-        dynamic,
-        encoded: dynamic
-            ? encode(preparedParameters)
-            : Hex.concat(...preparedParameters.map(({ encoded }) => encoded)),
-    };
+    let i = 2;
+    for (; i + 1 < value.length; i += 2)
+        context.bytes[offset++] =
+            (toNibble(value.charCodeAt(i)) << 4) | toNibble(value.charCodeAt(i + 1));
+    if (i < value.length)
+        context.bytes[offset++] = toNibble(value.charCodeAt(i)) << 4;
+    return offset;
+}
+function writeWord(context, offset, value) {
+    let value_ = BigInt(value);
+    if (value_ < 0n)
+        value_ = BigInt.asUintN(256, value_);
+    // DataView avoids 32 BigInt shifts for the common word-sized case.
+    if (value_ <= 0xffffffffffffffffn) {
+        context.view.setBigUint64(offset + 24, value_);
+        return;
+    }
+    const hex = value_.toString(16);
+    let cursor = offset + 32 - Math.ceil(hex.length / 2);
+    let i = hex.length % 2;
+    if (i === 1)
+        context.bytes[cursor++] = toNibble(hex.charCodeAt(0));
+    for (; i < hex.length; i += 2)
+        context.bytes[cursor++] =
+            (toNibble(hex.charCodeAt(i)) << 4) | toNibble(hex.charCodeAt(i + 1));
+}
+function toNibble(code) {
+    if (code >= 48 && code <= 57)
+        return code - 48;
+    if (code >= 65 && code <= 70)
+        return code - 55;
+    if (code >= 97 && code <= 102)
+        return code - 87;
+    return -1;
 }
 /** @internal */
 export function getArrayComponents(type) {