@onrail-xyz/evm 1.0.0

package/dist/layouting.d.ts

@@ -0,0 +1,264 @@
+import { type Address } from "viem";
+import type { Identity, RoUint8Array, RoTuple, RoNeTuple, RoPair, HeadTail, Opts, OptionalArg } from "@onrail-xyz/utils";
+import type { Conversion, Layout, Struct, DeriveType, Item, NumSizeToPrimitive, WithCustom, UnwrapSingleton } from "@onrail-xyz/binary-layout";
+import { paddingItem, uintItem, switchItem } from "@onrail-xyz/binary-layout";
+import type { KindWithAtomic } from "@onrail-xyz/amount";
+import { type AmountOr } from "@onrail-xyz/common";
+export declare const wordSize = 32;
+export declare const addressSize = 20;
+type SignedSlot = Readonly<{
+    binary: "int";
+    size: typeof wordSize;
+}>;
+export type SignedSlotItem<I extends Item> = WithCustom<SignedSlot, DeriveType<I>>;
+type SlotPadding = ReturnType<typeof paddingItem>;
+type PaddedStruct<I extends Item> = {
+    readonly _padding: SlotPadding;
+    readonly item: I;
+};
+type ZeroPaddedItem<I extends Item> = UnwrapSingleton<PaddedStruct<I>>;
+type PaddedItem<I extends Item> = I extends {
+    binary: "int";
+} ? SignedSlotItem<I> : ZeroPaddedItem<I>;
+declare const paddedStruct: <const S extends Struct>(layout: S) => {
+    readonly _padding: {
+        readonly binary: "bytes";
+        readonly fixed: Uint8Array<ArrayBuffer>;
+    };
+} & S;
+export type PaddedSlotLayout<T extends Struct | Item> = T extends Item ? PaddedItem<T> : T extends Struct ? ReturnType<typeof paddedStruct<T>> : never;
+export declare const paddedSlotLayout: <const T extends Struct | Item>(layoutOrItem: T) => PaddedSlotLayout<T>;
+export type PaddedFields<S extends Struct> = {
+    readonly [K in keyof S]: PaddedSlotLayout<S[K]>;
+};
+export declare const paddedFields: <const S extends Struct>(layout: S) => PaddedFields<S>;
+export declare const uint256Item: {
+    readonly binary: "uint";
+    readonly size: 32;
+};
+export declare const evmAmountItem: <const K extends KindWithAtomic | undefined = undefined>(...kind: OptionalArg<K>) => import("@onrail-xyz/common").AmountItem<32, K>;
+export declare const deadlineItem: import("@onrail-xyz/binary-layout").TimestampItem<{
+    readonly size: 32;
+    readonly saturateAs: "infinity";
+}>;
+export type Deadline = DeriveType<typeof deadlineItem>;
+export declare const evmTimestampItem: import("@onrail-xyz/binary-layout").TimestampItem<{
+    readonly size: 32;
+}>;
+export declare const addressConversion: Conversion<RoUint8Array, Address>;
+declare const _addressItem: {
+    readonly binary: "bytes";
+    readonly size: 20;
+    readonly custom: Conversion<RoUint8Array, `0x${string}`>;
+};
+export interface AddressItem extends Identity<typeof _addressItem> {
+}
+export declare const addressItem: AddressItem;
+export declare const abiAddressItem: Readonly<{
+    binary: "bytes";
+    layout: PaddedStruct<AddressItem>;
+    custom: Conversion<{
+        readonly item: `0x${string}`;
+    }, `0x${string}`>;
+}>;
+export declare const abiBoolItem: Readonly<{
+    binary: "bytes";
+    layout: PaddedStruct<{
+        readonly binary: "uint";
+        readonly size: 1;
+        readonly custom: {
+            readonly to: (encoded: number) => boolean;
+            readonly from: (value: boolean) => number;
+        };
+    }>;
+    custom: Conversion<{
+        readonly item: boolean;
+    }, boolean>;
+}>;
+declare const rightPaddedBytesLayout: <N extends number>(size: N) => {
+    readonly value: {
+        readonly binary: "bytes";
+        readonly size: N;
+    };
+    readonly _padding: {
+        readonly binary: "bytes";
+        readonly fixed: Uint8Array<ArrayBuffer>;
+    };
+};
+export type BytesNItem<N extends number> = UnwrapSingleton<ReturnType<typeof rightPaddedBytesLayout<N>>>;
+export declare const bytesNItem: <N extends number>(size: N) => BytesNItem<N>;
+export declare const signatureSize = 65;
+export declare const signatureItem: {
+    readonly binary: "bytes";
+    readonly size: 65;
+};
+export declare const signatureLayout: {
+    readonly r: {
+        readonly binary: "bytes";
+        readonly size: 32;
+    };
+    readonly s: {
+        readonly binary: "bytes";
+        readonly size: 32;
+    };
+    readonly v: {
+        readonly binary: "uint";
+        readonly size: 1;
+    };
+};
+export declare const abiSignatureLayout: {
+    readonly v: Readonly<{
+        binary: "bytes";
+        layout: PaddedStruct<{
+            readonly binary: "uint";
+            readonly size: 1;
+        }>;
+        custom: Conversion<{
+            readonly item: number;
+        }, number>;
+    }>;
+    readonly r: {
+        readonly binary: "bytes";
+        readonly size: 32;
+    };
+    readonly s: {
+        readonly binary: "bytes";
+        readonly size: 32;
+    };
+};
+export declare const abiSignatureItem: Readonly<{
+    binary: "bytes";
+    layout: {
+        readonly v: Readonly<{
+            binary: "bytes";
+            layout: PaddedStruct<{
+                readonly binary: "uint";
+                readonly size: 1;
+            }>;
+            custom: Conversion<{
+                readonly item: number;
+            }, number>;
+        }>;
+        readonly r: {
+            readonly binary: "bytes";
+            readonly size: 32;
+        };
+        readonly s: {
+            readonly binary: "bytes";
+            readonly size: 32;
+        };
+    };
+    custom: Conversion<{
+        readonly v: number;
+        readonly r: RoUint8Array;
+        readonly s: RoUint8Array;
+    }, RoUint8Array>;
+}>;
+export declare const compactSignatureItem: Readonly<{
+    binary: "bytes";
+    layout: {
+        readonly r: {
+            readonly binary: "bytes";
+            readonly size: 32;
+        };
+        readonly yParityAndS: {
+            readonly binary: "bytes";
+            readonly size: 32;
+        };
+    };
+    custom: Conversion<{
+        readonly r: RoUint8Array;
+        readonly yParityAndS: RoUint8Array;
+    }, RoUint8Array>;
+}>;
+export declare const selectorLength = 4;
+export declare const selectorOf: (funcSig: string) => Uint8Array<ArrayBufferLike>;
+export declare const selectorItem: (funcSig: string) => {
+    readonly binary: "bytes";
+    readonly fixed: Uint8Array<ArrayBufferLike>;
+};
+export declare const selectorLayout: (funcSig: string) => <const L extends Struct>(layout: L) => {
+    readonly _selector: {
+        readonly binary: "bytes";
+        readonly fixed: Uint8Array<ArrayBufferLike>;
+    };
+} & L;
+export type AbiEncoded<L extends Layout | undefined> = L extends Layout ? DeriveType<L> : RoUint8Array;
+declare const abiEncodedLayout: (offset: number) => {
+    readonly offset: {
+        readonly binary: "uint";
+        readonly size: 32;
+        readonly fixed: bigint;
+    };
+    readonly lengthPadding: {
+        readonly binary: "bytes";
+        readonly fixed: Uint8Array<ArrayBuffer>;
+    };
+    readonly item: {
+        readonly binary: "bytes";
+        readonly size: {
+            readonly binary: "uint";
+            readonly size: 4;
+        };
+    };
+    readonly postPadding: {
+        readonly binary: "bytes";
+    };
+};
+export type AbiEncodedBytesItem<L extends Layout | undefined> = WithCustom<ReturnType<typeof abiEncodedLayout>, AbiEncoded<L>>;
+type AbiEncodedOpts = Opts<{
+    layout: Layout;
+    offset: number;
+}>;
+type ContentOf<O extends AbiEncodedOpts> = "layout" extends keyof O ? O["layout"] : undefined;
+export declare const abiEncodedBytesItem: <const O extends AbiEncodedOpts = {}>(...[opts]: OptionalArg<O>) => AbiEncodedBytesItem<ContentOf<O>>;
+export type AbiParam<N extends string = string, T extends string = string, I extends Item = Item, V = unknown> = {
+    readonly name: N;
+    readonly type: T;
+    readonly item: I;
+    readonly __valueType?: V;
+};
+type ValueOf<I extends Item, Stated extends boolean, V> = Stated extends true ? V : DeriveType<I>;
+type ParamFactory<Stated extends boolean, V> = <N extends string, T extends string, const I extends Item>(name: N, type: T, item: I) => AbiParam<N, T, I, ValueOf<I, Stated, V>>;
+type AbiParamFn = ParamFactory<false, "ignored"> & {
+    <V>(): ParamFactory<true, V>;
+};
+export declare const abiParam: AbiParamFn;
+export type AbiParamValue<A extends AbiParam> = A extends {
+    __valueType?: infer V;
+} ? V : never;
+type ParamOfFactory<Stated extends boolean, V> = <T extends string, const I extends Item>(type: T, item: I) => <N extends string>(name: N) => AbiParam<N, T, I, ValueOf<I, Stated, V>>;
+type ParamOfFn = ParamOfFactory<false, "ignored"> & {
+    <V>(): ParamOfFactory<true, V>;
+};
+export declare const paramOf: ParamOfFn;
+export declare const addressParam: <N extends string>(name: N) => AbiParam<N, "address", AddressItem, `0x${string}`>;
+export declare const amountParam: <N extends string, T extends string, const K extends KindWithAtomic | undefined = undefined, S extends number = typeof wordSize>(name: N, type: T, ...args: OptionalArg<K, OptionalArg<S>>) => AbiParam<N, T, import("@onrail-xyz/common").AmountItem<S, K>, AmountOr<K, NumSizeToPrimitive<S>>>;
+export type DynamicAbiParam<N extends string, L extends Layout | undefined> = AbiParam<N, "bytes", AbiEncodedBytesItem<L>, AbiEncoded<L>> & {
+    readonly dynamic: {
+        readonly layout: L;
+    };
+};
+export declare const trailingBytesParam: <N extends string, const L extends Layout | undefined = undefined>(name: N, ...layout: OptionalArg<L>) => DynamicAbiParam<N, L>;
+export type SigVariant<S extends string = string, P extends Struct = Struct> = RoPair<S, P>;
+export type SigVariants = RoNeTuple<SigVariant>;
+export declare const signatureOf: (name: string, params: RoTuple<AbiParam>) => string;
+export type SigNameOf<S extends string> = S extends `${infer N}(${string}` ? N : never;
+export declare const sigNameOf: <S extends string>(funcSig: S) => SigNameOf<S>;
+type JoinTypes<P extends RoTuple<AbiParam>> = P extends HeadTail<P, infer H, infer R> ? R extends readonly [] ? H["type"] : `${H["type"]},${JoinTypes<R>}` : "";
+export type SigVariantOf<N extends string, P extends RoTuple<AbiParam>> = SigVariant<`${N}(${JoinTypes<P>})`, {
+    readonly [E in P[number] as E["name"]]: E["item"];
+}>;
+export declare const sigVariant: <N extends string, const P extends RoTuple<AbiParam>>(name: N, ...params: P) => SigVariantOf<N, P>;
+type SwitchRows = Parameters<typeof switchItem>[2];
+type SigRows<IS extends number, V extends SigVariants> = {
+    readonly [K in keyof V]: V[K] extends SigVariant<infer S, infer P> ? readonly [NumSizeToPrimitive<IS>, SigNameOf<S>, PaddedFields<P>] : never;
+};
+type SigRowsBound<IS extends number, V extends SigVariants> = SigRows<IS, V> extends infer R extends SwitchRows ? R : never;
+export type SigSwitcher<IS extends number, T extends string> = <const V extends SigVariants>(variants: V) => ReturnType<typeof switchItem<T, ReturnType<typeof uintItem<IS, {}>>, SigRowsBound<IS, V>, {}>>;
+export declare const sigSwitchItem: <IS extends number, T extends string>(idSize: IS, tag: T) => SigSwitcher<IS, T>;
+export type MappingKey = bigint | number | boolean | Address | RoUint8Array;
+export declare const mappingSlot: (key: MappingKey, declareSlot: bigint) => bigint;
+export declare const keccakSlot: (slot: bigint) => bigint;
+export {};
+//# sourceMappingURL=layouting.d.ts.map

package/dist/layouting.d.ts.map

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

package/dist/layouting.js

@@ -0,0 +1,238 @@
+import { checksumAddress } from "viem";
+import { utf8, hex, bignum, assertDistinct, argOf } from "@onrail-xyz/utils";
+import { serialize, deserialize, calcStaticSize, paddingItem, unwrapSingleton, isItem, uintItem, switchItem, numSizeToPrimitive, timestampItem, withCustom, hasFixed, customOf, boolItem } from "@onrail-xyz/binary-layout";
+import { amountItem, hashItem } from "@onrail-xyz/common";
+import { keccak256 } from "./hashing.js";
+// ---- Padding ----
+export const wordSize = 32;
+export const addressSize = 20;
+//sub-word layouts are left-padded onto one slot - the ABI's alignment for every static type but
+//  bytesN, which `bytesNItem` spells at word width, right-padded; whole-word ones (a signature's
+//  three words) are already slot-aligned and pass with empty padding
+const slotPadding = (layout) => {
+    const size = calcStaticSize(layout);
+    if (size === null || (size > wordSize && size % wordSize !== 0))
+        throw new Error("layout must have a static size of at most one word or of whole words");
+    return paddingItem(size > wordSize ? 0 : wordSize - size);
+};
+const signedSlotLayout = { binary: "int", size: wordSize };
+const signedSlotItem = (item) => {
+    const size = calcStaticSize(item);
+    const bound = 1n << BigInt(size * 8 - 1);
+    const checkBound = (wide) => {
+        if (wide < -bound || wide >= bound)
+            throw new Error(`${wide} does not fit a signed ${size * 8}-bit slot`);
+        return wide;
+    };
+    const narrow = (word) => numSizeToPrimitive(checkBound(word), size);
+    const widen = (value) => checkBound(BigInt(value));
+    //the item's own conversion speaks its declared width, so the widening wraps it on both sides
+    //  rather than composing through `withCustom`, which only appends
+    const own = customOf(item);
+    return withCustom(signedSlotLayout, own === undefined
+        ? { to: narrow, from: widen }
+        : { to: (word) => own.to(narrow(word)),
+            from: (value) => widen(own.from(value)) });
+};
+//a slot surfaces exactly the item's value, so an item that surfaces none - one of fixed value,
+//  `as` included, since `as` carries `fixed` by construction - has no slot form: it would leave
+//  the padded struct with nothing to unwrap to
+const paddedItem = (item) => {
+    if (calcStaticSize(item) === null || hasFixed(item))
+        throw new Error("a slot item must be statically sized and surface a value");
+    return (item.binary === "int"
+        ? signedSlotItem(item)
+        : unwrapSingleton({ _padding: slotPadding(item), item }));
+};
+//a generated wire-only field leads with an underscore - `_padding`, `_selector` - which keeps
+//  it out of the namespace a spec's own fields are spelled in
+const paddedStruct = (layout) => ({ _padding: slotPadding(layout), ...layout });
+export const paddedSlotLayout = (layoutOrItem) => (isItem(layoutOrItem)
+    ? paddedItem(layoutOrItem)
+    : paddedStruct(layoutOrItem));
+//every field on a slot of its own: the ABI's static parameter list, EIP-712's encodeData
+export const paddedFields = (layout) => Object.fromEntries(Object.entries(layout).map(([name, field]) => [name, paddedSlotLayout(field)]));
+// ---- Value items ----
+export const uint256Item = { binary: "uint", size: wordSize };
+//an amount on a word; narrower amounts are `amountItem(size, kind)` as anywhere else
+export const evmAmountItem = (...kind) => amountItem(wordSize, ...kind);
+//a maxed out deadline is the "never expires" idiom (EIP-2612, EIP-3009), and anything else out
+//  that far is not an intended instant either, so the whole high end resolves to the same sentinel
+export const deadlineItem = timestampItem({ size: wordSize, saturateAs: "infinity" });
+export const evmTimestampItem = timestampItem({ size: wordSize });
+//annotated, not `satisfies`: only an annotation gives the value the `Conversion` reference as
+//  its type, and that reference is what survives into every item embedding it.
+//  The surfaced spelling is EIP-55, which is what viem's own decoders return: a lowercase one
+//  would make the same word decode to two strings that compare unequal
+export const addressConversion = {
+    to: (encoded) => checksumAddress(hex.encode(encoded, true)),
+    from: (addr) => hex.decode(addr),
+};
+const _addressItem = {
+    binary: "bytes",
+    size: addressSize,
+    custom: addressConversion,
+};
+export const addressItem = _addressItem;
+//an address and a bool on their ABI words
+export const abiAddressItem = paddedSlotLayout(addressItem);
+export const abiBoolItem = paddedSlotLayout(boolItem());
+//the ABI's `bytesN`, the one static type it pads on the right: spelled at word width, where a
+//  bare bytes item on a slot (an address, say) is left-padded like everything else
+const rightPaddedBytesLayout = (size) => ({
+    value: { binary: "bytes", size },
+    _padding: paddingItem(wordSize - size),
+});
+export const bytesNItem = (size) => {
+    if (!Number.isInteger(size) || size < 1 || size > wordSize)
+        throw new Error(`bytes${size} is not an ABI type`);
+    return unwrapSingleton(rightPaddedBytesLayout(size));
+};
+// ---- Signatures ----
+export const signatureSize = 65;
+export const signatureItem = { binary: "bytes", size: signatureSize };
+const vItem = { binary: "uint", size: 1 };
+//v is the recovery id in its legacy spelling, 27 + yParity
+const vBase = 27;
+const yParityBit = 0x80;
+export const signatureLayout = { r: hashItem, s: hashItem, v: vItem };
+export const abiSignatureLayout = { v: paddedSlotLayout(vItem), r: hashItem, s: hashItem };
+export const abiSignatureItem = withCustom(abiSignatureLayout, {
+    to: (words) => serialize(signatureLayout, words),
+    from: (signature) => deserialize(signatureLayout, signature),
+});
+export const compactSignatureItem = withCustom({ r: hashItem, yParityAndS: hashItem }, {
+    to: ({ r, yParityAndS }) => {
+        const s = Uint8Array.from(yParityAndS);
+        s[0] = yParityAndS[0] & ~yParityBit;
+        const yParity = yParityAndS[0] >= yParityBit ? 1 : 0;
+        return serialize(signatureLayout, { r, s, v: vBase + yParity });
+    },
+    from: (signature) => {
+        const { r, s, v } = deserialize(signatureLayout, signature);
+        //the form has one bit for the parity: v must be that bit's legacy spelling, and s must
+        //  leave the bit free, as a canonical (low) s does
+        if (v !== vBase && v !== vBase + 1)
+            throw new Error(`v must be ${vBase} or ${vBase + 1}, got ${v}`);
+        if (s[0] >= yParityBit)
+            throw new Error("s has its top bit set (not a low s), so it has no compact form");
+        const yParityAndS = Uint8Array.from(s);
+        yParityAndS[0] = s[0] | (v - vBase) * yParityBit;
+        return { r, yParityAndS };
+    },
+});
+// ---- Function selectors ----
+const funcSigHashPrefix = (funcSig, size) => keccak256(utf8.encode(funcSig)).subarray(0, size);
+export const selectorLength = 4;
+export const selectorOf = (funcSig) => funcSigHashPrefix(funcSig, selectorLength);
+export const selectorItem = (funcSig) => ({ binary: "bytes", fixed: selectorOf(funcSig) });
+export const selectorLayout = (funcSig) => (layout) => ({ _selector: selectorItem(funcSig), ...layout });
+// ---- A single dynamic value ----
+//poor man's abi.encode/decode(bytes): handles a single dynamic value - a trailing argument, or a
+//  lone return - whose payload therefore follows the whole head. `offset` is that head's size,
+//  its own word included - hence the default, a lone argument - and is the argument's index times
+//  the word size only where every preceding argument occupies exactly one slot
+const lengthSize = 4;
+//the payload stays raw bytes in the layout, so its length is at hand to check the padding
+//  against; the conversion runs the content layout, if any
+const abiEncodedLayout = (offset) => ({
+    offset: { ...uint256Item, fixed: BigInt(offset) },
+    lengthPadding: { binary: "bytes", fixed: new Uint8Array(wordSize - lengthSize) },
+    item: { binary: "bytes", size: { binary: "uint", size: lengthSize } },
+    postPadding: { binary: "bytes" },
+});
+const paddingSizeOf = (dataSize) => (wordSize - dataSize % wordSize) % wordSize;
+export const abiEncodedBytesItem = (...[opts]) => {
+    const layout = abiEncodedLayout(opts?.offset ?? wordSize);
+    const content = opts?.layout;
+    return withCustom(layout, {
+        to: (wrapped) => {
+            const { item, postPadding } = wrapped;
+            if (postPadding.length !== paddingSizeOf(item.length) || postPadding.some(b => b !== 0))
+                throw new Error(`abi-encoded bytes: expected ${paddingSizeOf(item.length)} padding bytes`);
+            return (content !== undefined ? deserialize(content, item) : item);
+        },
+        from: (value) => {
+            const item = content !== undefined ? serialize(content, value) : value;
+            return { item, postPadding: new Uint8Array(paddingSizeOf(item.length)) };
+        },
+    });
+};
+export const abiParam = ((...args) => args.length === 0
+    ? (name, type, item) => ({ name, type, item })
+    : { name: args[0], type: args[1], item: args[2] });
+export const paramOf = ((...args) => args.length === 0
+    ? (type, item) => (name) => ({ name, type, item })
+    : (name) => ({ name, type: args[0], item: args[1] }));
+export const addressParam = paramOf("address", addressItem);
+//the item's width is the domain's range, independent of the ABI type the slot is spelled as: a
+//  uint64 amount the contract holds rides a `uint256` word, and the 8-byte item is what rejects
+//  a value the contract could not hold. Without a kind the value is what that width derives,
+//  as the item's own DeriveType would say
+export const amountParam = (name, type, ...args) => abiParam()(name, type, amountItem((args[1] ?? wordSize), argOf(args)));
+//`bytes` as a function's last parameter - raw, or the serialization of `layout`. The item is a
+//  placeholder built at offset zero; `contractFromSpec` rebuilds it once the parameter list
+//  fixes the head's size, which the type does not depend on
+export const trailingBytesParam = (name, ...layout) => ({
+    ...abiParam(name, "bytes", abiEncodedBytesItem({ layout: argOf(layout) })),
+    dynamic: { layout: argOf(layout) },
+});
+//the params' names become a struct's keys, so a repeat would fold two params into one field;
+//  every params list passes through here, which is where it is caught
+export const signatureOf = (name, params) => {
+    assertDistinct(...params.map(p => p.name));
+    return `${name}(${params.map(p => p.type).join(",")})`;
+};
+export const sigNameOf = (funcSig) => {
+    const open = funcSig.indexOf("(");
+    if (open < 1)
+        throw new Error(`not a function signature: ${funcSig}`);
+    return funcSig.slice(0, open);
+};
+//a variant from its name and params, so an event or error is spelled once
+export const sigVariant = (name, ...params) => [signatureOf(name, params), Object.fromEntries(params.map(p => [p.name, p.item]))];
+const sigPrefixId = (funcSig, size) => {
+    if (size < 1 || size > wordSize)
+        throw new Error(`signature prefix size must be within [1, ${wordSize}], got ${size}`);
+    return numSizeToPrimitive(bignum.fromBytes(funcSigHashPrefix(funcSig, size)), size);
+};
+//a switch over signature-derived ids, decoding the abi-encoded params of the matched variant.
+//  The tag surfaces the signature's own name, Solidity's spelling included - a consumer wanting
+//  its discriminants to read uniformly folds the case on its own side, where the convention is:
+//  custom errors off revert data (idSize 4 - the selector is all the wire carries), events off
+//  topic0 concatenated with the remaining topics and the data - so an event's struct is in
+//  wire order, indexed params first, which `sigVariant`'s param order is only when they lead
+//  the declaration. topic0 carries the whole hash, so events take idSize 32; a shorter prefix
+//  would only trade away collision headroom
+export const sigSwitchItem = (idSize, tag) => (variants) => switchItem(tag, uintItem(idSize), variants.map(([funcSig, params]) => [
+    sigPrefixId(funcSig, idSize),
+    sigNameOf(funcSig),
+    paddedFields(params),
+]));
+export const mappingSlot = (key, declareSlot) => {
+    const buf = new Uint8Array(2 * wordSize);
+    if (typeof key === "bigint" || typeof key === "number") {
+        const int = BigInt(key);
+        if (int < -(1n << 255n) || int >= (1n << 256n))
+            throw new Error(`mapping key ${int} does not fit a word`);
+        buf.set(bignum.toBytes(int < 0n ? int + (1n << 256n) : int, wordSize));
+    }
+    else if (typeof key === "boolean")
+        buf[wordSize - 1] = key ? 1 : 0;
+    else if (typeof key === "string") {
+        //viem's Address is any `0x${string}`, so a hex-spelled bytesN would otherwise pass for one
+        const address = hex.decode(key);
+        if (address.length !== addressSize)
+            throw new Error(`a string mapping key is an address, got ${address.length} bytes - ` +
+                `pass a bytesN key as a Uint8Array`);
+        buf.set(address, wordSize - addressSize);
+    }
+    else {
+        if (key.length > wordSize)
+            throw new Error("mapping key must not exceed one word");
+        buf.set(key, 0);
+    }
+    buf.set(bignum.toBytes(declareSlot, wordSize), wordSize);
+    return bignum.fromBytes(keccak256(buf));
+};
+export const keccakSlot = (slot) => bignum.fromBytes(keccak256(bignum.toBytes(slot, wordSize)));

package/dist/parsing.d.ts

@@ -0,0 +1,16 @@
+import type { Hex } from "viem";
+import type { RoArray, RoUint8Array } from "@onrail-xyz/utils";
+import type { DeriveType } from "@onrail-xyz/binary-layout";
+import { type SigVariants } from "./layouting.js";
+export type ViemLog = Readonly<{
+    topics: RoArray<Hex>;
+    data: Hex;
+}>;
+declare const errorSwitchItem: import("./layouting.js").SigSwitcher<4, "error">;
+declare const eventSwitchItem: import("./layouting.js").SigSwitcher<32, "event">;
+export type ParsedError<V extends SigVariants> = DeriveType<ReturnType<typeof errorSwitchItem<V>>>;
+export type ParsedEvent<V extends SigVariants> = DeriveType<ReturnType<typeof eventSwitchItem<V>>>;
+export declare const buildParseError: <const V extends SigVariants>(errorDefs: V) => (revertData: RoUint8Array) => ParsedError<V>;
+export declare const buildParseEvent: <const V extends SigVariants>(eventDefs: V) => (log: ViemLog) => ParsedEvent<V>;
+export {};
+//# sourceMappingURL=parsing.d.ts.map

package/dist/parsing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parsing.d.ts","sourceRoot":"","sources":["../src/parsing.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,MAAM,CAAC;AAChC,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAE/D,OAAO,KAAK,EAAE,UAAU,EAAc,MAAM,2BAA2B,CAAC;AAExE,OAAO,EAAE,KAAK,WAAW,EAA2C,MAAM,gBAAgB,CAAC;AAQ3F,MAAM,MAAM,OAAO,GAAG,QAAQ,CAAC;IAAE,MAAM,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC;IAAC,IAAI,EAAE,GAAG,CAAA;CAAE,CAAC,CAAC;AAEpE,QAAA,MAAM,eAAe,kDAAyC,CAAC;AAC/D,QAAA,MAAM,eAAe,mDAAyC,CAAC;AAG/D,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,WAAW,IAC3C,UAAU,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AACpD,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,WAAW,IAC3C,UAAU,CAAC,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAEpD,eAAO,MAAM,eAAe,GAAI,KAAK,CAAC,CAAC,SAAS,WAAW,aAAa,CAAC,kBAEnD,YAAY,KAAG,WAAW,CAAC,CAAC,CAIjD,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,KAAK,CAAC,CAAC,SAAS,WAAW,aAAa,CAAC,WAE1D,OAAO,KAAG,WAAW,CAAC,CAAC,CAQrC,CAAC"}

package/dist/parsing.js

@@ -0,0 +1,26 @@
+import { bytes, hex, succeeds } from "@onrail-xyz/utils";
+import { deserialize, findVariantByRawId } from "@onrail-xyz/binary-layout";
+import { selectorLength, sigSwitchItem, wordSize } from "./layouting.js";
+const requireKnownSig = (item, prefix, what) => {
+    if (!succeeds(() => findVariantByRawId(item, deserialize(item.id, prefix))))
+        throw new Error(`unrecognized ${what}: ${hex.encode(prefix, true)}`);
+};
+const errorSwitchItem = sigSwitchItem(selectorLength, "error");
+const eventSwitchItem = sigSwitchItem(wordSize, "event");
+export const buildParseError = (errorDefs) => {
+    const item = errorSwitchItem(errorDefs);
+    return (revertData) => {
+        requireKnownSig(item, revertData.subarray(0, selectorLength), "error selector");
+        return deserialize(item, revertData);
+    };
+};
+export const buildParseEvent = (eventDefs) => {
+    const item = eventSwitchItem(eventDefs);
+    return (log) => {
+        if (log.topics.length === 0)
+            throw new Error("anonymous event: no topic0 to switch on");
+        const encoded = bytes.concat(...log.topics.map(t => hex.decode(t)), hex.decode(log.data));
+        requireKnownSig(item, encoded.subarray(0, wordSize), "event topic0");
+        return deserialize(item, encoded);
+    };
+};