@onrail-xyz/evm 1.0.0

package/dist/erc3009.d.ts

@@ -0,0 +1,416 @@
+import type { Address } from "viem";
+import type { RoUint8Array, 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, Eip712Message } from "./eip712.js";
+declare const erc3009Spec: <const K extends KindWithAtomic | undefined = undefined>(...kind: OptionalArg<K>) => readonly [import("./client.js").FuncSpec<"authorizationState", readonly [import("./layouting.js").AbiParam<"authorizer", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"nonce", "bytes32", {
+    readonly binary: "bytes";
+    readonly size: 32;
+}, RoUint8Array>], (authorizer: `0x${string}`, nonce: RoUint8Array) => {
+    authorizer: `0x${string}`;
+    nonce: RoUint8Array;
+}, Readonly<{
+    binary: "bytes";
+    layout: {
+        readonly _padding: {
+            readonly binary: "bytes";
+            readonly fixed: Uint8Array<ArrayBuffer>;
+        };
+        readonly item: {
+            readonly binary: "uint";
+            readonly size: 1;
+            readonly custom: {
+                readonly to: (encoded: number) => boolean;
+                readonly from: (value: boolean) => number;
+            };
+        };
+    };
+    custom: import("@onrail-xyz/binary-layout").Conversion<{
+        readonly item: boolean;
+    }, boolean>;
+}>>, import("./client.js").FuncSpec<"transferWithAuthorization", readonly [import("./layouting.js").AbiParam<"from", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"to", "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<"validAfter", "uint256", import("@onrail-xyz/binary-layout").TimestampItem<{
+    readonly size: 32;
+}>, Date>, import("./layouting.js").AbiParam<"validBefore", "uint256", import("@onrail-xyz/binary-layout").TimestampItem<{
+    readonly size: 32;
+    readonly saturateAs: "infinity";
+}>, "infinity" | Date>, import("./layouting.js").AbiParam<"nonce", "bytes32", {
+    readonly binary: "bytes";
+    readonly size: 32;
+}, RoUint8Array>, 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: RoUint8Array;
+        readonly s: RoUint8Array;
+    }, RoUint8Array>;
+}>, RoUint8Array>], (from: `0x${string}`, to: `0x${string}`, value: import("@onrail-xyz/common").AmountOr<K, bigint>, validAfter: Date, validBefore: "infinity" | Date, nonce: RoUint8Array, signature: RoUint8Array) => {
+    from: `0x${string}`;
+    to: `0x${string}`;
+    value: import("@onrail-xyz/common").AmountOr<K, bigint>;
+    validAfter: Date;
+    validBefore: "infinity" | Date;
+    nonce: RoUint8Array;
+    signature: RoUint8Array;
+}, undefined>, import("./client.js").FuncSpec<"receiveWithAuthorization", readonly [import("./layouting.js").AbiParam<"from", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"to", "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<"validAfter", "uint256", import("@onrail-xyz/binary-layout").TimestampItem<{
+    readonly size: 32;
+}>, Date>, import("./layouting.js").AbiParam<"validBefore", "uint256", import("@onrail-xyz/binary-layout").TimestampItem<{
+    readonly size: 32;
+    readonly saturateAs: "infinity";
+}>, "infinity" | Date>, import("./layouting.js").AbiParam<"nonce", "bytes32", {
+    readonly binary: "bytes";
+    readonly size: 32;
+}, RoUint8Array>, 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: RoUint8Array;
+        readonly s: RoUint8Array;
+    }, RoUint8Array>;
+}>, RoUint8Array>], (from: `0x${string}`, to: `0x${string}`, value: import("@onrail-xyz/common").AmountOr<K, bigint>, validAfter: Date, validBefore: "infinity" | Date, nonce: RoUint8Array, signature: RoUint8Array) => {
+    from: `0x${string}`;
+    to: `0x${string}`;
+    value: import("@onrail-xyz/common").AmountOr<K, bigint>;
+    validAfter: Date;
+    validBefore: "infinity" | Date;
+    nonce: RoUint8Array;
+    signature: RoUint8Array;
+}, undefined>, import("./client.js").FuncSpec<"cancelAuthorization", readonly [import("./layouting.js").AbiParam<"authorizer", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"nonce", "bytes32", {
+    readonly binary: "bytes";
+    readonly size: 32;
+}, RoUint8Array>, 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: RoUint8Array;
+        readonly s: RoUint8Array;
+    }, RoUint8Array>;
+}>, RoUint8Array>], (authorizer: `0x${string}`, nonce: RoUint8Array, signature: RoUint8Array) => {
+    authorizer: `0x${string}`;
+    nonce: RoUint8Array;
+    signature: RoUint8Array;
+}, undefined>];
+export declare const erc3009: <const K extends KindWithAtomic | undefined = undefined>(contract: Address, ...kind: OptionalArg<K>) => ContractMethods<ReturnType<typeof erc3009Spec<K>>>;
+export declare const erc3009Events: readonly [import("./layouting.js").SigVariantOf<"AuthorizationUsed", readonly [import("./layouting.js").AbiParam<"authorizer", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"nonce", "bytes32", {
+    readonly binary: "bytes";
+    readonly size: 32;
+}, RoUint8Array>]>, import("./layouting.js").SigVariantOf<"AuthorizationCanceled", readonly [import("./layouting.js").AbiParam<"authorizer", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"nonce", "bytes32", {
+    readonly binary: "bytes";
+    readonly size: 32;
+}, RoUint8Array>]>];
+declare const authorizationType: readonly [{
+    readonly name: "from";
+    readonly type: "address";
+}, {
+    readonly name: "to";
+    readonly type: "address";
+}, {
+    readonly name: "value";
+    readonly type: "uint256";
+}, {
+    readonly name: "validAfter";
+    readonly type: "uint256";
+}, {
+    readonly name: "validBefore";
+    readonly type: "uint256";
+}, {
+    readonly name: "nonce";
+    readonly type: "bytes32";
+}];
+declare const cancelAuthorizationType: readonly [{
+    readonly name: "authorizer";
+    readonly type: "address";
+}, {
+    readonly name: "nonce";
+    readonly type: "bytes32";
+}];
+export type Eip3009AuthorizationMessage = Eip712Message<typeof authorizationType>;
+export type Eip3009CancelMessage = Eip712Message<typeof cancelAuthorizationType>;
+export declare const randomAuthorizationNonce: () => Uint8Array;
+export declare const composeTransferWithAuthorizationMsg: (from: Address, to: Address, value: AmountOrAtomic, domain: Eip712Domain, nonce: RoUint8Array, validBefore?: Deadline, validAfter?: Date) => {
+    readonly types: {
+        readonly [x: string]: ({
+            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 [{
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly name: "validAfter";
+            readonly type: "uint256";
+        }, {
+            readonly name: "validBefore";
+            readonly type: "uint256";
+        }, {
+            readonly name: "nonce";
+            readonly type: "bytes32";
+        }];
+        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 primaryType: "ReceiveWithAuthorization" | "TransferWithAuthorization";
+    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 from: `0x${string}`;
+        readonly to: `0x${string}`;
+        readonly value: bigint;
+        readonly validAfter: bigint;
+        readonly validBefore: bigint;
+        readonly nonce: RoUint8Array;
+    };
+};
+export declare const composeReceiveWithAuthorizationMsg: (from: Address, to: Address, value: AmountOrAtomic, domain: Eip712Domain, nonce: RoUint8Array, validBefore?: Deadline, validAfter?: Date) => {
+    readonly types: {
+        readonly [x: string]: ({
+            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 [{
+            readonly name: "from";
+            readonly type: "address";
+        }, {
+            readonly name: "to";
+            readonly type: "address";
+        }, {
+            readonly name: "value";
+            readonly type: "uint256";
+        }, {
+            readonly name: "validAfter";
+            readonly type: "uint256";
+        }, {
+            readonly name: "validBefore";
+            readonly type: "uint256";
+        }, {
+            readonly name: "nonce";
+            readonly type: "bytes32";
+        }];
+        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 primaryType: "ReceiveWithAuthorization" | "TransferWithAuthorization";
+    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 from: `0x${string}`;
+        readonly to: `0x${string}`;
+        readonly value: bigint;
+        readonly validAfter: bigint;
+        readonly validBefore: bigint;
+        readonly nonce: RoUint8Array;
+    };
+};
+export declare const composeCancelAuthorizationMsg: (authorizer: Address, domain: Eip712Domain, nonce: RoUint8Array) => {
+    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 CancelAuthorization: readonly [{
+            readonly name: "authorizer";
+            readonly type: "address";
+        }, {
+            readonly name: "nonce";
+            readonly type: "bytes32";
+        }];
+    };
+    readonly primaryType: "CancelAuthorization";
+    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 authorizer: `0x${string}`;
+        readonly nonce: RoUint8Array;
+    };
+};
+export {};
+//# sourceMappingURL=erc3009.d.ts.map

package/dist/erc3009.d.ts.map

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

package/dist/erc3009.js

@@ -0,0 +1,72 @@
+import { toAtomicIfAmount, hashItem } from "@onrail-xyz/common";
+import { deadlineItem, evmTimestampItem, abiBoolItem, abiSignatureItem, sigVariant, abiParam, amountParam, addressParam } from "./layouting.js";
+import { abiFunction, contractFromSpec } from "./client.js";
+import { eip712DomainType } from "./eip712.js";
+const from = addressParam("from");
+const to = addressParam("to");
+const authorizer = addressParam("authorizer");
+//the standard's nonce is a caller-chosen bytes32, unrelated to EIP-2612's sequential uint256
+const nonce = abiParam("nonce", "bytes32", hashItem);
+const validAfter = abiParam("validAfter", "uint256", evmTimestampItem);
+const validBefore = abiParam("validBefore", "uint256", deadlineItem);
+const signature = abiParam("signature", "uint8,bytes32,bytes32", abiSignatureItem);
+const erc3009Spec = (...kind) => {
+    const value = amountParam("value", "uint256", ...kind);
+    //one parameter list under two names: the receiving variant binds the submitter to be `to`
+    const withAuthorization = (name) => abiFunction(name, [from, to, value, validAfter, validBefore, nonce, signature], (from, to, value, validAfter, validBefore, nonce, signature) => ({ from, to, value, validAfter, validBefore, nonce, signature }));
+    return [
+        abiFunction("authorizationState", [authorizer, nonce], (authorizer, nonce) => ({ authorizer, nonce }), abiBoolItem),
+        withAuthorization("transferWithAuthorization"),
+        withAuthorization("receiveWithAuthorization"),
+        abiFunction("cancelAuthorization", [authorizer, nonce, signature], (authorizer, nonce, signature) => ({ authorizer, nonce, signature })),
+    ];
+};
+export const erc3009 = (contract, ...kind) => contractFromSpec(contract, erc3009Spec(...kind));
+//the standard's events as `buildParseEvent` variants; its reverts are left to implementations
+export const erc3009Events = [
+    sigVariant("AuthorizationUsed", authorizer, nonce),
+    sigVariant("AuthorizationCanceled", authorizer, nonce),
+];
+// ---- EIP-3009 Authorization Messages ----
+const authorizationType = [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" },
+];
+const cancelAuthorizationType = [
+    { name: "authorizer", type: "address" },
+    { name: "nonce", type: "bytes32" },
+];
+export const randomAuthorizationNonce = () => crypto.getRandomValues(new Uint8Array(32));
+//one struct under two names: the receiving variant additionally binds the submitter to be `to`
+const composeAuthorization = (primaryType) => (from, to, value, domain, nonce, validBefore = "infinity", validAfter = new Date(0)) => {
+    const atomic = toAtomicIfAmount(value);
+    if (atomic < 0n)
+        throw new Error("Value must not be negative");
+    return {
+        types: { EIP712Domain: eip712DomainType(domain), [primaryType]: authorizationType },
+        primaryType,
+        domain,
+        message: { from,
+            to,
+            value: atomic,
+            validAfter: evmTimestampItem.custom.from(validAfter),
+            validBefore: deadlineItem.custom.from(validBefore),
+            nonce,
+        },
+    };
+};
+//compose an EIP-3009 authorization; `toViemTypedData` bridges it to viem's signing calls
+export const composeTransferWithAuthorizationMsg = composeAuthorization("TransferWithAuthorization");
+export const composeReceiveWithAuthorizationMsg = composeAuthorization("ReceiveWithAuthorization");
+export const composeCancelAuthorizationMsg = (authorizer, domain, nonce) => ({
+    types: { EIP712Domain: eip712DomainType(domain),
+        CancelAuthorization: cancelAuthorizationType,
+    },
+    primaryType: "CancelAuthorization",
+    domain,
+    message: { authorizer, nonce },
+});

package/dist/hashing.d.ts

@@ -0,0 +1,2 @@
+export { keccak_256 as keccak256, sha3_256 } from "@noble/hashes/sha3.js";
+//# sourceMappingURL=hashing.d.ts.map

package/dist/hashing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hashing.d.ts","sourceRoot":"","sources":["../src/hashing.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,IAAI,SAAS,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/hashing.js

@@ -0,0 +1 @@
+export { keccak_256 as keccak256, sha3_256 } from "@noble/hashes/sha3.js";

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./client.js";
+export * from "./eip712.js";
+export * from "./erc20.js";
+export * from "./erc3009.js";
+export * from "./hashing.js";
+export * from "./layouting.js";
+export * from "./parsing.js";
+export * from "./permit.js";
+export * from "./query.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,gBAAgB,CAAC;AAC/B,cAAc,cAAc,CAAC;AAC7B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./client.js";
+export * from "./eip712.js";
+export * from "./erc20.js";
+export * from "./erc3009.js";
+export * from "./hashing.js";
+export * from "./layouting.js";
+export * from "./parsing.js";
+export * from "./permit.js";
+export * from "./query.js";