ox 0.0.1 → 0.1.0

package/_esm/AbiParameters.js

@@ -0,0 +1,543 @@
+import * as abitype from 'abitype';
+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 * as Solidity from './Solidity.js';
+import * as internal from './internal/abiParameters.js';
+import * as Cursor from './internal/cursor.js';
+// eslint-disable-next-line jsdoc/require-jsdoc
+export function decode(parameters, data, options = {}) {
+    const { as = 'Array' } = options;
+    const bytes = typeof data === 'string' ? Bytes.fromHex(data) : data;
+    const cursor = Cursor.create(bytes);
+    if (Bytes.size(bytes) === 0 && parameters.length > 0)
+        throw new ZeroDataError();
+    if (Bytes.size(bytes) && Bytes.size(bytes) < 32)
+        throw new DataSizeTooSmallError({
+            data: typeof data === 'string' ? data : Hex.fromBytes(data),
+            parameters: parameters,
+            size: Bytes.size(bytes),
+        });
+    let consumed = 0;
+    const values = as === 'Array' ? [] : {};
+    for (let i = 0; i < parameters.length; ++i) {
+        const param = parameters[i];
+        cursor.setPosition(consumed);
+        const [data, consumed_] = internal.decodeParameter(cursor, param, {
+            staticPosition: 0,
+        });
+        consumed += consumed_;
+        if (as === 'Array')
+            values.push(data);
+        else
+            values[param.name ?? i] = data;
+    }
+    return values;
+}
+decode.parseError = (error) => 
+/* v8 ignore next */
+error;
+/**
+ * Encodes primitive values into ABI encoded data as per the [Application Binary Interface (ABI) Specification](https://docs.soliditylang.org/en/latest/abi-spec).
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const data = AbiParameters.encode(
+ *   AbiParameters.from(['string', 'uint', 'bool']),
+ *   ['wagmi', 420n, true],
+ * )
+ * ```
+ *
+ * @example
+ * ### JSON Parameters
+ *
+ * Specify **JSON ABI** Parameters as schema:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const data = AbiParameters.encode(
+ *   [
+ *     { type: 'string', name: 'name' },
+ *     { type: 'uint', name: 'age' },
+ *     { type: 'bool', name: 'isOwner' },
+ *   ],
+ *   ['wagmi', 420n, true],
+ * )
+ * ```
+ *
+ * @param parameters - The set of ABI parameters to encode, in the shape of the `inputs` or `outputs` attribute of an ABI Item. These parameters must include valid [ABI types](https://docs.soliditylang.org/en/latest/types.html).
+ * @param values - The set of primitive values that correspond to the ABI types defined in `parameters`.
+ * @returns ABI encoded data.
+ */
+export function encode(parameters, values) {
+    if (parameters.length !== values.length)
+        throw new LengthMismatchError({
+            expectedLength: parameters.length,
+            givenLength: values.length,
+        });
+    // Prepare the parameters to determine dynamic types to encode.
+    const preparedParameters = internal.prepareParameters({
+        parameters: parameters,
+        values: values,
+    });
+    const data = internal.encode(preparedParameters);
+    if (data.length === 0)
+        return '0x';
+    return data;
+}
+encode.parseError = (error) => 
+/* v8 ignore next */
+error;
+/**
+ * Encodes an array of primitive values to a [packed ABI encoding](https://docs.soliditylang.org/en/latest/abi-spec.html#non-standard-packed-mode).
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const encoded = AbiParameters.encodePacked(
+ *   ['address', 'string'],
+ *   ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', 'hello world'],
+ * )
+ * // @log: '0xd8da6bf26964af9d7eed9e03e53415d37aa9604568656c6c6f20776f726c64'
+ * ```
+ *
+ * @param types - Set of ABI types to pack encode.
+ * @param values - The set of primitive values that correspond to the ABI types defined in `types`.
+ * @returns The encoded packed data.
+ */
+export function encodePacked(types, values) {
+    if (types.length !== values.length)
+        throw new LengthMismatchError({
+            expectedLength: types.length,
+            givenLength: values.length,
+        });
+    const data = [];
+    for (let i = 0; i < types.length; i++) {
+        const type = types[i];
+        const value = values[i];
+        data.push(encodePacked.encode(type, value));
+    }
+    return Hex.concat(...data);
+}
+(function (encodePacked) {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function encode(type, value, isArray = false) {
+        if (type === 'address') {
+            const address = value;
+            Address.assert(address);
+            return Hex.padLeft(address.toLowerCase(), isArray ? 32 : 0);
+        }
+        if (type === 'string')
+            return Hex.fromString(value);
+        if (type === 'bytes')
+            return value;
+        if (type === 'bool')
+            return Hex.padLeft(Hex.fromBoolean(value), isArray ? 32 : 1);
+        const intMatch = type.match(Solidity.integerRegex);
+        if (intMatch) {
+            const [_type, baseType, bits = '256'] = intMatch;
+            const size = Number.parseInt(bits) / 8;
+            return Hex.fromNumber(value, {
+                size: isArray ? 32 : size,
+                signed: baseType === 'int',
+            });
+        }
+        const bytesMatch = type.match(Solidity.bytesRegex);
+        if (bytesMatch) {
+            const [_type, size] = bytesMatch;
+            if (Number.parseInt(size) !== (value.length - 2) / 2)
+                throw new BytesSizeMismatchError({
+                    expectedSize: Number.parseInt(size),
+                    value: value,
+                });
+            return Hex.padRight(value, isArray ? 32 : 0);
+        }
+        const arrayMatch = type.match(Solidity.arrayRegex);
+        if (arrayMatch && Array.isArray(value)) {
+            const [_type, childType] = arrayMatch;
+            const data = [];
+            for (let i = 0; i < value.length; i++) {
+                data.push(encode(childType, value[i], true));
+            }
+            if (data.length === 0)
+                return '0x';
+            return Hex.concat(...data);
+        }
+        throw new InvalidTypeError(type);
+    }
+    encodePacked.encode = encode;
+})(encodePacked || (encodePacked = {}));
+/* v8 ignore next */
+encodePacked.parseError = (error) => error;
+/**
+ * Formats {@link ox#AbiParameters.AbiParameters} into **Human Readable ABI Parameters**.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const formatted = AbiParameters.format([
+ *   {
+ *     name: 'spender',
+ *     type: 'address',
+ *   },
+ *   {
+ *     name: 'amount',
+ *     type: 'uint256',
+ *   },
+ * ])
+ *
+ * formatted
+ * //    ^?
+ *
+ *
+ * ```
+ *
+ * @param parameters - The ABI Parameters to format.
+ * @returns The formatted ABI Parameters  .
+ */
+export function format(parameters) {
+    return abitype.formatAbiParameters(parameters);
+}
+format.parseError = (error) => 
+/* v8 ignore next */
+error;
+/**
+ * Parses arbitrary **JSON ABI Parameters** or **Human Readable ABI Parameters** into typed {@link ox#AbiParameters.AbiParameters}.
+ *
+ * @example
+ * ### JSON Parameters
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const parameters = AbiParameters.from([
+ *   {
+ *     name: 'spender',
+ *     type: 'address',
+ *   },
+ *   {
+ *     name: 'amount',
+ *     type: 'uint256',
+ *   },
+ * ])
+ *
+ * parameters
+ * //^?
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * ```
+ *
+ * @example
+ * ### Human Readable Parameters
+ *
+ * Human Readable ABI Parameters can be parsed into a typed {@link ox#AbiParameters.AbiParameters}:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const parameters = AbiParameters.from('address spender, uint256 amount')
+ *
+ * parameters
+ * //^?
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * ```
+ *
+ * @example
+ * It is possible to specify `struct`s along with your definitions:
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * const parameters = AbiParameters.from([
+ *   'struct Foo { address spender; uint256 amount; }', // [!code hl]
+ *   'Foo foo, address bar',
+ * ])
+ *
+ * parameters
+ * //^?
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ *
+ * ```
+ *
+ *
+ *
+ * @param parameters - The ABI Parameters to parse.
+ * @returns The typed ABI Parameters.
+ */
+export function from(parameters) {
+    if (Array.isArray(parameters) && typeof parameters[0] === 'string')
+        return abitype.parseAbiParameters(parameters);
+    if (typeof parameters === 'string')
+        return abitype.parseAbiParameters(parameters);
+    return parameters;
+}
+from.parseError = (error) => 
+/* v8 ignore next */
+error;
+/**
+ * Throws when the data size is too small for the given parameters.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'uint256' }], '0x010f')
+ * //                                             ↑ ❌ 2 bytes
+ * // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.
+ * // @error: Params: (uint256)
+ * // @error: Data:   0x010f (2 bytes)
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass a valid data size.
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')
+ * //                                             ↑ ✅ 32 bytes
+ * ```
+ */
+export class DataSizeTooSmallError extends Errors.BaseError {
+    constructor({ data, parameters, size, }) {
+        super(`Data size of ${size} bytes is too small for given parameters.`, {
+            metaMessages: [
+                `Params: (${abitype.formatAbiParameters(parameters)})`,
+                `Data:   ${data} (${size} bytes)`,
+            ],
+        });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AbiParameters.DataSizeTooSmallError'
+        });
+    }
+}
+/**
+ * Throws when zero data is provided, but data is expected.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'uint256' }], '0x')
+ * //                                           ↑ ❌ zero data
+ * // @error: AbiParameters.DataSizeTooSmallError: Data size of 2 bytes is too small for given parameters.
+ * // @error: Params: (uint256)
+ * // @error: Data:   0x010f (2 bytes)
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass valid data.
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'uint256' }], '0x00000000000000000000000000000000000000000000000000000000000010f')
+ * //                                             ↑ ✅ 32 bytes
+ * ```
+ */
+export class ZeroDataError extends Errors.BaseError {
+    constructor() {
+        super('Cannot decode zero data ("0x") with ABI parameters.');
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AbiParameters.ZeroDataError'
+        });
+    }
+}
+/**
+ * The length of the array value does not match the length specified in the corresponding ABI parameter.
+ *
+ * ### Example
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from('uint256[3]'), [[69n, 420n]])
+ * //                                               ↑ expected: 3  ↑ ❌ length: 2
+ * // @error: AbiParameters.ArrayLengthMismatchError: ABI encoding array length mismatch
+ * // @error: for type `uint256[3]`. Expected: `3`. Given: `2`.
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass an array of the correct length.
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from(['uint256[3]']), [[69n, 420n, 69n]])
+ * //                                                         ↑ ✅ length: 3
+ * ```
+ */
+export class ArrayLengthMismatchError extends Errors.BaseError {
+    constructor({ expectedLength, givenLength, type, }) {
+        super(`Array length mismatch for type \`${type}\`. Expected: \`${expectedLength}\`. Given: \`${givenLength}\`.`);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AbiParameters.ArrayLengthMismatchError'
+        });
+    }
+}
+/**
+ * The size of the bytes value does not match the size specified in the corresponding ABI parameter.
+ *
+ * ### Example
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from('bytes8'), [['0xdeadbeefdeadbeefdeadbeef']])
+ * //                                            ↑ expected: 8 bytes  ↑ ❌ size: 12 bytes
+ * // @error: BytesSizeMismatchError: Size of bytes "0xdeadbeefdeadbeefdeadbeef"
+ * // @error: (bytes12) does not match expected size (bytes8).
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass a bytes value of the correct size.
+ *
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from(['bytes8']), ['0xdeadbeefdeadbeef'])
+ * //                                                       ↑ ✅ size: 8 bytes
+ * ```
+ */
+export class BytesSizeMismatchError extends Errors.BaseError {
+    constructor({ expectedSize, value, }) {
+        super(`Size of bytes "${value}" (bytes${Hex.size(value)}) does not match expected size (bytes${expectedSize}).`);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AbiParameters.BytesSizeMismatchError'
+        });
+    }
+}
+/**
+ * The length of the values to encode does not match the length of the ABI parameters.
+ *
+ * ### Example
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from(['string', 'uint256']), ['hello'])
+ * // @error: LengthMismatchError: ABI encoding params/values length mismatch.
+ * // @error: Expected length (params): 2
+ * // @error: Given length (values): 1
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass the correct number of values to encode.
+ *
+ * ### Solution
+ *
+ * Pass a [valid ABI type](https://docs.soliditylang.org/en/develop/abi-spec.html#types).
+ */
+export class LengthMismatchError extends Errors.BaseError {
+    constructor({ expectedLength, givenLength, }) {
+        super([
+            'ABI encoding parameters/values length mismatch.',
+            `Expected length (parameters): ${expectedLength}`,
+            `Given length (values): ${givenLength}`,
+        ].join('\n'));
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AbiParameters.LengthMismatchError'
+        });
+    }
+}
+/**
+ * The value provided is not a valid array as specified in the corresponding ABI parameter.
+ *
+ * ### Example
+ *
+ * ```ts twoslash
+ * // @noErrors
+ * import { AbiParameters } from 'ox'
+ * // ---cut---
+ * AbiParameters.encode(AbiParameters.from(['uint256[3]']), [69])
+ * ```
+ *
+ * ### Solution
+ *
+ * Pass an array value.
+ */
+export class InvalidArrayError extends Errors.BaseError {
+    constructor(value) {
+        super(`Value \`${value}\` is not a valid array.`);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AbiParameters.InvalidArrayError'
+        });
+    }
+}
+/**
+ * Throws when the ABI parameter type is invalid.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AbiParameters } from 'ox'
+ *
+ * AbiParameters.decode([{ type: 'lol' }], '0x00000000000000000000000000000000000000000000000000000000000010f')
+ * //                             ↑ ❌ invalid type
+ * // @error: AbiParameters.InvalidTypeError: Type `lol` is not a valid ABI Type.
+ * ```
+ */
+export class InvalidTypeError extends Errors.BaseError {
+    constructor(type) {
+        super(`Type \`${type}\` is not a valid ABI Type.`);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AbiParameters.InvalidTypeError'
+        });
+    }
+}
+//# sourceMappingURL=AbiParameters.js.map

package/_esm/AbiParameters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AbiParameters.js","sourceRoot":"","sources":["../AbiParameters.ts"],"names":[],"mappings":"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"}

package/_esm/AccessList.js

@@ -0,0 +1,105 @@
+import * as Address from './Address.js';
+import * as Errors from './Errors.js';
+import * as Hash from './Hash.js';
+import * as Hex from './Hex.js';
+/**
+ * Converts a list of Access List tuples into a object-formatted list.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AccessList } from 'ox'
+ *
+ * const accessList = AccessList.fromTupleList([
+ *   [
+ *     '0x0000000000000000000000000000000000000000',
+ *     [
+ *       '0x0000000000000000000000000000000000000000000000000000000000000001',
+ *       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',
+ *     ],
+ *   ],
+ * ])
+ * // @log: [
+ * // @log:   {
+ * // @log:     address: '0x0000000000000000000000000000000000000000',
+ * // @log:     storageKeys: [
+ * // @log:       '0x0000000000000000000000000000000000000000000000000000000000000001',
+ * // @log:       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',
+ * // @log:     ],
+ * // @log:   },
+ * // @log: ]
+ * ```
+ *
+ * @param accessList - List of tuples.
+ * @returns Access list.
+ */
+export function fromTupleList(accessList) {
+    const list = [];
+    for (let i = 0; i < accessList.length; i++) {
+        const [address, storageKeys] = accessList[i];
+        if (address)
+            Address.assert(address, { strict: false });
+        list.push({
+            address: address,
+            storageKeys: storageKeys.map((key) => Hash.validate(key) ? key : Hex.trimLeft(key)),
+        });
+    }
+    return list;
+}
+/**
+ * Converts a structured Access List into a list of tuples.
+ *
+ * @example
+ * ```ts twoslash
+ * import { AccessList } from 'ox'
+ *
+ * const accessList = AccessList.toTupleList([
+ *   {
+ *     address: '0x0000000000000000000000000000000000000000',
+ *     storageKeys: [
+ *       '0x0000000000000000000000000000000000000000000000000000000000000001',
+ *       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe'],
+ *   },
+ * ])
+ * // @log: [
+ * // @log:   [
+ * // @log:     '0x0000000000000000000000000000000000000000',
+ * // @log:     [
+ * // @log:       '0x0000000000000000000000000000000000000000000000000000000000000001',
+ * // @log:       '0x60fdd29ff912ce880cd3edaf9f932dc61d3dae823ea77e0323f94adb9f6a72fe',
+ * // @log:     ],
+ * // @log:   ],
+ * // @log: ]
+ * ```
+ *
+ * @param accessList - Access list.
+ * @returns List of tuples.
+ */
+export function toTupleList(accessList) {
+    if (!accessList || accessList.length === 0)
+        return [];
+    const tuple = [];
+    for (const { address, storageKeys } of accessList) {
+        for (let j = 0; j < storageKeys.length; j++)
+            if (Hex.size(storageKeys[j]) !== 32)
+                throw new InvalidStorageKeySizeError({
+                    storageKey: storageKeys[j],
+                });
+        if (address)
+            Address.assert(address, { strict: false });
+        tuple.push([address, storageKeys]);
+    }
+    return tuple;
+}
+/** Thrown when the size of a storage key is invalid. */
+export class InvalidStorageKeySizeError extends Errors.BaseError {
+    constructor({ storageKey }) {
+        super(`Size for storage key "${storageKey}" is invalid. Expected 32 bytes. Got ${Hex.size(storageKey)} bytes.`);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 'AccessList.InvalidStorageKeySizeError'
+        });
+    }
+}
+//# sourceMappingURL=AccessList.js.map

package/_esm/AccessList.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccessList.js","sourceRoot":"","sources":["../AccessList.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAA;AACvC,OAAO,KAAK,MAAM,MAAM,aAAa,CAAA;AACrC,OAAO,KAAK,IAAI,MAAM,WAAW,CAAA;AACjC,OAAO,KAAK,GAAG,MAAM,UAAU,CAAA;AAgB/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,aAAa,CAAC,UAAiB;IAC7C,MAAM,IAAI,GAAwB,EAAE,CAAA;IACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QAC3C,MAAM,CAAC,OAAO,EAAE,WAAW,CAAC,GAAG,UAAU,CAAC,CAAC,CAAyB,CAAA;QAEpE,IAAI,OAAO;YAAE,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAA;QAEvD,IAAI,CAAC,IAAI,CAAC;YACR,OAAO,EAAE,OAAO;YAChB,WAAW,EAAE,WAAW,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CACnC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,QAAQ,CAAC,GAAG,CAAC,CAC7C;SACF,CAAC,CAAA;IACJ,CAAC;IACD,OAAO,IAAI,CAAA;AACb,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,MAAM,UAAU,WAAW,CACzB,UAAmC;IAEnC,IAAI,CAAC,UAAU,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,EAAE,CAAA;IAErD,MAAM,KAAK,GAAmB,EAAE,CAAA;IAChC,KAAK,MAAM,EAAE,OAAO,EAAE,WAAW,EAAE,IAAI,UAAU,EAAE,CAAC;QAClD,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,WAAW,CAAC,MAAM,EAAE,CAAC,EAAE;YACzC,IAAI,GAAG,CAAC,IAAI,CAAC,WAAW,CAAC,CAAC,CAAE,CAAC,KAAK,EAAE;gBAClC,MAAM,IAAI,0BAA0B,CAAC;oBACnC,UAAU,EAAE,WAAW,CAAC,CAAC,CAAE;iBAC5B,CAAC,CAAA;QAEN,IAAI,OAAO;YAAE,OAAO,CAAC,MAAM,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,CAAA;QAEvD,KAAK,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAA;IACpC,CAAC;IACD,OAAO,KAAK,CAAA;AACd,CAAC;AAED,wDAAwD;AACxD,MAAM,OAAO,0BAA2B,SAAQ,MAAM,CAAC,SAAS;IAE9D,YAAY,EAAE,UAAU,EAA2B;QACjD,KAAK,CACH,yBAAyB,UAAU,wCAAwC,GAAG,CAAC,IAAI,CAAC,UAAU,CAAC,SAAS,CACzG,CAAA;QAJe;;;;mBAAO,uCAAuC;WAAA;IAKhE,CAAC;CACF"}

package/_esm/AccountProof.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=AccountProof.js.map

package/_esm/AccountProof.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"AccountProof.js","sourceRoot":"","sources":["../AccountProof.ts"],"names":[],"mappings":""}