@onrail-xyz/evm 1.0.0

package/dist/permit.d.ts

@@ -0,0 +1,139 @@
+import type { Address } from "viem";
+import type { OptionalArg } from "@onrail-xyz/utils";
+import type { KindWithAtomic } from "@onrail-xyz/amount";
+import { type AmountOrAtomic } from "@onrail-xyz/common";
+import { type Deadline } from "./layouting.js";
+import { type ContractMethods } from "./client.js";
+import type { Eip712Domain, Eip712Data, Eip712Message } from "./eip712.js";
+declare const permitSpec: <const K extends KindWithAtomic | undefined = undefined>(...kind: OptionalArg<K>) => readonly [import("./client.js").FuncSpec<"DOMAIN_SEPARATOR", readonly [], () => {}, {
+    readonly binary: "bytes";
+    readonly size: 32;
+}>, import("./client.js").FuncSpec<"nonces", readonly [import("./layouting.js").AbiParam<"owner", "address", import("./layouting.js").AddressItem, `0x${string}`>], (owner: `0x${string}`) => {
+    owner: `0x${string}`;
+}, {
+    readonly binary: "uint";
+    readonly size: 32;
+}>, import("./client.js").FuncSpec<"permit", readonly [import("./layouting.js").AbiParam<"owner", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"spender", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"value", "uint256", import("@onrail-xyz/common").AmountItem<32, K>, import("@onrail-xyz/common").AmountOr<K, bigint>>, import("./layouting.js").AbiParam<"deadline", "uint256", import("@onrail-xyz/binary-layout").TimestampItem<{
+    readonly size: 32;
+    readonly saturateAs: "infinity";
+}>, "infinity" | Date>, import("./layouting.js").AbiParam<"signature", "uint8,bytes32,bytes32", Readonly<{
+    binary: "bytes";
+    layout: {
+        readonly v: Readonly<{
+            binary: "bytes";
+            layout: {
+                readonly _padding: {
+                    readonly binary: "bytes";
+                    readonly fixed: Uint8Array<ArrayBuffer>;
+                };
+                readonly item: {
+                    readonly binary: "uint";
+                    readonly size: 1;
+                };
+            };
+            custom: import("@onrail-xyz/binary-layout").Conversion<{
+                readonly item: number;
+            }, number>;
+        }>;
+        readonly r: {
+            readonly binary: "bytes";
+            readonly size: 32;
+        };
+        readonly s: {
+            readonly binary: "bytes";
+            readonly size: 32;
+        };
+    };
+    custom: import("@onrail-xyz/binary-layout").Conversion<{
+        readonly v: number;
+        readonly r: import("@onrail-xyz/utils").RoUint8Array;
+        readonly s: import("@onrail-xyz/utils").RoUint8Array;
+    }, import("@onrail-xyz/utils").RoUint8Array>;
+}>, import("@onrail-xyz/utils").RoUint8Array>], (owner: `0x${string}`, spender: `0x${string}`, value: import("@onrail-xyz/common").AmountOr<K, bigint>, deadline: "infinity" | Date, signature: import("@onrail-xyz/utils").RoUint8Array) => {
+    owner: `0x${string}`;
+    spender: `0x${string}`;
+    value: import("@onrail-xyz/common").AmountOr<K, bigint>;
+    deadline: "infinity" | Date;
+    signature: import("@onrail-xyz/utils").RoUint8Array;
+}, undefined>];
+export declare const permit: <const K extends KindWithAtomic | undefined = undefined>(contract: Address, ...kind: OptionalArg<K>) => ContractMethods<ReturnType<typeof permitSpec<K>>>;
+declare const permitType: readonly [{
+    readonly name: "owner";
+    readonly type: "address";
+}, {
+    readonly name: "spender";
+    readonly type: "address";
+}, {
+    readonly name: "value";
+    readonly type: "uint256";
+}, {
+    readonly name: "nonce";
+    readonly type: "uint256";
+}, {
+    readonly name: "deadline";
+    readonly type: "uint256";
+}];
+export type Eip2612Message = Eip712Message<typeof permitType>;
+export type Eip2612Data = Eip712Data<Eip2612Message>;
+export declare const composePermitMsg: (owner: Address, spender: Address, value: AmountOrAtomic, domain: Eip712Domain, nonce: number | bigint, deadline?: Deadline) => {
+    readonly types: {
+        readonly EIP712Domain: ({
+            readonly name: "name";
+            readonly type: "string";
+        } | {
+            readonly name: "version";
+            readonly type: "string";
+        } | {
+            readonly name: "chainId";
+            readonly type: "uint256";
+        } | {
+            readonly name: "verifyingContract";
+            readonly type: "address";
+        } | {
+            readonly name: "salt";
+            readonly type: "bytes32";
+        })[];
+        readonly Permit: readonly [{
+            readonly name: "owner";
+            readonly type: "address";
+        }, {
+            readonly name: "spender";
+            readonly type: "address";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly name: "nonce";
+            readonly type: "uint256";
+        }, {
+            readonly name: "deadline";
+            readonly type: "uint256";
+        }];
+    };
+    readonly primaryType: "Permit";
+    readonly domain: Partial<Eip712Message<readonly [{
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly name: "version";
+        readonly type: "string";
+    }, {
+        readonly name: "chainId";
+        readonly type: "uint256";
+    }, {
+        readonly name: "verifyingContract";
+        readonly type: "address";
+    }, {
+        readonly name: "salt";
+        readonly type: "bytes32";
+    }]>>;
+    readonly message: {
+        readonly owner: `0x${string}`;
+        readonly spender: `0x${string}`;
+        readonly value: bigint;
+        readonly nonce: bigint;
+        readonly deadline: bigint;
+    };
+};
+export {};
+//# sourceMappingURL=permit.d.ts.map

package/dist/permit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permit.d.ts","sourceRoot":"","sources":["../src/permit.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACzD,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,oBAAoB,CAAC;AACrF,OAAO,EAAE,KAAK,QAAQ,EAC0C,MAAM,gBAAgB,CAAC;AACvF,OAAO,EAAE,KAAK,eAAe,EAAiC,MAAM,aAAa,CAAC;AAClF,OAAO,KAAK,EAAE,YAAY,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAQ3E,QAAA,MAAM,UAAU,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,GAAG,SAAS,GAAG,SAAS,WAC/D,WAAW,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cAUxB,CAAC;AAEF,eAAO,MAAM,MAAM,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,GAAG,SAAS,GAAG,SAAS,YACjE,OAAO,WACP,WAAW,CAAC,CAAC,CAAC,KACvB,eAAe,CAAC,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC,CACF,CAAC;AAElD,QAAA,MAAM,UAAU;aACZ,IAAI,EAAE,OAAO;aAAK,IAAI,EAAE,SAAS;;aACjC,IAAI,EAAE,SAAS;aAAG,IAAI,EAAE,SAAS;;aACjC,IAAI,EAAE,OAAO;aAAK,IAAI,EAAE,SAAS;;aACjC,IAAI,EAAE,OAAO;aAAK,IAAI,EAAE,SAAS;;aACjC,IAAI,EAAE,UAAU;aAAE,IAAI,EAAE,SAAS;EAC3B,CAAC;AAEX,MAAM,MAAM,cAAc,GAAG,aAAa,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9D,MAAM,MAAM,WAAW,GAAM,UAAU,CAAC,cAAc,CAAC,CAAC;AAGxD,eAAO,MAAM,gBAAgB,UACjB,OAAO,WACP,OAAO,SACP,cAAc,UACd,YAAY,SACZ,MAAM,GAAG,MAAM,aACf,QAAQ;;iBAUD,YAAY;;;;;;;;;;;;;;;;iBAA4B,MAAM;2BA3BvD,OAAO;2BAAW,SAAS;;2BAC3B,SAAS;2BAAS,SAAS;;2BAC3B,OAAO;2BAAW,SAAS;;2BAC3B,OAAO;2BAAW,SAAS;;2BAC3B,UAAU;2BAAQ,SAAS;;;0BAwBpB,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;CAIxB,CAAC"}

package/dist/permit.js

@@ -0,0 +1,38 @@
+import { toAtomicIfAmount, hashItem } from "@onrail-xyz/common";
+import { uint256Item, deadlineItem, abiSignatureItem, abiParam, addressParam, amountParam } from "./layouting.js";
+import { abiFunction, contractFromSpec } from "./client.js";
+import { eip712DomainType } from "./eip712.js";
+const owner = addressParam("owner");
+const spender = addressParam("spender");
+const deadline = abiParam("deadline", "uint256", deadlineItem);
+const signature = abiParam("signature", "uint8,bytes32,bytes32", abiSignatureItem);
+const permitSpec = (...kind) => {
+    const value = amountParam("value", "uint256", ...kind);
+    return [
+        abiFunction("DOMAIN_SEPARATOR", [], () => ({}), hashItem),
+        abiFunction("nonces", [owner], owner => ({ owner }), uint256Item),
+        abiFunction("permit", [owner, spender, value, deadline, signature], (owner, spender, value, deadline, signature) => ({ owner, spender, value, deadline, signature })),
+    ];
+};
+export const permit = (contract, ...kind) => contractFromSpec(contract, permitSpec(...kind));
+const permitType = [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+];
+//compose an EIP-2612 permit message; `toViemTypedData` bridges it to viem's signing calls
+export const composePermitMsg = (owner, spender, value, domain, nonce, deadline = "infinity") => {
+    const atomic = toAtomicIfAmount(value);
+    if (atomic < 0n)
+        throw new Error("Value must not be negative");
+    const unixDeadline = deadlineItem.custom.from(deadline);
+    const bigNonce = typeof nonce === "number" ? BigInt(nonce) : nonce;
+    return {
+        types: { EIP712Domain: eip712DomainType(domain), Permit: permitType },
+        primaryType: "Permit",
+        domain,
+        message: { owner, spender, value: atomic, nonce: bigNonce, deadline: unixDeadline },
+    };
+};

package/dist/query.d.ts

@@ -0,0 +1,54 @@
+import type { Abi, AbiStateMutability, Address, PublicClient, ParseAbi, ContractFunctionName, ContractFunctionArgs, ContractFunctionReturnType } from "viem";
+import type { RoUint8Array, RoArray, RoPair } from "@onrail-xyz/utils";
+import { type MaybeArray } from "@onrail-xyz/utils";
+import type { Layout, DeriveType } from "@onrail-xyz/binary-layout";
+import type { SigNameOf } from "./layouting.js";
+type ViemResolve<A extends Abi, N extends ContractFunctionName<A>, T extends "params" | "return"> = T extends "params" ? ContractFunctionArgs<A, AbiStateMutability, N> : ContractFunctionReturnType<A, AbiStateMutability, N>;
+type AbiResolve<S extends string, T extends "params" | "return"> = string extends S ? T extends "params" ? RoArray : unknown : ParseAbi<[`function ${S}`]> extends infer A extends Abi ? SigNameOf<S> extends infer N extends ContractFunctionName<A> ? ViemResolve<A, N, T> : never : never;
+type AbiParameters<S extends string> = AbiResolve<S, "params">;
+export type QueryAbiReturn<S extends string> = AbiResolve<S, "return">;
+export type QueryAbiPair<S extends string = string> = RoPair<S, AbiParameters<S>>;
+export type QueryLayoutTriple<CL extends Layout = Layout, RL extends Layout = Layout> = readonly [CL, DeriveType<CL>, RL];
+export type QueryCallData = RoUint8Array | QueryLayoutTriple | QueryAbiPair;
+export type QueryCall<D extends QueryCallData = QueryCallData> = {
+    readonly to: Address;
+    readonly data: D;
+    readonly allowFailure?: boolean;
+};
+type _CheckCall<C> = C extends {
+    data: infer D;
+} ? D extends RoUint8Array ? RoUint8Array : D extends QueryLayoutTriple<infer CL extends Layout, infer RL extends Layout> ? QueryLayoutTriple<CL, RL> : D extends QueryAbiPair<infer S extends string> ? QueryAbiPair<S> : never : never;
+type CheckCall<C> = Omit<C, "data"> & {
+    data: _CheckCall<C>;
+};
+type CheckCalls<A> = A extends RoArray<QueryCall> ? {
+    [K in keyof A]: CheckCall<A[K]>;
+} : CheckCall<A>;
+type ResultOf<D> = D extends RoUint8Array ? RoUint8Array : D extends QueryLayoutTriple<Layout, infer RL extends Layout> ? DeriveType<RL> : D extends QueryAbiPair<infer S extends string> ? QueryAbiReturn<S> : never;
+type WrappedResult<C extends QueryCall> = {
+    success: true;
+    data: ResultOf<C["data"]>;
+} | {
+    success: false;
+    data: RoUint8Array;
+};
+type ByAllowFailure<F, C extends QueryCall> = F extends true ? WrappedResult<C> : ResultOf<C["data"]>;
+type CallResult<C> = C extends QueryCall ? ByAllowFailure<C["allowFailure"], C> : never;
+export type QueryResult<A extends MaybeArray<QueryCall>> = A extends RoArray<QueryCall> ? {
+    [K in keyof A]: CallResult<A[K]>;
+} : CallResult<A>;
+export type QueryResultWithMeta<A extends MaybeArray<QueryCall>> = [
+    QueryResult<A>,
+    bigint,
+    RoUint8Array,
+    Date
+];
+export type BlockSpec<S extends "hash" | "ref" = "hash" | "ref"> = S extends "hash" ? RoUint8Array : bigint | "latest" | "finalized";
+export type Query = ReturnType<typeof createQuery>;
+export declare const createQuery: (viemClient: PublicClient) => {
+    <const A extends MaybeArray<QueryCall>>(callS: A & CheckCalls<A>, block: BlockSpec<"hash">): Promise<QueryResult<A>>;
+    <const A extends MaybeArray<QueryCall>>(callS: A & CheckCalls<A>, block?: BlockSpec<"ref">): Promise<QueryResultWithMeta<A>>;
+    <const A extends MaybeArray<QueryCall>>(callS: A & CheckCalls<A>, block: BlockSpec): Promise<QueryResult<A> | QueryResultWithMeta<A>>;
+};
+export {};
+//# sourceMappingURL=query.d.ts.map

package/dist/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../src/query.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,kBAAkB,EAAE,OAAO,EAAO,YAAY,EAAE,QAAQ,EAC7D,oBAAoB,EAAE,oBAAoB,EAAE,0BAA0B,EAAE,MAAM,MAAM,CAAC;AAEnG,OAAO,KAAK,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACvE,OAAO,EAAE,KAAK,UAAU,EAC8B,MAAM,mBAAmB,CAAC;AAChF,OAAO,KAAK,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAC;AAEpE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAQhD,KAAK,WAAW,CAAC,CAAC,SAAS,GAAG,EAAE,CAAC,SAAS,oBAAoB,CAAC,CAAC,CAAC,EAAE,CAAC,SAAS,QAAQ,GAAG,QAAQ,IAC9F,CAAC,SAAS,QAAQ,GAChB,oBAAoB,CAAC,CAAC,EAAE,kBAAkB,EAAE,CAAC,CAAC,GAC9C,0BAA0B,CAAC,CAAC,EAAE,kBAAkB,EAAE,CAAC,CAAC,CAAC;AAEzD,KAAK,UAAU,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,QAAQ,GAAG,QAAQ,IAC7D,MAAM,SAAS,CAAC,GACd,CAAC,SAAS,QAAQ,GAChB,OAAO,GACP,OAAO,GACT,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,CAAC,CAAC,SAAS,MAAM,CAAC,SAAS,GAAG,GACvD,SAAS,CAAC,CAAC,CAAC,SAAS,MAAM,CAAC,SAAS,oBAAoB,CAAC,CAAC,CAAC,GAC1D,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GACpB,KAAK,GACP,KAAK,CAAC;AAEV,KAAK,aAAa,CAAC,CAAC,SAAS,MAAM,IAAI,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;AAE/D,MAAM,MAAM,cAAc,CAAC,CAAC,SAAS,MAAM,IAAI,UAAU,CAAC,CAAC,EAAE,QAAQ,CAAC,CAAC;AAEvE,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM,IAAI,MAAM,CAAC,CAAC,EAAE,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC;AAElF,MAAM,MAAM,iBAAiB,CAAC,EAAE,SAAS,MAAM,GAAG,MAAM,EAAE,EAAE,SAAS,MAAM,GAAG,MAAM,IAClF,SAAS,CAAC,EAAE,EAAE,UAAU,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC;AAEpC,MAAM,MAAM,aAAa,GAAG,YAAY,GAAG,iBAAiB,GAAG,YAAY,CAAC;AAI5E,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,aAAa,GAAG,aAAa,IAC3D;IAAE,QAAQ,CAAC,EAAE,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IAAC,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAE9E,KAAK,UAAU,CAAC,CAAC,IACf,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC,CAAA;CAAE,GACzB,CAAC,SAAS,YAAY,GACpB,YAAY,GACZ,CAAC,SAAS,iBAAiB,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,MAAM,EAAE,SAAS,MAAM,CAAC,GAC7E,iBAAiB,CAAC,EAAE,EAAE,EAAE,CAAC,GACzB,CAAC,SAAS,YAAY,CAAC,MAAM,CAAC,SAAS,MAAM,CAAC,GAC9C,YAAY,CAAC,CAAC,CAAC,GACf,KAAK,GACP,KAAK,CAAC;AAEV,KAAK,SAAS,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,EAAE,MAAM,CAAC,GAAG;IAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC;AAE9D,KAAK,UAAU,CAAC,CAAC,IACf,CAAC,SAAS,OAAO,CAAC,SAAS,CAAC,GAC1B;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GACnC,SAAS,CAAC,CAAC,CAAC,CAAC;AAIjB,KAAK,QAAQ,CAAC,CAAC,IACb,CAAC,SAAS,YAAY,GAAyC,YAAY,GAC3E,CAAC,SAAS,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,SAAS,MAAM,CAAC,GAAG,UAAU,CAAC,EAAE,CAAC,GAC7E,CAAC,SAAS,YAAY,CAAC,MAAM,CAAC,SAAS,MAAM,CAAC,GAAiB,cAAc,CAAC,CAAC,CAAC,GAChF,KAAK,CAAC;AAER,KAAK,aAAa,CAAC,CAAC,SAAS,SAAS,IACpC;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAA;CAAE,GAAG;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,IAAI,EAAE,YAAY,CAAA;CAAE,CAAC;AAExF,KAAK,cAAc,CAAC,CAAC,EAAE,CAAC,SAAS,SAAS,IACxC,CAAC,SAAS,IAAI,GAAG,aAAa,CAAC,CAAC,CAAC,GAAG,QAAQ,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;AAE1D,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,SAAS,SAAS,GAAG,cAAc,CAAC,CAAC,CAAC,cAAc,CAAC,EAAE,CAAC,CAAC,GAAG,KAAK,CAAC;AAExF,MAAM,MAAM,WAAW,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,IACrD,CAAC,SAAS,OAAO,CAAC,SAAS,CAAC,GAC1B;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;CAAE,GACpC,UAAU,CAAC,CAAC,CAAC,CAAC;AAElB,MAAM,MAAM,mBAAmB,CAAC,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,IAC7D;IAAC,WAAW,CAAC,CAAC,CAAC;IAAE,MAAM;IAAE,YAAY;IAAE,IAAI;CAAC,CAAC;AAyE/C,MAAM,MAAM,SAAS,CAAC,CAAC,SAAS,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,KAAK,IAC7D,CAAC,SAAS,MAAM,GACd,YAAY,GACZ,MAAM,GAAG,QAAQ,GAAG,WAAW,CAAC;AAiEpC,MAAM,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,eAAO,MAAM,WAAW,eAAgB,YAAY;WAE7B,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,SAC3C,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,SACjB,SAAS,CAAC,MAAM,CAAC,GACvB,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;WAEL,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,SAC1C,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,UACjB,SAAS,CAAC,KAAK,CAAC,GACvB,OAAO,CAAC,mBAAmB,CAAC,CAAC,CAAC,CAAC;WAEb,CAAC,SAAS,UAAU,CAAC,SAAS,CAAC,SAC3C,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,SACjB,SAAS,GACf,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,mBAAmB,CAAC,CAAC,CAAC,CAAC;CAUpD,CAAC"}

package/dist/query.js

@@ -0,0 +1,105 @@
+import { multicall3Abi, encodeFunctionData, decodeFunctionResult, parseAbi } from "viem";
+import { isArray, isUint8Array, throwOnNullish, hex, unixTime } from "@onrail-xyz/utils";
+import { serialize, deserialize } from "@onrail-xyz/binary-layout";
+import { sigNameOf } from "./layouting.js";
+// ---- Runtime encoding/decoding ----
+const viemAbi = (sig) => ({
+    abi: parseAbi([`function ${sig}`]),
+    functionName: sigNameOf(sig),
+});
+const encodeCallData = (data) => !Array.isArray(data)
+    ? hex.encode(data, true)
+    : typeof data[0] === "string"
+        ? encodeFunctionData({ ...viemAbi(data[0]), args: data[1] })
+        : hex.encode(serialize(data[0], data[1]), true);
+const decodeResult = (data, returnData) => !Array.isArray(data)
+    ? hex.decode(returnData)
+    : typeof data[0] === "string"
+        ? decodeFunctionResult({ ...viemAbi(data[0]), data: returnData })
+        : deserialize(data[2], hex.decode(returnData));
+const processResult = (call, raw) => {
+    const { success, returnData } = raw;
+    const data = success ? decodeResult(call.data, returnData) : hex.decode(returnData);
+    if (!raw.success && !call.allowFailure)
+        throw new Error(`Call to ${call.to} reverted: ${hex.encode(data, true)}`);
+    return call.allowFailure ? { success, data } : data;
+};
+// ---- createQuery ----
+//Multicall3's deterministic deployment puts it at the same address on nearly every chain, but a
+//  few (zkSync and friends) deviate, hence the chain config takes precedence when it has an entry
+const CANONICAL_MULTICALL3 = "0xcA11bde05977b3631167028862bE2a173976CA11";
+const multicall3Of = (viemClient) => viemClient.chain?.contracts?.multicall3?.address ?? CANONICAL_MULTICALL3;
+const encodeAggregate3 = (calls) => encodeFunctionData({
+    abi: multicall3Abi,
+    functionName: "aggregate3",
+    args: [calls.map(c => ({
+            target: c.to,
+            allowFailure: true,
+            callData: encodeCallData(c.data),
+        }))],
+});
+async function aggregate3(viemClient, callData, blockHash) {
+    const returnData = await viemClient.request({
+        method: "eth_call",
+        params: [
+            { to: multicall3Of(viemClient), data: callData },
+            { blockHash, requireCanonical: true },
+        ],
+    });
+    return decodeFunctionResult({
+        abi: multicall3Abi,
+        functionName: "aggregate3",
+        data: returnData,
+    });
+}
+const MAX_RETRIES = 3;
+//resolves a block tag or number to a canonical block hash, retrying whenever the batch does not
+//  come back, which is what a reorged-out block looks like from here
+async function resolveBlock(viemClient, callData, block) {
+    const blockIdentifier = typeof block === "bigint" ? { blockNumber: block } : { blockTag: block };
+    let lastError;
+    for (let attempt = 0; attempt < MAX_RETRIES; ++attempt) {
+        const blockInfo = await viemClient.getBlock(blockIdentifier);
+        const blockHash = throwOnNullish(blockInfo.hash, "Block hash is null (pending block)");
+        const results = await aggregate3(viemClient, callData, blockHash)
+            .catch(error => { lastError = error; return undefined; });
+        if (results === undefined)
+            continue;
+        return {
+            results,
+            blockInfo: {
+                number: blockInfo.number,
+                hash: hex.decode(blockHash),
+                timestamp: unixTime.toDate(blockInfo.timestamp),
+            },
+        };
+    }
+    throw new Error(`Querying canonical block failed ${MAX_RETRIES} times in a row`, { cause: lastError });
+}
+const _query = async (viemClient, callS, block) => {
+    const multi = isArray(callS);
+    const calls = multi ? callS : [callS];
+    //encoded before any block is resolved: a malformed argument is the caller's error, which the
+    //  reorg retry must neither repeat nor report as a failed block
+    const callData = encodeAggregate3(calls);
+    return (isUint8Array(block)
+        ? aggregate3(viemClient, callData, hex.encode(block, true))
+        : resolveBlock(viemClient, callData, block)).then(raw => {
+        const [results, blockInfo] = "results" in raw
+            ? [raw.results, raw.blockInfo]
+            : [raw, undefined];
+        const result = multi
+            ? calls.map((c, i) => processResult(c, results[i]))
+            : processResult(calls[0], results[0]);
+        return blockInfo
+            ? [result, blockInfo.number, blockInfo.hash, blockInfo.timestamp]
+            : result;
+    });
+};
+export const createQuery = (viemClient) => {
+    //impl
+    function query(callS, block = "latest") {
+        return _query(viemClient, callS, block);
+    }
+    return query;
+};

package/package.json

@@ -0,0 +1,70 @@
+{
+  "$schema": "https://json.schemastore.org/package.json",
+  "name": "@onrail-xyz/evm",
+  "version": "1.0.0",
+  "author": "nonergodic",
+  "license": "Apache-2.0",
+  "description": "EVM utilities built on viem: declarative contract specs, ERC20, EIP-2612 permit and EIP-3009 authorization interactions, Multicall3 batched reads, and word-aligned binary layouts",
+  "keywords": [
+    "ethereum",
+    "evm",
+    "viem",
+    "erc20",
+    "permit",
+    "eip-2612",
+    "eip-3009",
+    "eip-712",
+    "multicall",
+    "abi",
+    "layout"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Onrail/ts-sdk.git",
+    "directory": "packages/evm"
+  },
+  "bugs": {
+    "url": "https://github.com/Onrail/ts-sdk/issues"
+  },
+  "homepage": "https://github.com/Onrail/ts-sdk/tree/main/packages/evm#readme",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "types": "./dist/index.d.ts",
+  "exports": {
+    "types": "./dist/index.d.ts",
+    "import": "./dist/index.js",
+    "default": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "src",
+    "README.md"
+  ],
+  "peerDependencies": {
+    "@onrail-xyz/utils": "^1.0.0",
+    "@onrail-xyz/binary-layout": "^1.0.0",
+    "@onrail-xyz/amount": "^1.0.0",
+    "@onrail-xyz/common": "^1.0.0",
+    "@noble/hashes": "^1.8.0 || ^2.0.0",
+    "viem": "^2"
+  },
+  "devDependencies": {
+    "@noble/hashes": "^2.2.0",
+    "viem": "^2.55.11",
+    "@onrail-xyz/utils": "1.0.0",
+    "@onrail-xyz/binary-layout": "1.0.0",
+    "@onrail-xyz/common": "1.0.0",
+    "@onrail-xyz/amount": "1.0.0"
+  },
+  "engines": {
+    "node": ">=25.0.0"
+  },
+  "scripts": {
+    "build": "pnpm clean && tsc",
+    "test": "tsc -p tsconfig.test.json && tsx --test tests/**/*.test.ts",
+    "clean": "rm -rf ./dist"
+  }
+}

package/src/client.ts

@@ -0,0 +1,196 @@
+import type { Address, AccessList, Hex } from "viem";
+import type { RoUint8Array, RoArray, RoTuple, Function, OptionalArg } from "@onrail-xyz/utils";
+import { hex, argOf } from "@onrail-xyz/utils";
+import type { Layout, Struct } from "@onrail-xyz/binary-layout";
+import { serialize, isItem, isOmitted, calcStaticSize } from "@onrail-xyz/binary-layout";
+import type { KindWithAtomic } from "@onrail-xyz/amount";
+import { type AmountOrAtomic, toAtomicIfAmount } from "@onrail-xyz/common";
+import type { AbiParam, AbiParamValue, DynamicAbiParam, PaddedSlotLayout } from "./layouting.js";
+import { wordSize, selectorLayout,
+         paddedSlotLayout, abiEncodedBytesItem, signatureOf } from "./layouting.js";
+import type { QueryLayoutTriple } from "./query.js";
+
+//the marker `trailingBytesParam` sets, read only here - nothing outside the spec builder asks
+//  whether a param is the dynamic one
+const isDynamicParam = (param: AbiParam): param is DynamicAbiParam<string, Layout | undefined> =>
+  "dynamic" in param;
+
+//the default spans the whole domain, so the bare `ContractTx` takes an amount of any kind
+export type ContractTx<K extends KindWithAtomic | undefined = KindWithAtomic | undefined> = {
+  to:          Address;
+  from?:       Address;
+  value?:      AmountOrAtomic<K>;
+  data:        RoUint8Array;
+  accessList?: AccessList;
+};
+
+export type ViemTx = {
+  readonly to:          Address;
+  readonly data:        Hex;
+  readonly account?:    Address;
+  readonly value?:      bigint;
+  readonly accessList?: AccessList;
+};
+
+//viem spells call data as hex and values as bigint where this package speaks bytes and amounts,
+//  and calls the sender `account` because it also accepts a whole Account: every field is
+//  converted so that consumers hand the result straight to sendTransaction/estimateGas
+export const toViemTx = (tx: ContractTx): ViemTx => ({
+  to:   tx.to,
+  data: hex.encode(tx.data, true),
+  ...(tx.from       !== undefined && { account:    tx.from                    }),
+  ...(tx.value      !== undefined && { value:      toAtomicIfAmount(tx.value) }),
+  ...(tx.accessList !== undefined && { accessList: tx.accessList              }),
+});
+
+// ---- Contract spec builder ----
+// A spec is a tuple of `abiFunction` rows, [name, params, composer, outputLayout | undefined]. The
+//   signature and the input layout - each param left-padded onto its ABI slot - derive from the
+//   params; the composer turns positional args into the params object, which methods also accept
+//   directly, and exists for the parameter names, which nothing else can carry.
+// Solidity overloads share an ABI name, so a row whose method key must differ from it names
+//   both, key first: `["safeTransferFromWithData", "safeTransferFrom"]`.
+// Read calls (outputLayout defined) return a layout triple for the query system.
+// Write calls (outputLayout undefined) return pre-serialized call data; who sends it is the
+//   transaction's business, not the spec's.
+// Every param is static but for a trailing `trailingBytesParam`, whose offset the parameter
+//   count fixes; two dynamic params would need offsets computed from the tails ahead of them,
+//   which is an encoding pass rather than a layout.
+
+export type ParamsStruct<P extends RoTuple<AbiParam>> =
+  { readonly [E in P[number] as E["name"]]: E["item"] };
+
+//each param's field of the call's layout: static ones left-padded onto their slot, a trailing
+//  dynamic one already ABI-shaped (offset, length, payload, padding)
+export type ParamsLayout<P extends RoTuple<AbiParam>> = {
+  readonly [E in P[number] as E["name"]]:
+    E extends { readonly dynamic: object } ? E["item"] : PaddedSlotLayout<E["item"]>;
+};
+
+//the params' values, positionally and by name
+type ParamValues<P extends RoTuple<AbiParam>> =
+  { [K in keyof P]: P[K] extends AbiParam ? AbiParamValue<P[K]> : never };
+export type ParamsRecord<P extends RoTuple<AbiParam>> =
+  { readonly [E in P[number] as E["name"]]: AbiParamValue<E> };
+
+export type FuncName = string | readonly [key: string, abiName: string];
+export type FuncKey<N extends FuncName> =
+  N extends readonly [infer K extends string, string] ? K : N;
+
+export type FuncSpec<
+  N extends FuncName            = FuncName,
+  P extends RoTuple<AbiParam>   = RoTuple<AbiParam>,
+  C extends Function<any>       = Function<any>,
+  R extends Layout | undefined  = Layout | undefined,
+> = readonly [N, P, C, R];
+type ContractSpec = RoTuple<FuncSpec>;
+
+//the composer is contextually typed from the params, so it is written with names only
+export const abiFunction = <
+  const N extends FuncName,
+  const P extends RoTuple<AbiParam>,
+        C extends (...args: ParamValues<P>) => ParamsRecord<P>,
+  const R extends Layout | undefined = undefined,
+>(name: N, params: P, composer: C, ...output: OptionalArg<R>): FuncSpec<N, P, C, R> =>
+  [name, params, composer, argOf(output)];
+
+type ReadResult<P extends RoTuple<AbiParam>, OL extends Layout> = {
+  readonly to:   Address;
+  readonly data: QueryLayoutTriple<ParamsLayout<P>, OL>;
+};
+
+type WriteResult = Readonly<{
+  to:   Address;
+  data: Uint8Array;
+}>;
+
+//object form first, positional form last: `infer` (and `Parameters`/`ReturnType`) bind to an
+//  overloaded function's last signature, and the positional signature is the one reflection
+//  needs — the object form's parameter is just the params' derived type, recoverable from them
+//  without going through the function type
+type ContractMethodOf<P extends RoTuple<AbiParam>, OL, C extends Function<any>> =
+  OL extends Layout
+  ? ((params: ParamsRecord<P>) => ReadResult<P, OL>) &
+    ((...args: Parameters<C>) => ReadResult<P, OL>)
+  : ((params: ParamsRecord<P>) => WriteResult) &
+    ((...args: Parameters<C>) => WriteResult);
+
+export type ContractMethods<S extends RoTuple<any>> = {
+  readonly [E in S[number] as E extends FuncSpec<infer N> ? FuncKey<N> : never]:
+    E extends FuncSpec<FuncName, infer P, infer C, infer OL>
+    ? ContractMethodOf<P, OL, C>
+    : never;
+};
+
+function resolveArgs(
+  layout:   Struct,
+  composer: Function<any>,
+  args:     RoArray,
+): unknown {
+  //For 0 or 2+ args, it's unambiguously the composer (positional) form.
+  //For a single object arg, it's ambiguous only when the layout has exactly one non-omitted
+  //  field — the arg could be the object form { name: value } or a struct passed positionally.
+  //  We assume object form if the object has exactly one key matching that field's name.
+  //  For 2+ non-omitted fields, a single arg must be object form (positional would have multiple).
+  if (args.length === 1 && typeof args[0] === "object" && args[0] !== null) {
+    let nonOmittedCount = 0;
+    let firstName: string | undefined;
+    for (const [name, field] of Object.entries(layout)) {
+      if (isItem(field) && isOmitted(field))
+        continue;
+      if (++nonOmittedCount > 1)
+        return args[0];
+      firstName = name;
+    }
+    //single non-omitted field: assume object form if the object has exactly one matching key
+    const keys = Object.keys(args[0]);
+    if (keys.length === 1 && keys[0] === firstName)
+      return args[0];
+  }
+  return composer(...args);
+}
+
+export const contractFromSpec = <const S extends ContractSpec>(
+  contract: Address,
+  spec:     S,
+): ContractMethods<S> => {
+  const result: Record<string, Function<any>> = {};
+  for (const [name, params, composer, outputLayout] of spec) {
+    const [key, abiName] = typeof name === "string" ? [name, name] : name;
+    const sig = signatureOf(abiName, params);
+    const dynamicIndex = params.findIndex(isDynamicParam);
+    //a second dynamic param cannot be last either, so the one check covers both
+    if (dynamicIndex >= 0 && dynamicIndex !== params.length - 1)
+      throw new Error(`${sig}: a dynamic parameter must be the only one, and come last`);
+
+    //the dynamic payload follows the whole head, which is not one word per preceding param:
+    //  a static tuple param spans as many slots as it has members
+    const staticFields = params.filter(param => !isDynamicParam(param))
+      .map(param => paddedSlotLayout(param.item));
+    const headSize = staticFields.reduce((sum, field) => sum + calcStaticSize(field)!, wordSize);
+
+    let staticIndex = 0;
+    const inputLayout = Object.fromEntries(params.map(param => [
+      param.name,
+      isDynamicParam(param)
+      ? abiEncodedBytesItem({ layout: param.dynamic.layout, offset: headSize })
+      : staticFields[staticIndex++]!,
+    ]));
+    const layout = selectorLayout(sig)(inputLayout);
+
+    const method = (...args: any[]) => ({
+      to:   contract,
+      data: outputLayout !== undefined
+        ? [layout, resolveArgs(inputLayout, composer, args), outputLayout]
+        : serialize(layout, resolveArgs(inputLayout, composer, args) as any),
+    });
+    //shape-dispatching methods would report length 0; stamp the positional arity so it stays
+    //  observable, e.g. for arity-driven call batching
+    Object.defineProperty(method, "length", { value: composer.length });
+    if (Object.hasOwn(result, key))
+      throw new Error(`duplicate method key: ${key}`);
+
+    result[key] = method;
+  }
+  return result as any;
+};