@onrail-xyz/evm 1.0.0

package/dist/client.js

@@ -0,0 +1,79 @@
+import { hex, argOf } from "@onrail-xyz/utils";
+import { serialize, isItem, isOmitted, calcStaticSize } from "@onrail-xyz/binary-layout";
+import { toAtomicIfAmount } from "@onrail-xyz/common";
+import { wordSize, selectorLayout, paddedSlotLayout, abiEncodedBytesItem, signatureOf } from "./layouting.js";
+//the marker `trailingBytesParam` sets, read only here - nothing outside the spec builder asks
+//  whether a param is the dynamic one
+const isDynamicParam = (param) => "dynamic" in param;
+//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) => ({
+    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 }),
+});
+//the composer is contextually typed from the params, so it is written with names only
+export const abiFunction = (name, params, composer, ...output) => [name, params, composer, argOf(output)];
+function resolveArgs(layout, composer, args) {
+    //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;
+        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 = (contract, spec) => {
+    const result = {};
+    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) => ({
+            to: contract,
+            data: outputLayout !== undefined
+                ? [layout, resolveArgs(inputLayout, composer, args), outputLayout]
+                : serialize(layout, resolveArgs(inputLayout, composer, args)),
+        });
+        //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;
+};

package/dist/eip712.d.ts

@@ -0,0 +1,72 @@
+import type { Address, Hex } from "viem";
+import type { RoUint8Array, RoArray, StrRecord, DeepRo } from "@onrail-xyz/utils";
+import type { BytesNItem } from "./layouting.js";
+import { abiAddressItem, abiBoolItem, uint256Item } from "./layouting.js";
+export type Eip712Field = {
+    readonly name: string;
+    readonly type: string;
+};
+type Eip712Value<T extends string> = string extends T ? Address | boolean | bigint | RoUint8Array | string : T extends "address" ? Address : T extends "bool" ? boolean : T extends `uint${number}` | `int${number}` ? bigint : T extends `bytes${number}` | "bytes" ? RoUint8Array : T extends "string" ? string : never;
+export type Eip712Message<F extends RoArray<Eip712Field> = RoArray<Eip712Field>> = {
+    readonly [E in F[number] as E["name"]]: Eip712Value<E["type"]>;
+};
+declare const domainSeparatorFields: 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";
+}];
+export type Eip712Domain = Partial<Eip712Message<typeof domainSeparatorFields>>;
+export type Eip712Data<Message = StrRecord> = {
+    readonly types: StrRecord<RoArray<Eip712Field>>;
+    readonly primaryType: string;
+    readonly domain: Eip712Domain;
+    readonly message: DeepRo<Message>;
+};
+export type ViemTypedData<T> = T extends RoUint8Array ? Hex : T extends object ? {
+    readonly [K in keyof T]: ViemTypedData<T[K]>;
+} : T;
+export declare const toViemTypedData: <T>(value: T) => ViemTypedData<T>;
+declare const int256Item: {
+    readonly binary: "int";
+    readonly size: 32;
+};
+type WordItem<T extends string> = T extends "bool" ? typeof abiBoolItem : T extends "address" ? typeof abiAddressItem : T extends `uint${number}` ? typeof uint256Item : T extends `int${number}` ? typeof int256Item : T extends `bytes${infer N extends number}` ? BytesNItem<N> : never;
+export type Eip712EncodeDataLayout<F extends RoArray<Eip712Field>> = {
+    readonly [E in F[number] as E["name"]]: WordItem<E["type"]>;
+};
+export declare const eip712EncodeDataLayout: <const F extends RoArray<Eip712Field>>(fields: F) => Eip712EncodeDataLayout<F>;
+export declare const eip712DomainType: (domain: 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";
+})[];
+export declare const guessEip712Domain: (name: string, verifyingContract: Address, chainId: bigint, domainSeparator: RoUint8Array, versionGuesses?: RoArray<string>) => {
+    readonly name: string;
+    readonly version?: string;
+    readonly chainId: bigint;
+    readonly verifyingContract: `0x${string}`;
+};
+export {};
+//# sourceMappingURL=eip712.d.ts.map

package/dist/eip712.d.ts.map

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

package/dist/eip712.js

@@ -0,0 +1,96 @@
+import { bytes, hex, utf8 } from "@onrail-xyz/utils";
+import { serialize } from "@onrail-xyz/binary-layout";
+import { hashItem } from "@onrail-xyz/common";
+import { keccak256 } from "./hashing.js";
+import { wordSize, abiAddressItem, abiBoolItem, uint256Item, bytesNItem } from "./layouting.js";
+const domainSeparatorFields = [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" },
+    { name: "salt", type: "bytes32" },
+];
+//viem spells bytes values as hex where this package speaks bytes: every bytes leaf of domain and
+//  message is converted so that consumers hand the result straight to signTypedData/hashTypedData
+export const toViemTypedData = (value) => (value instanceof Uint8Array
+    ? hex.encode(value, true)
+    : Array.isArray(value)
+        ? value.map(toViemTypedData)
+        : typeof value === "object" && value !== null
+            ? Object.fromEntries(Object.entries(value).map(([k, v]) => [k, toViemTypedData(v)]))
+            : value);
+// ---- encodeData ----
+// A struct's encodeData puts each atomic field on a word, in field order, so a layout spelled
+//   from the field list serializes a message to exactly those bytes and reads one back - which
+//   is how a message is derived from data that already has a word-per-field layout. A dynamic
+//   (`bytes`, `string`), array or struct-typed field takes a word too, but holding a hash this
+//   layout does not compute, so such a field is rejected. Values ride at word width: a `uint8`
+//   field's range is its composer's to keep.
+const int256Item = { binary: "int", size: wordSize };
+const wordItem = (type) => {
+    if (type === "bool")
+        return abiBoolItem;
+    if (type === "address")
+        return abiAddressItem;
+    if (/^uint\d+$/.test(type))
+        return uint256Item;
+    if (/^int\d+$/.test(type))
+        return int256Item;
+    const bytesN = /^bytes(\d+)$/.exec(type);
+    if (bytesN !== null)
+        return bytesNItem(Number(bytesN[1]));
+    throw new Error(`EIP-712 type '${type}' has no encodeData word - only atomic types are encoded`);
+};
+export const eip712EncodeDataLayout = (fields) => Object.fromEntries(fields.map(f => [f.name, wordItem(f.type)]));
+// ---- Domain Separator ----
+//the domain's type as viem derives it - the fields present, in the standard's order - so a message
+//  composed with it hashes identically on both sides
+export const eip712DomainType = (domain) => domainSeparatorFields.filter(f => domain[f.name] !== undefined);
+const associatedLayoutItem = {
+    name: hashItem,
+    version: hashItem,
+    chainId: { binary: "uint", size: wordSize },
+    verifyingContract: abiAddressItem,
+    salt: hashItem,
+};
+const hashString = (s) => keccak256(utf8.encode(s));
+const typeString = (fields) => "EIP712Domain("
+    + domainSeparatorFields //enforces correct order (iterating over fields would not)
+        .filter(dsf => fields.includes(dsf.name))
+        .map(dsf => `${dsf.type} ${dsf.name}`)
+        .join(",")
+    + ")";
+const typeHash = (fields) => hashString(typeString(fields));
+const typeHashItem = (fields) => ({ binary: "bytes", fixed: typeHash(fields) });
+const separatorLayout = (fields) => ({
+    typeHash: typeHashItem(fields),
+    ...Object.fromEntries(domainSeparatorFields //enforces correct order (iterating over fields would not)
+        .filter(dsf => fields.includes(dsf.name))
+        .map(dsf => [dsf.name, associatedLayoutItem[dsf.name]])),
+});
+const matchesHash = (layout, candidate, expected) => bytes.equals(keccak256(serialize(layout, candidate)), expected);
+// ---- Domain Resolution ----
+// Reconstructs the domain of tokens that only expose DOMAIN_SEPARATOR() by brute-forcing the
+// version field against the on-chain hash. Covers the { name, chainId, verifyingContract } domain
+// with an optional version, i.e. everything that follows EIP-2612's reference implementation.
+const typicalDomainFields = ["name", "chainId", "verifyingContract"];
+const unversionedLayout = separatorLayout(typicalDomainFields);
+const versionedLayout = separatorLayout([...typicalDomainFields, "version"]);
+const guessDomainSeparatorVersion = (known, domainSeparator, guesses) => {
+    for (const version of guesses)
+        if (matchesHash(versionedLayout, { ...known, version: hashString(version) }, domainSeparator))
+            return version;
+    throw new Error("Could not determine domain separator version");
+};
+//reconstructs the EIP-712 domain from on-chain data, guesses the version if needed
+export const guessEip712Domain = (name, verifyingContract, chainId, domainSeparator, versionGuesses = ["1", "2", "0"]) => {
+    const known = { name: hashString(name), chainId, verifyingContract };
+    return {
+        name,
+        ...(matchesHash(unversionedLayout, known, domainSeparator)
+            ? {}
+            : { version: guessDomainSeparatorVersion(known, domainSeparator, versionGuesses) }),
+        chainId,
+        verifyingContract,
+    };
+};

package/dist/erc20.d.ts

@@ -0,0 +1,113 @@
+import type { Address } from "viem";
+import type { OptionalArg } from "@onrail-xyz/utils";
+import type { KindWithAtomic } from "@onrail-xyz/amount";
+import type { ContractMethods } from "./client.js";
+declare const erc20Spec: <const K extends KindWithAtomic | undefined = undefined>(...kind: OptionalArg<K>) => readonly [import("./client.js").FuncSpec<"name", readonly [], () => {}, Readonly<{
+    custom: Readonly<{
+        to: import("@onrail-xyz/utils").Function<[{
+            readonly item: import("@onrail-xyz/utils").RoUint8Array;
+            readonly postPadding: import("@onrail-xyz/utils").RoUint8Array;
+        }], string>;
+        from: import("@onrail-xyz/utils").Function<[string], {
+            readonly item: import("@onrail-xyz/utils").RoUint8Array;
+            readonly postPadding: import("@onrail-xyz/utils").RoUint8Array;
+        }>;
+    }>;
+    readonly binary: "bytes";
+    readonly layout: {
+        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";
+        };
+    };
+}>>, import("./client.js").FuncSpec<"symbol", readonly [], () => {}, Readonly<{
+    custom: Readonly<{
+        to: import("@onrail-xyz/utils").Function<[{
+            readonly item: import("@onrail-xyz/utils").RoUint8Array;
+            readonly postPadding: import("@onrail-xyz/utils").RoUint8Array;
+        }], string>;
+        from: import("@onrail-xyz/utils").Function<[string], {
+            readonly item: import("@onrail-xyz/utils").RoUint8Array;
+            readonly postPadding: import("@onrail-xyz/utils").RoUint8Array;
+        }>;
+    }>;
+    readonly binary: "bytes";
+    readonly layout: {
+        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";
+        };
+    };
+}>>, import("./client.js").FuncSpec<"decimals", readonly [], () => {}, 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>;
+}>>, import("./client.js").FuncSpec<"totalSupply", readonly [], () => {}, import("@onrail-xyz/common").AmountItem<32, K>>, import("./client.js").FuncSpec<"balanceOf", readonly [import("./layouting.js").AbiParam<"owner", "address", import("./layouting.js").AddressItem, `0x${string}`>], (owner: `0x${string}`) => {
+    owner: `0x${string}`;
+}, import("@onrail-xyz/common").AmountItem<32, K>>, import("./client.js").FuncSpec<"allowance", 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}`>], (owner: `0x${string}`, spender: `0x${string}`) => {
+    owner: `0x${string}`;
+    spender: `0x${string}`;
+}, import("@onrail-xyz/common").AmountItem<32, K>>, import("./client.js").FuncSpec<"approve", readonly [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>>], (spender: `0x${string}`, value: import("@onrail-xyz/common").AmountOr<K, bigint>) => {
+    spender: `0x${string}`;
+    value: import("@onrail-xyz/common").AmountOr<K, bigint>;
+}, undefined>, import("./client.js").FuncSpec<"transfer", readonly [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>>], (to: `0x${string}`, value: import("@onrail-xyz/common").AmountOr<K, bigint>) => {
+    to: `0x${string}`;
+    value: import("@onrail-xyz/common").AmountOr<K, bigint>;
+}, undefined>, import("./client.js").FuncSpec<"transferFrom", 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>>], (from: `0x${string}`, to: `0x${string}`, value: import("@onrail-xyz/common").AmountOr<K, bigint>) => {
+    from: `0x${string}`;
+    to: `0x${string}`;
+    value: import("@onrail-xyz/common").AmountOr<K, bigint>;
+}, undefined>];
+export declare const erc20: <const K extends KindWithAtomic | undefined = undefined>(contract: Address, ...kind: OptionalArg<K>) => ContractMethods<ReturnType<typeof erc20Spec<K>>>;
+export declare const erc20Events: <const K extends KindWithAtomic | undefined = undefined>(...kind: OptionalArg<K>) => readonly [import("./layouting.js").SigVariantOf<"Transfer", 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").SigVariantOf<"Approval", 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>>]>];
+declare const allowanceAdjustersSpec: <const K extends KindWithAtomic | undefined = undefined>(...kind: OptionalArg<K>) => readonly [import("./client.js").FuncSpec<"increaseAllowance", readonly [import("./layouting.js").AbiParam<"spender", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"addedValue", "uint256", import("@onrail-xyz/common").AmountItem<32, K>, import("@onrail-xyz/common").AmountOr<K, bigint>>], (spender: `0x${string}`, addedValue: import("@onrail-xyz/common").AmountOr<K, bigint>) => {
+    spender: `0x${string}`;
+    addedValue: import("@onrail-xyz/common").AmountOr<K, bigint>;
+}, undefined>, import("./client.js").FuncSpec<"decreaseAllowance", readonly [import("./layouting.js").AbiParam<"spender", "address", import("./layouting.js").AddressItem, `0x${string}`>, import("./layouting.js").AbiParam<"subtractedValue", "uint256", import("@onrail-xyz/common").AmountItem<32, K>, import("@onrail-xyz/common").AmountOr<K, bigint>>], (spender: `0x${string}`, subtractedValue: import("@onrail-xyz/common").AmountOr<K, bigint>) => {
+    spender: `0x${string}`;
+    subtractedValue: import("@onrail-xyz/common").AmountOr<K, bigint>;
+}, undefined>];
+export declare const allowanceAdjusters: <const K extends KindWithAtomic | undefined = undefined>(contract: Address, ...kind: OptionalArg<K>) => ContractMethods<ReturnType<typeof allowanceAdjustersSpec<K>>>;
+export {};
+//# sourceMappingURL=erc20.d.ts.map

package/dist/erc20.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"erc20.d.ts","sourceRoot":"","sources":["../src/erc20.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAC;AACpC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAGzD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAgBnD,QAAA,MAAM,SAAS,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,GAAG,SAAS,GAAG,SAAS,WAC9D,WAAW,CAAC,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BAbwB,MAAM;2BAAQ,CAAC;;;;;;;;;;;;;;;;;;;;;cA6B/D,CAAC;AAEF,eAAO,MAAM,KAAK,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,GAAG,SAAS,GAAG,SAAS,YAChE,OAAO,WACP,WAAW,CAAC,CAAC,CAAC,KACvB,eAAe,CAAC,UAAU,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,CACF,CAAC;AAGjD,eAAO,MAAM,WAAW,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,GAAG,SAAS,GAAG,SAAS,WACvE,WAAW,CAAC,CAAC,CAAC,02BAOxB,CAAC;AAEF,QAAA,MAAM,sBAAsB,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,GAAG,SAAS,GAAG,SAAS,WAC3E,WAAW,CAAC,CAAC,CAAC;;;;;;cAUxB,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAI,KAAK,CAAC,CAAC,SAAS,cAAc,GAAG,SAAS,GAAG,SAAS,YAC7E,OAAO,WACP,WAAW,CAAC,CAAC,CAAC,KACvB,eAAe,CAAC,UAAU,CAAC,OAAO,sBAAsB,CAAC,CAAC,CAAC,CAAC,CACF,CAAC"}

package/dist/erc20.js

@@ -0,0 +1,44 @@
+import { utf8Conversion, withCustom } from "@onrail-xyz/binary-layout";
+import { paddedSlotLayout, evmAmountItem, abiEncodedBytesItem, sigVariant, addressParam, amountParam } from "./layouting.js";
+import { abiFunction, contractFromSpec } from "./client.js";
+const abiStringItem = withCustom(abiEncodedBytesItem(), utf8Conversion);
+const decimalsItem = paddedSlotLayout({ binary: "uint", size: 1 });
+const from = addressParam("from");
+const to = addressParam("to");
+const owner = addressParam("owner");
+const spender = addressParam("spender");
+const valueParam = (...kind) => amountParam("value", "uint256", ...kind);
+const erc20Spec = (...kind) => {
+    const value = valueParam(...kind);
+    const amountItem = evmAmountItem(...kind);
+    const abiF = abiFunction;
+    return [
+        abiF("name", [], () => ({}), abiStringItem),
+        abiF("symbol", [], () => ({}), abiStringItem),
+        abiF("decimals", [], () => ({}), decimalsItem),
+        abiF("totalSupply", [], () => ({}), amountItem),
+        abiF("balanceOf", [owner], owner => ({ owner }), amountItem),
+        abiF("allowance", [owner, spender], (owner, spender) => ({ owner, spender }), amountItem),
+        abiF("approve", [spender, value], (spender, value) => ({ spender, value })),
+        abiF("transfer", [to, value], (to, value) => ({ to, value })),
+        abiF("transferFrom", [from, to, value], (from, to, value) => ({ from, to, value })),
+    ];
+};
+export const erc20 = (contract, ...kind) => contractFromSpec(contract, erc20Spec(...kind));
+//`Transfer` and `Approval` as `buildParseEvent` variants; `allowanceAdjusters` emits the latter
+export const erc20Events = (...kind) => {
+    const value = valueParam(...kind);
+    return [
+        sigVariant("Transfer", from, to, value),
+        sigVariant("Approval", owner, spender, value),
+    ];
+};
+const allowanceAdjustersSpec = (...kind) => {
+    const addedValue = amountParam("addedValue", "uint256", ...kind);
+    const subtractedValue = amountParam("subtractedValue", "uint256", ...kind);
+    return [
+        abiFunction("increaseAllowance", [spender, addedValue], (spender, addedValue) => ({ spender, addedValue })),
+        abiFunction("decreaseAllowance", [spender, subtractedValue], (spender, subtractedValue) => ({ spender, subtractedValue })),
+    ];
+};
+export const allowanceAdjusters = (contract, ...kind) => contractFromSpec(contract, allowanceAdjustersSpec(...kind));