@volga-sh/evm-ghostcall 0.0.3 → 0.0.4

package/README.md

@@ -1,12 +1,11 @@
 # ghostcall
 
-`ghostcall` batches EVM blockchain reads without deployment dependencies.
+`ghostcall` batches EVM contract reads without deploying a Multicall contract.
 
 ## Documentation
 
-The docs live at [ghostcall.volga.sh](https://ghostcall.volga.sh).
-
-Start there for installation, examples, the API reference, protocol details, and endpoint limit notes.
+Start at [ghostcall.volga.sh](https://ghostcall.volga.sh) for the setup guide,
+recipes, API reference, protocol, and size limits.
 
 ## Install
 
@@ -14,16 +13,19 @@ Start there for installation, examples, the API reference, protocol details, and
 npm install @volga-sh/evm-ghostcall
 ```
 
-## Quick Start
+## Quick start
+
+This example uses viem for its client and ABI definition. ghostcall uses ox
+internally to encode arguments and decode results:
 
-This example uses viem for the EIP-1193-compatible client and ABI helpers. Install it with `npm install viem` if your app does not already use it.
+```sh
+npm install viem
+```
 
 ```ts
 import { aggregateDecodedCalls } from "@volga-sh/evm-ghostcall";
 import {
 	createPublicClient,
-	decodeFunctionResult,
-	encodeFunctionData,
 	http,
 	parseAbi,
 } from "viem";
@@ -34,35 +36,55 @@ const client = createPublicClient({
 	transport: http(),
 });
 
-const erc20Abi = parseAbi(["function totalSupply() view returns (uint256)"]);
+const abi = parseAbi(["function totalSupply() view returns (uint256)"]);
+const token = "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2";
 
 const [totalSupply] = await aggregateDecodedCalls(client, [
 	{
-		to: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
-		data: encodeFunctionData({
-			abi: erc20Abi,
-			functionName: "totalSupply",
-		}),
-		decodeResult: (returnData) =>
-			decodeFunctionResult({
-				abi: erc20Abi,
-				functionName: "totalSupply",
-				data: returnData,
-			}),
+		to: token,
+		abi,
+		functionName: "totalSupply",
 	},
 ]);
+// totalSupply is inferred as bigint.
 ```
 
-See the [Getting Started guide](https://ghostcall.volga.sh/getting-started/) for a complete viem example with ABI encoding and decoding.
+Function names, arguments, and results are inferred from the ABI. Functions
+with inputs require `args`, for example `args: [owner]` for `balanceOf`.
+Keep ABIs literal with `as const`, viem's `parseAbi`, or ox's `Abi.from`.
+
+For already-encoded calldata, use the raw API:
+
+```ts
+import { aggregateCalls } from "@volga-sh/evm-ghostcall";
+
+const results = await aggregateCalls(client, [
+	{ to: token, data: "0x18160ddd" },
+]);
+// [{ success: true, returnData: "0x..." }]
+```
+
+`aggregateDecodedCalls()` also accepts raw `data` with a custom `decodeResult`
+callback, including in the same batch as ABI calls. Each entry uses either ABI
+fields or raw calldata; TypeScript rejects entries that mix the two forms.
+
+See [Getting Started](https://ghostcall.volga.sh/getting-started/) for a complete
+two-call walkthrough.
 
 ## API
 
-- `aggregateDecodedCalls()` sends a strict batch and returns decoded values.
-- `aggregateCalls()` sends a batch and returns raw `{ success, returnData }` entries.
-- `encodeCalls()` builds the CREATE-style `eth_call` data payload.
-- `decodeResults()` parses the packed ghostcall response.
+- `aggregateDecodedCalls()` accepts ABI calls or custom decoders and returns a typed result tuple.
+- `aggregateCalls()` sends calls and returns raw success or failure results.
+- `encodeCalls()` builds request data for an `eth_call` without `to`.
+- `decodeResults()` parses a raw ghostcall response.
+
+Read the [API reference](https://ghostcall.volga.sh/api/) for signatures,
+options, return types, and errors.
 
-Full reference: [API docs](https://ghostcall.volga.sh/api/).
+The public type surface contains seven types, including ghostcall's own `Hex`.
+`GhostcallAggregateCall` is merged into `GhostcallCall`. See
+[type import migration](https://ghostcall.volga.sh/api/types/#migrating-type-imports)
+for the removed helper aliases. Runtime exports are unchanged.
 
 ## Development
 
@@ -73,11 +95,12 @@ npm run test
 npm run check
 ```
 
-Docs are built with Astro Starlight:
+To work on the documentation:
 
 ```sh
 npm run docs:dev
 npm run docs:build
 ```
 
-The repository is hosted at [github.com/volga-sh/ghostcall](https://github.com/volga-sh/ghostcall).
+The source is hosted at
+[github.com/volga-sh/ghostcall](https://github.com/volga-sh/ghostcall).

package/dist/sdk/abi.d.ts

@@ -0,0 +1,39 @@
+import type { Abi } from "ox/Abi";
+import * as AbiFunction from "ox/AbiFunction";
+import type * as AbiItem from "ox/AbiItem";
+import type { GhostcallDecodedCall, Hex } from "./index.ts";
+type FunctionCall<TFunction extends AbiFunction.AbiFunction> = TFunction extends AbiFunction.AbiFunction ? {
+    functionName: TFunction["name"];
+} & (TFunction["inputs"] extends readonly [] ? {
+    args?: readonly [];
+} : {
+    args: NonNullable<AbiFunction.encodeData.Args<TFunction>[0]>;
+}) : never;
+/**
+ * An ABI-described call. A literal ABI determines valid function names and args.
+ * Use `as const` or an ABI parser to retain those literal types.
+ */
+type GhostcallAbiCall<TAbi extends Abi = Abi> = {
+    to: Hex;
+    abi: TAbi;
+    data?: never;
+    decodeResult?: never;
+    allowFailure?: never;
+} & (Abi extends TAbi ? {
+    functionName: string;
+    args?: readonly unknown[];
+} : FunctionCall<Extract<TAbi[number], {
+    type: "function";
+}>>);
+type CallFunctionName<TCall extends GhostcallAbiCall> = TCall["functionName"] & AbiFunction.Name<TCall["abi"]>;
+type CallArguments<TCall extends GhostcallAbiCall> = TCall extends {
+    args: infer TArgs extends readonly unknown[];
+} ? TArgs : readonly [];
+type ResolvedFunction<TCall extends GhostcallAbiCall> = AbiItem.fromAbi.Options<TCall["abi"], CallFunctionName<TCall>> extends AbiItem.fromAbi.Options<TCall["abi"], CallFunctionName<TCall>, infer TArgs> ? AbiItem.fromAbi.ReturnType<TCall["abi"], CallFunctionName<TCall>, Extract<CallArguments<TCall>, TArgs>, AbiFunction.AbiFunction> : never;
+/** The decoded result of an ABI call, including argument-selected overloads. */
+type GhostcallAbiResult<TCall extends GhostcallAbiCall> = AbiFunction.decodeResult.ReturnType<Extract<ResolvedFunction<TCall>, AbiFunction.AbiFunction>>;
+/** Bind encoding and decoding to the same resolved ABI function. */
+declare function prepareAbiCall(call: GhostcallAbiCall): GhostcallDecodedCall;
+export type { GhostcallAbiCall, GhostcallAbiResult };
+export { prepareAbiCall };
+//# sourceMappingURL=abi.d.ts.map

package/dist/sdk/abi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi.d.ts","sourceRoot":"","sources":["../../src/sdk/abi.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AAC9C,OAAO,KAAK,KAAK,OAAO,MAAM,YAAY,CAAC;AAE3C,OAAO,KAAK,EAAE,oBAAoB,EAAE,GAAG,EAAE,MAAM,YAAY,CAAC;AAG5D,KAAK,YAAY,CAAC,SAAS,SAAS,WAAW,CAAC,WAAW,IAC1D,SAAS,SAAS,WAAW,CAAC,WAAW,GACtC;IACA,YAAY,EAAE,SAAS,CAAC,MAAM,CAAC,CAAC;CAChC,GAAG,CAAC,SAAS,CAAC,QAAQ,CAAC,SAAS,SAAS,EAAE,GACzC;IAAE,IAAI,CAAC,EAAE,SAAS,EAAE,CAAA;CAAE,GACtB;IAAE,IAAI,EAAE,WAAW,CAAC,WAAW,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;CAAE,CAAC,GACnE,KAAK,CAAC;AAEV;;;GAGG;AACH,KAAK,gBAAgB,CAAC,IAAI,SAAS,GAAG,GAAG,GAAG,IAAI;IAC/C,EAAE,EAAE,GAAG,CAAC;IACR,GAAG,EAAE,IAAI,CAAC;IACV,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,YAAY,CAAC,EAAE,KAAK,CAAC;CACrB,GAAG,CAAC,GAAG,SAAS,IAAI,GAClB;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,SAAS,OAAO,EAAE,CAAA;CAAE,GACnD,YAAY,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAAC,CAAC,CAAC,CAAC;AAE9D,KAAK,gBAAgB,CAAC,KAAK,SAAS,gBAAgB,IAAI,KAAK,CAAC,cAAc,CAAC,GAC5E,WAAW,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;AAEhC,KAAK,aAAa,CAAC,KAAK,SAAS,gBAAgB,IAAI,KAAK,SAAS;IAClE,IAAI,EAAE,MAAM,KAAK,SAAS,SAAS,OAAO,EAAE,CAAC;CAC7C,GACE,KAAK,GACL,SAAS,EAAE,CAAC;AAIf,KAAK,gBAAgB,CAAC,KAAK,SAAS,gBAAgB,IACnD,OAAO,CAAC,OAAO,CAAC,OAAO,CACtB,KAAK,CAAC,KAAK,CAAC,EACZ,gBAAgB,CAAC,KAAK,CAAC,CACvB,SAAS,OAAO,CAAC,OAAO,CAAC,OAAO,CAChC,KAAK,CAAC,KAAK,CAAC,EACZ,gBAAgB,CAAC,KAAK,CAAC,EACvB,MAAM,KAAK,CACX,GACE,OAAO,CAAC,OAAO,CAAC,UAAU,CAC1B,KAAK,CAAC,KAAK,CAAC,EACZ,gBAAgB,CAAC,KAAK,CAAC,EACvB,OAAO,CAAC,aAAa,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,EACpC,WAAW,CAAC,WAAW,CACvB,GACA,KAAK,CAAC;AAEV,gFAAgF;AAChF,KAAK,kBAAkB,CAAC,KAAK,SAAS,gBAAgB,IACrD,WAAW,CAAC,YAAY,CAAC,UAAU,CAClC,OAAO,CAAC,gBAAgB,CAAC,KAAK,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,CACzD,CAAC;AAEH,oEAAoE;AACpE,iBAAS,cAAc,CAAC,IAAI,EAAE,gBAAgB,GAAG,oBAAoB,CAoBpE;AAED,YAAY,EAAE,gBAAgB,EAAE,kBAAkB,EAAE,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/sdk/abi.js

@@ -0,0 +1,20 @@
+import * as AbiFunction from "ox/AbiFunction";
+/** Bind encoding and decoding to the same resolved ABI function. */
+function prepareAbiCall(call) {
+    const args = call.args ?? [];
+    const abiFunction = AbiFunction.fromAbi(call.abi, call.functionName, {
+        args,
+    });
+    // ox permits selector-only encoding with no args. At this wire boundary,
+    // missing arguments must fail before RPC, including for dynamically loaded ABIs.
+    if (args.length !== abiFunction.inputs.length) {
+        throw new TypeError(`${call.functionName} expects ${abiFunction.inputs.length} arguments, received ${args.length}`);
+    }
+    return {
+        to: call.to,
+        data: AbiFunction.encodeData(abiFunction, args),
+        decodeResult: (returnData) => AbiFunction.decodeResult(abiFunction, returnData),
+    };
+}
+export { prepareAbiCall };
+//# sourceMappingURL=abi.js.map

package/dist/sdk/abi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"abi.js","sourceRoot":"","sources":["../../src/sdk/abi.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,WAAW,MAAM,gBAAgB,CAAC;AA+D9C,oEAAoE;AACpE,SAAS,cAAc,CAAC,IAAsB;IAC7C,MAAM,IAAI,GAAG,IAAI,CAAC,IAAI,IAAI,EAAE,CAAC;IAC7B,MAAM,WAAW,GAAG,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE;QACpE,IAAI;KACJ,CAAC,CAAC;IAEH,yEAAyE;IACzE,iFAAiF;IACjF,IAAI,IAAI,CAAC,MAAM,KAAK,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC;QAC/C,MAAM,IAAI,SAAS,CAClB,GAAG,IAAI,CAAC,YAAY,YAAY,WAAW,CAAC,MAAM,CAAC,MAAM,wBAAwB,IAAI,CAAC,MAAM,EAAE,CAC9F,CAAC;IACH,CAAC;IAED,OAAO;QACN,EAAE,EAAE,IAAI,CAAC,EAAE;QACX,IAAI,EAAE,WAAW,CAAC,UAAU,CAAC,WAAW,EAAE,IAAI,CAAC;QAC/C,YAAY,EAAE,CAAC,UAAU,EAAE,EAAE,CAC5B,WAAW,CAAC,YAAY,CAAC,WAAW,EAAE,UAAU,CAAC;KAClD,CAAC;AACH,CAAC;AAGD,OAAO,EAAE,cAAc,EAAE,CAAC"}

package/dist/sdk/index.d.ts

@@ -1,322 +1,88 @@
-/**
- * Hex-encoded binary data prefixed with `0x`.
- *
- * Ghostcall request and response data is represented as raw hex strings. The
- * SDK does not accept byte arrays or ABI fragments.
- */
+import { type GhostcallAbiCall, type GhostcallAbiResult } from "./abi.ts";
+/** A 0x-prefixed string, validated at SDK wire boundaries. */
 type Hex = `0x${string}`;
-/**
- * Hex-encoded RPC quantity prefixed with `0x`.
- */
-type HexQuantity = `0x${string}`;
-/**
- * Block reference accepted by the outer `eth_call`.
- */
-type GhostcallBlockReference = string | number | bigint;
-/**
- * One Ghostcall subcall entry.
- */
+/** Raw calldata for one target. Encoding ignores the SDK-only failure policy. */
 type GhostcallCall = {
-    /**
-     * Target contract address to invoke.
-     */
     to: Hex;
-    /**
-     * Hex-encoded call data to forward to {@link GhostcallCall.to}.
-     *
-     * The encoded payload is limited to `65535` bytes because Ghostcall stores each
-     * calldata length as a big-endian `uint16`.
-     */
+    /** At most 65,535 bytes (the wire format stores a uint16 length). */
     data: Hex;
-};
-/**
- * One Ghostcall aggregate subcall entry.
- *
- * The wire format does not include failure-policy bits. `allowFailure` is an SDK
- * policy applied after Ghostcall returns the packed result entries.
- */
-type GhostcallAggregateCall = GhostcallCall & {
-    /**
-     * Allows this subcall to return a failed result entry.
-     *
-     * Defaults to `false`, matching Multicall3's strict `aggregate3` behavior when
-     * a call does not explicitly opt into failure.
-     */
+    /** Return failed entries from aggregateCalls instead of throwing. Default: false. */
     allowFailure?: boolean;
 };
-/**
- * One Ghostcall subcall entry for decoded aggregate results.
- */
+/** Raw calldata with a decoder that only receives successful results. */
 type GhostcallDecodedCall<TResult = unknown> = GhostcallCall & {
-    /**
-     * Decodes this call's successful return data.
-     *
-     * This is intentionally a caller-provided function so the SDK stays independent
-     * from ABI libraries while still letting callers plug in helpers such as
-     * `decodeFunctionResult` from viem or ox.
-     */
-    decodeResult: GhostcallResultDecoder<TResult>;
+    abi?: never;
+    functionName?: never;
+    args?: never;
+    allowFailure?: never;
+    decodeResult: (returnData: Hex, entry: Extract<GhostcallResult, {
+        success: true;
+    }>, index: number) => TResult;
 };
-/**
- * One successful Ghostcall result entry.
- */
-type GhostcallSuccessResult = {
-    /**
-     * Indicates whether the underlying EVM `CALL` returned successfully.
-     *
-     * A `true` value means the target call returned successfully.
-     */
+/** Raw results retain input order and include revert data for failed calls. */
+type GhostcallResult = {
     success: true;
-    /**
-     * Raw return data produced by the target call.
-     */
     returnData: Hex;
-};
-/**
- * One failed Ghostcall result entry.
- */
-type GhostcallFailedResult = {
-    /**
-     * Indicates whether the underlying EVM `CALL` returned successfully.
-     *
-     * A `false` value means the target call reverted or otherwise failed, but the
-     * Ghostcall batch itself still completed successfully.
-     */
+} | {
     success: false;
-    /**
-     * Raw return data produced by the target call.
-     *
-     * For failed calls this contains revert data, if any. The SDK leaves higher-level
-     * ABI decoding and failure policy to the caller.
-     */
     returnData: Hex;
 };
-/**
- * One decoded Ghostcall result entry.
- */
-type GhostcallResult = GhostcallSuccessResult | GhostcallFailedResult;
-/**
- * Function used by {@link aggregateCalls} to turn raw successful return data into
- * a caller-chosen value.
- */
-type GhostcallResultDecoder<TResult> = (returnData: Hex, entry: GhostcallSuccessResult, index: number) => TResult;
-/**
- * Error thrown when a strict Ghostcall batch encounters a failed subcall.
- */
-declare class GhostcallSubcallError extends Error {
-    readonly index: number;
-    readonly call: GhostcallAggregateCall;
-    readonly result: GhostcallFailedResult;
-    constructor(index: number, call: GhostcallAggregateCall, result: GhostcallFailedResult);
-}
-type GhostcallDecodedResults<TCalls extends readonly GhostcallDecodedCall[]> = {
-    -readonly [Index in keyof TCalls]: TCalls[Index] extends {
-        decodeResult: GhostcallResultDecoder<infer TResult>;
-    } ? TResult : never;
+type GhostcallFailedResult = Extract<GhostcallResult, {
+    success: false;
+}>;
+type GhostcallDecodedInput = GhostcallAbiCall | GhostcallDecodedCall;
+type ValidatedDecodedCall<TCall extends GhostcallDecodedInput> = TCall extends GhostcallAbiCall ? GhostcallAbiCall<TCall["abi"]> : TCall;
+type ValidatedDecodedCalls<TCalls extends readonly GhostcallDecodedInput[]> = {
+    [Index in keyof TCalls]: ValidatedDecodedCall<TCalls[Index]>;
+};
+type DecodedResult<TCall extends GhostcallDecodedInput> = TCall extends GhostcallAbiCall ? GhostcallAbiResult<TCall> : TCall extends GhostcallDecodedCall ? ReturnType<TCall["decodeResult"]> : never;
+type GhostcallDecodedResults<TCalls extends readonly GhostcallDecodedInput[]> = {
+    -readonly [Index in keyof TCalls]: DecodedResult<TCalls[Index]>;
 };
 type GhostcallEncodeOptions = {
-    /**
-     * Maximum allowed CREATE initcode size in bytes.
-     *
-     * This applies to the full request `data`, including bundled Ghostcall
-     * initcode and every encoded subcall entry.
-     *
-     * Defaults to Ethereum's EIP-3860 limit of `49,152` bytes.
-     */
+    /** Full CREATE request ceiling, including bundled initcode. Default: 49,152 bytes. */
     maxInitcodeBytes?: number;
 };
-type GhostcallEthCallOptions = {
-    /**
-     * Optional `from` address for the outer `eth_call`.
-     */
-    from?: Hex;
-    /**
-     * Optional gas limit for the outer `eth_call`.
-     */
-    gas?: HexQuantity;
-    /**
-     * Optional block tag, hex quantity, or block number for the outer `eth_call`.
-     *
-     * Decimal strings, numbers, and bigints are normalized to hex quantities.
-     * Defaults to `latest`.
-     */
-    blockTag?: GhostcallBlockReference;
-};
 type GhostcallAggregateOptions = GhostcallEncodeOptions & {
-    /**
-     * Optional outer `eth_call` controls shared by {@link aggregateCalls} and
-     * {@link aggregateDecodedCalls}.
-     */
-    ethCall?: GhostcallEthCallOptions;
+    /** Controls the outer eth_call, shared by the entire batch. */
+    ethCall?: {
+        from?: Hex;
+        /** Canonical RPC hex quantity. */
+        gas?: Hex;
+        /** Decimal block numbers are normalized to hex. Default: "latest". */
+        blockTag?: string | number | bigint;
+    };
 };
-/**
- * Minimal EIP-1193 provider shape used by the SDK.
- */
-type EIP1193ProviderWithRequestFn = {
+type Provider = {
     request(args: {
         method: string;
         params?: unknown;
     }): Promise<unknown>;
 };
+/** A disallowed failure, with its zero-based index, executed call, and revert data. */
+declare class GhostcallSubcallError extends Error {
+    readonly index: number;
+    readonly call: GhostcallCall;
+    readonly result: GhostcallFailedResult;
+    constructor(index: number, call: GhostcallCall, result: GhostcallFailedResult);
+}
 /**
- * Encodes a list of contract calls into the full CREATE-style `eth_call` payload
- * expected by Ghostcall.
- *
- * The returned hex string already includes the bundled Ghostcall initcode followed
- * by the compact binary payload for each subcall, so callers can pass it directly
- * as the `data` field of an `eth_call` request without supplying a `to` address.
- * Each encoded subcall entry uses the compact layout `[len(2)][target(20)][data]`.
- * The bundled initcode assumes appended bytes follow this exact shape; this
- * function is the supported boundary for producing well-formed Ghostcall payloads.
- *
- * @param calls - Ordered list of subcalls to execute. Each entry becomes one
- *                Ghostcall payload segment in the same order it appears here.
- * @param options - Optional encoding controls.
- *
- * @returns Full CREATE payload consisting of the bundled Ghostcall initcode plus
- *          the encoded call list.
- *
- * @throws {TypeError} If any call address or calldata value is not valid hex.
- * @throws {RangeError} If any call data exceeds the protocol `uint16` length limit
- *                      or if the full encoded CREATE payload would exceed the
- *                      configured initcode size limit.
- *
- * @example
- * const data = encodeCalls([
- *   {
- *     // USDC on Ethereum mainnet: balanceOf(Binance 14)
- *     to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
- *     data: "0x70a0823100000000000000000000000028c6c06298d514db089934071355e5743bf21d60",
- *   },
- *   {
- *     // WETH9 on Ethereum mainnet: totalSupply()
- *     to: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
- *     data: "0x18160ddd",
- *   },
- * ]);
- *
- * // Later:
- * // provider.request({ method: "eth_call", params: [{ data }, "latest"] })
- */
-declare function encodeCalls(calls: readonly GhostcallCall[], options?: GhostcallEncodeOptions): Hex;
-/**
- * Sends a Ghostcall batch with a CREATE-style `eth_call` and decodes the result.
- *
- * This is the provider-facing counterpart to {@link encodeCalls} and
- * {@link decodeResults}. It sends the bundled Ghostcall initcode as the `data`
- * field of `eth_call` without a `to` address, then returns raw result entries
- * in the same order as the input calls. Request bytes are built through
- * {@link encodeCalls}, so SDK callers get the supported payload validation before
- * the RPC request is sent.
- *
- * By default, any failed subcall makes this method reject. Set
- * `allowFailure: true` on a call to receive that failed entry in the returned
- * results instead. Use {@link aggregateDecodedCalls} when you want a strict batch
- * that returns decoded values directly. Use `options.ethCall` to forward `from`,
- * `gas`, or `blockTag` to the outer `eth_call`.
- *
- * @param provider - EIP-1193-compatible provider with a `request` method.
- * @param calls - Ordered list of subcalls to execute.
- * @param options - Optional outer call and initcode controls.
- *
- * @returns Ordered Ghostcall result entries.
- *
- * @throws {TypeError} If inputs are not valid Ghostcall call entries or if the
- *                     provider returns a non-hex `eth_call` result.
- * @throws {RangeError} If the encoded CREATE payload exceeds protocol or the
- *                      configured CREATE initcode ceiling.
- * @throws {GhostcallSubcallError} If a subcall fails without `allowFailure: true`.
- * @throws {Error} If the response entry count does not match the request entry count.
- *
- * @example
- * const results = await aggregateCalls(provider, [
- *   {
- *     // USDC on Ethereum mainnet: balanceOf(Binance 14)
- *     to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
- *     data: "0x70a0823100000000000000000000000028c6c06298d514db089934071355e5743bf21d60",
- *   },
- *   {
- *     // WETH9 on Ethereum mainnet: totalSupply()
- *     to: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
- *     data: "0x18160ddd",
- *   },
- * ]);
+ * Build CREATE-style eth_call data: initcode followed by [length (2)][target (20)][data].
+ * Send without a `to` address. Invalid inputs throw TypeError; size limits throw RangeError.
  */
-declare function aggregateCalls(provider: EIP1193ProviderWithRequestFn, calls: readonly GhostcallAggregateCall[], options?: GhostcallAggregateOptions): Promise<GhostcallResult[]>;
+declare function encodeCalls(calls: readonly GhostcallCall[], { maxInitcodeBytes, }?: GhostcallEncodeOptions): Hex;
 /**
- * Sends a strict Ghostcall batch and decodes each successful result entry.
- *
- * This is the decoded counterpart to {@link aggregateCalls}. It sends the bundled
- * Ghostcall initcode as the `data` field of `eth_call` without a `to` address,
- * then runs each call's `decodeResult` callback over the successful return data in
- * the same order as the input calls.
- *
- * `aggregateDecodedCalls` is always strict. Its TypeScript input shape requires a
- * `decodeResult` callback on every call and does not accept `allowFailure`.
- * Any failed subcall rejects with {@link GhostcallSubcallError}. Use
- * {@link aggregateCalls} if you need raw failed entries. Use `options.ethCall`
- * to forward `from`, `gas`, or `blockTag` to the outer `eth_call`.
- *
- * @param provider - EIP-1193-compatible provider with a `request` method.
- * @param calls - Ordered list of strict decoded subcalls to execute.
- * @param options - Optional outer call and initcode controls.
- *
- * @returns Ordered list of decoded values.
- *
- * @throws {TypeError} If inputs are not valid Ghostcall call entries or if the
- *                     provider returns a non-hex `eth_call` result.
- * @throws {RangeError} If the encoded CREATE payload exceeds protocol or the
- *                      configured CREATE initcode ceiling.
- * @throws {GhostcallSubcallError} If any subcall fails.
- * @throws {Error} If the response entry count does not match the request entry count.
- *
- * @example
- * const erc20Abi = parseAbi([
- *   "function balanceOf(address account) view returns (uint256)",
- * ]);
- * const usdc = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
- * const owner = "0x28C6c06298d514Db089934071355E5743bf21d60";
- *
- * const [balance] = await aggregateDecodedCalls(provider, [
- *   {
- *     to: usdc,
- *     data: "0x70a0823100000000000000000000000028c6c06298d514db089934071355e5743bf21d60",
- *     decodeResult: (returnData) => decodeFunctionResult({
- *       abi: erc20Abi,
- *       functionName: "balanceOf",
- *       data: returnData,
- *     }),
- *   },
- * ]);
+ * Execute a raw batch in order. Failed calls throw GhostcallSubcallError unless
+ * their entry sets allowFailure. Provider errors pass through unchanged.
  */
-declare function aggregateDecodedCalls<const TCalls extends readonly GhostcallDecodedCall<unknown>[]>(provider: EIP1193ProviderWithRequestFn, calls: TCalls, options?: GhostcallAggregateOptions): Promise<GhostcallDecodedResults<TCalls>>;
+declare function aggregateCalls(provider: Provider, calls: readonly GhostcallCall[], options?: GhostcallAggregateOptions): Promise<GhostcallResult[]>;
 /**
- * Decodes the packed result blob returned by Ghostcall.
- *
- * Each decoded entry corresponds to exactly one subcall in the original batch and
- * preserves the original ordering. The SDK intentionally returns raw result bytes
- * rather than ABI-decoding them so higher-level callers can apply their own
- * decoding and failure policy.
- *
- * @param data - Raw bytes returned by Ghostcall, typically the direct result of a
- *               CREATE-style `eth_call`.
- *
- * @returns Ordered list of decoded Ghostcall result entries. Returns an empty
- *          array for `0x`.
- *
- * @throws {TypeError} If the provided data is not valid hex, if a result header is
- *                     truncated, or if an entry body is shorter than advertised.
- *
- * @example
- * const results = decodeResults("0x8002cafe0004deadbeef");
- *
- * console.log(results);
- * // [
- * //   { success: true, returnData: "0xcafe" },
- * //   { success: false, returnData: "0xdeadbeef" }
- * // ]
+ * Execute ABI-described calls or raw calls with custom decoders. Each tuple position
+ * retains its result type. Any failed call throws; encoding/decoding errors pass through.
  */
+declare function aggregateDecodedCalls<const TCalls extends readonly GhostcallDecodedInput[]>(provider: Provider, calls: TCalls & NoInfer<ValidatedDecodedCalls<TCalls>>, options?: GhostcallAggregateOptions): Promise<GhostcallDecodedResults<TCalls>>;
+/** Decode ordered [success bit | uint15 length][returndata] entries. Reject malformed data. */
 declare function decodeResults(data: Hex): GhostcallResult[];
-export type { EIP1193ProviderWithRequestFn, GhostcallAggregateCall, GhostcallAggregateOptions, GhostcallBlockReference, GhostcallCall, GhostcallDecodedCall, GhostcallDecodedResults, GhostcallEncodeOptions, GhostcallEthCallOptions, GhostcallFailedResult, GhostcallResult, GhostcallResultDecoder, GhostcallSuccessResult, Hex, HexQuantity, };
+export type { GhostcallAbiCall, GhostcallAggregateOptions, GhostcallCall, GhostcallDecodedCall, GhostcallEncodeOptions, GhostcallResult, Hex, };
 export { aggregateCalls, aggregateDecodedCalls, decodeResults, encodeCalls, GhostcallSubcallError, };
 //# sourceMappingURL=index.d.ts.map

package/dist/sdk/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,KAAK,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAEzB;;GAEG;AACH,KAAK,WAAW,GAAG,KAAK,MAAM,EAAE,CAAC;AAEjC;;GAEG;AACH,KAAK,uBAAuB,GAAG,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;AAExD;;GAEG;AACH,KAAK,aAAa,GAAG;IACpB;;OAEG;IACH,EAAE,EAAE,GAAG,CAAC;IAER;;;;;OAKG;IACH,IAAI,EAAE,GAAG,CAAC;CACV,CAAC;AAEF;;;;;GAKG;AACH,KAAK,sBAAsB,GAAG,aAAa,GAAG;IAC7C;;;;;OAKG;IACH,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;GAEG;AACH,KAAK,oBAAoB,CAAC,OAAO,GAAG,OAAO,IAAI,aAAa,GAAG;IAC9D;;;;;;OAMG;IACH,YAAY,EAAE,sBAAsB,CAAC,OAAO,CAAC,CAAC;CAC9C,CAAC;AAEF;;GAEG;AACH,KAAK,sBAAsB,GAAG;IAC7B;;;;OAIG;IACH,OAAO,EAAE,IAAI,CAAC;IAEd;;OAEG;IACH,UAAU,EAAE,GAAG,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,KAAK,qBAAqB,GAAG;IAC5B;;;;;OAKG;IACH,OAAO,EAAE,KAAK,CAAC;IAEf;;;;;OAKG;IACH,UAAU,EAAE,GAAG,CAAC;CAChB,CAAC;AAEF;;GAEG;AACH,KAAK,eAAe,GAAG,sBAAsB,GAAG,qBAAqB,CAAC;AAEtE;;;GAGG;AACH,KAAK,sBAAsB,CAAC,OAAO,IAAI,CACtC,UAAU,EAAE,GAAG,EACf,KAAK,EAAE,sBAAsB,EAC7B,KAAK,EAAE,MAAM,KACT,OAAO,CAAC;AAEb;;GAEG;AACH,cAAM,qBAAsB,SAAQ,KAAK;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,sBAAsB,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;gBAGtC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,sBAAsB,EAC5B,MAAM,EAAE,qBAAqB;CAS9B;AAED,KAAK,uBAAuB,CAAC,MAAM,SAAS,SAAS,oBAAoB,EAAE,IAAI;IAC9E,CAAC,UAAU,KAAK,IAAI,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS;QACxD,YAAY,EAAE,sBAAsB,CAAC,MAAM,OAAO,CAAC,CAAC;KACpD,GACE,OAAO,GACP,KAAK;CACR,CAAC;AAEF,KAAK,sBAAsB,GAAG;IAC7B;;;;;;;OAOG;IACH,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,KAAK,uBAAuB,GAAG;IAC9B;;OAEG;IACH,IAAI,CAAC,EAAE,GAAG,CAAC;IAEX;;OAEG;IACH,GAAG,CAAC,EAAE,WAAW,CAAC;IAElB;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,uBAAuB,CAAC;CACnC,CAAC;AAEF,KAAK,yBAAyB,GAAG,sBAAsB,GAAG;IACzD;;;OAGG;IACH,OAAO,CAAC,EAAE,uBAAuB,CAAC;CAClC,CAAC;AAEF;;GAEG;AACH,KAAK,4BAA4B,GAAG;IACnC,OAAO,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtE,CAAC;AAWF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,iBAAS,WAAW,CACnB,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,OAAO,GAAE,sBAA2B,GAClC,GAAG,CAmCL;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,iBAAe,cAAc,CAC5B,QAAQ,EAAE,4BAA4B,EACtC,KAAK,EAAE,SAAS,sBAAsB,EAAE,EACxC,OAAO,CAAC,EAAE,yBAAyB,GACjC,OAAO,CAAC,eAAe,EAAE,CAAC,CAyC5B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,iBAAe,qBAAqB,CACnC,KAAK,CAAC,MAAM,SAAS,SAAS,oBAAoB,CAAC,OAAO,CAAC,EAAE,EAE7D,QAAQ,EAAE,4BAA4B,EACtC,KAAK,EAAE,MAAM,EACb,OAAO,CAAC,EAAE,yBAAyB,GACjC,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAQ1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,iBAAS,aAAa,CAAC,IAAI,EAAE,GAAG,GAAG,eAAe,EAAE,CAsCnD;AAqKD,YAAY,EACX,4BAA4B,EAC5B,sBAAsB,EACtB,yBAAyB,EACzB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,uBAAuB,EACvB,sBAAsB,EACtB,uBAAuB,EACvB,qBAAqB,EACrB,eAAe,EACf,sBAAsB,EACtB,sBAAsB,EACtB,GAAG,EACH,WAAW,GACX,CAAC;AACF,OAAO,EACN,cAAc,EACd,qBAAqB,EACrB,aAAa,EACb,WAAW,EACX,qBAAqB,GACrB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/sdk/index.ts"],"names":[],"mappings":"AAGA,OAAO,EACN,KAAK,gBAAgB,EACrB,KAAK,kBAAkB,EAEvB,MAAM,UAAU,CAAC;AAGlB,8DAA8D;AAC9D,KAAK,GAAG,GAAG,KAAK,MAAM,EAAE,CAAC;AAEzB,iFAAiF;AACjF,KAAK,aAAa,GAAG;IACpB,EAAE,EAAE,GAAG,CAAC;IACR,qEAAqE;IACrE,IAAI,EAAE,GAAG,CAAC;IACV,qFAAqF;IACrF,YAAY,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,yEAAyE;AACzE,KAAK,oBAAoB,CAAC,OAAO,GAAG,OAAO,IAAI,aAAa,GAAG;IAC9D,GAAG,CAAC,EAAE,KAAK,CAAC;IACZ,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,IAAI,CAAC,EAAE,KAAK,CAAC;IACb,YAAY,CAAC,EAAE,KAAK,CAAC;IACrB,YAAY,EAAE,CACb,UAAU,EAAE,GAAG,EACf,KAAK,EAAE,OAAO,CAAC,eAAe,EAAE;QAAE,OAAO,EAAE,IAAI,CAAA;KAAE,CAAC,EAClD,KAAK,EAAE,MAAM,KACT,OAAO,CAAC;CACb,CAAC;AAEF,+EAA+E;AAC/E,KAAK,eAAe,GACjB;IAAE,OAAO,EAAE,IAAI,CAAC;IAAC,UAAU,EAAE,GAAG,CAAA;CAAE,GAClC;IAAE,OAAO,EAAE,KAAK,CAAC;IAAC,UAAU,EAAE,GAAG,CAAA;CAAE,CAAC;AAEvC,KAAK,qBAAqB,GAAG,OAAO,CAAC,eAAe,EAAE;IAAE,OAAO,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAC1E,KAAK,qBAAqB,GAAG,gBAAgB,GAAG,oBAAoB,CAAC;AAGrE,KAAK,oBAAoB,CAAC,KAAK,SAAS,qBAAqB,IAC5D,KAAK,SAAS,gBAAgB,GAAG,gBAAgB,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,KAAK,CAAC;AAEzE,KAAK,qBAAqB,CAAC,MAAM,SAAS,SAAS,qBAAqB,EAAE,IAAI;KAC5E,KAAK,IAAI,MAAM,MAAM,GAAG,oBAAoB,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;CAC5D,CAAC;AAEF,KAAK,aAAa,CAAC,KAAK,SAAS,qBAAqB,IACrD,KAAK,SAAS,gBAAgB,GAC3B,kBAAkB,CAAC,KAAK,CAAC,GACzB,KAAK,SAAS,oBAAoB,GACjC,UAAU,CAAC,KAAK,CAAC,cAAc,CAAC,CAAC,GACjC,KAAK,CAAC;AAEX,KAAK,uBAAuB,CAAC,MAAM,SAAS,SAAS,qBAAqB,EAAE,IAC3E;IACC,CAAC,UAAU,KAAK,IAAI,MAAM,MAAM,GAAG,aAAa,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;CAC/D,CAAC;AAEH,KAAK,sBAAsB,GAAG;IAC7B,sFAAsF;IACtF,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,KAAK,yBAAyB,GAAG,sBAAsB,GAAG;IACzD,+DAA+D;IAC/D,OAAO,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,GAAG,CAAC;QACX,kCAAkC;QAClC,GAAG,CAAC,EAAE,GAAG,CAAC;QACV,sEAAsE;QACtE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAAC;KACpC,CAAC;CACF,CAAC;AAEF,KAAK,QAAQ,GAAG;IACf,OAAO,CAAC,IAAI,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACtE,CAAC;AAEF,uFAAuF;AACvF,cAAM,qBAAsB,SAAQ,KAAK;IACxC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;gBAGtC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,aAAa,EACnB,MAAM,EAAE,qBAAqB;CAQ9B;AAUD;;;GAGG;AACH,iBAAS,WAAW,CACnB,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,EACC,gBAA+C,GAC/C,GAAE,sBAA2B,GAC5B,GAAG,CA6BL;AAED;;;GAGG;AACH,iBAAe,cAAc,CAC5B,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,OAAO,CAAC,EAAE,yBAAyB,GACjC,OAAO,CAAC,eAAe,EAAE,CAAC,CA6B5B;AAED;;;GAGG;AACH,iBAAe,qBAAqB,CACnC,KAAK,CAAC,MAAM,SAAS,SAAS,qBAAqB,EAAE,EAErD,QAAQ,EAAE,QAAQ,EAClB,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC,EACtD,OAAO,CAAC,EAAE,yBAAyB,GACjC,OAAO,CAAC,uBAAuB,CAAC,MAAM,CAAC,CAAC,CAY1C;AAED,+FAA+F;AAC/F,iBAAS,aAAa,CAAC,IAAI,EAAE,GAAG,GAAG,eAAe,EAAE,CAwBnD;AAiDD,YAAY,EACX,gBAAgB,EAChB,yBAAyB,EACzB,aAAa,EACb,oBAAoB,EACpB,sBAAsB,EACtB,eAAe,EACf,GAAG,GACH,CAAC;AACF,OAAO,EACN,cAAc,EACd,qBAAqB,EACrB,aAAa,EACb,WAAW,EACX,qBAAqB,GACrB,CAAC"}

package/dist/sdk/index.js

@@ -1,7 +1,8 @@
+import { validate as isAddress } from "ox/Address";
+import { size as hexSize, validate as isHex } from "ox/Hex";
+import { prepareAbiCall, } from "./abi.js";
 import { ghostcallInitcode } from "./generated/initcode.js";
-/**
- * Error thrown when a strict Ghostcall batch encounters a failed subcall.
- */
+/** A disallowed failure, with its zero-based index, executed call, and revert data. */
 class GhostcallSubcallError extends Error {
     index;
     call;
@@ -12,139 +13,60 @@ class GhostcallSubcallError extends Error {
         this.index = index;
         this.call = call;
         this.result = result;
-        Object.setPrototypeOf(this, new.target.prototype);
     }
 }
-const addressHexLength = 40;
+const encodedCallHeaderSize = 22;
 const encodedHeaderHexLength = 4;
 const maxCalldataSize = 0xffff;
-const encodedCallHeaderSize = 0x16;
 const defaultMaxCreateInitcodeSize = 0xc000;
 const successFlagMask = 0x8000;
 const returnDataLengthMask = 0x7fff;
-const bundledInitcodeSize = byteLength(ghostcallInitcode);
+const bundledInitcodeSize = hexSize(ghostcallInitcode);
 /**
- * Encodes a list of contract calls into the full CREATE-style `eth_call` payload
- * expected by Ghostcall.
- *
- * The returned hex string already includes the bundled Ghostcall initcode followed
- * by the compact binary payload for each subcall, so callers can pass it directly
- * as the `data` field of an `eth_call` request without supplying a `to` address.
- * Each encoded subcall entry uses the compact layout `[len(2)][target(20)][data]`.
- * The bundled initcode assumes appended bytes follow this exact shape; this
- * function is the supported boundary for producing well-formed Ghostcall payloads.
- *
- * @param calls - Ordered list of subcalls to execute. Each entry becomes one
- *                Ghostcall payload segment in the same order it appears here.
- * @param options - Optional encoding controls.
- *
- * @returns Full CREATE payload consisting of the bundled Ghostcall initcode plus
- *          the encoded call list.
- *
- * @throws {TypeError} If any call address or calldata value is not valid hex.
- * @throws {RangeError} If any call data exceeds the protocol `uint16` length limit
- *                      or if the full encoded CREATE payload would exceed the
- *                      configured initcode size limit.
- *
- * @example
- * const data = encodeCalls([
- *   {
- *     // USDC on Ethereum mainnet: balanceOf(Binance 14)
- *     to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
- *     data: "0x70a0823100000000000000000000000028c6c06298d514db089934071355e5743bf21d60",
- *   },
- *   {
- *     // WETH9 on Ethereum mainnet: totalSupply()
- *     to: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
- *     data: "0x18160ddd",
- *   },
- * ]);
- *
- * // Later:
- * // provider.request({ method: "eth_call", params: [{ data }, "latest"] })
+ * Build CREATE-style eth_call data: initcode followed by [length (2)][target (20)][data].
+ * Send without a `to` address. Invalid inputs throw TypeError; size limits throw RangeError.
  */
-function encodeCalls(calls, options = {}) {
+function encodeCalls(calls, { maxInitcodeBytes = defaultMaxCreateInitcodeSize, } = {}) {
+    if (!Number.isSafeInteger(maxInitcodeBytes) || maxInitcodeBytes < 0) {
+        throw new TypeError("options.maxInitcodeBytes must be a non-negative safe integer");
+    }
     const encodedParts = [ghostcallInitcode.slice(2)];
-    const maxInitcodeBytes = resolveMaxInitcodeBytes(options.maxInitcodeBytes);
     let totalEncodedSize = bundledInitcodeSize;
-    if (totalEncodedSize > maxInitcodeBytes) {
-        throw new RangeError(`encoded Ghostcall initcode exceeds the ${maxInitcodeBytes}-byte CREATE initcode limit`);
-    }
+    const sizeError = `encoded Ghostcall initcode exceeds the ${maxInitcodeBytes}-byte CREATE initcode limit`;
+    if (totalEncodedSize > maxInitcodeBytes)
+        throw new RangeError(sizeError);
     for (const [index, call] of calls.entries()) {
         assertAddress(call.to, `calls[${index}].to`);
         const calldata = assertHex(call.data, `calls[${index}].data`);
-        const calldataSize = byteLength(calldata);
+        const calldataSize = hexSize(calldata);
         if (calldataSize > maxCalldataSize) {
             throw new RangeError(`calls[${index}].data exceeds the ${maxCalldataSize}-byte calldata limit`);
         }
         totalEncodedSize += encodedCallHeaderSize + calldataSize;
-        if (totalEncodedSize > maxInitcodeBytes) {
-            throw new RangeError(`encoded Ghostcall initcode exceeds the ${maxInitcodeBytes}-byte CREATE initcode limit`);
-        }
-        encodedParts.push(calldataSize.toString(16).padStart(4, "0"));
-        encodedParts.push(call.to.slice(2));
-        encodedParts.push(calldata.slice(2));
+        if (totalEncodedSize > maxInitcodeBytes)
+            throw new RangeError(sizeError);
+        encodedParts.push(calldataSize.toString(16).padStart(4, "0"), call.to.slice(2), calldata.slice(2));
     }
     return `0x${encodedParts.join("")}`;
 }
 /**
- * Sends a Ghostcall batch with a CREATE-style `eth_call` and decodes the result.
- *
- * This is the provider-facing counterpart to {@link encodeCalls} and
- * {@link decodeResults}. It sends the bundled Ghostcall initcode as the `data`
- * field of `eth_call` without a `to` address, then returns raw result entries
- * in the same order as the input calls. Request bytes are built through
- * {@link encodeCalls}, so SDK callers get the supported payload validation before
- * the RPC request is sent.
- *
- * By default, any failed subcall makes this method reject. Set
- * `allowFailure: true` on a call to receive that failed entry in the returned
- * results instead. Use {@link aggregateDecodedCalls} when you want a strict batch
- * that returns decoded values directly. Use `options.ethCall` to forward `from`,
- * `gas`, or `blockTag` to the outer `eth_call`.
- *
- * @param provider - EIP-1193-compatible provider with a `request` method.
- * @param calls - Ordered list of subcalls to execute.
- * @param options - Optional outer call and initcode controls.
- *
- * @returns Ordered Ghostcall result entries.
- *
- * @throws {TypeError} If inputs are not valid Ghostcall call entries or if the
- *                     provider returns a non-hex `eth_call` result.
- * @throws {RangeError} If the encoded CREATE payload exceeds protocol or the
- *                      configured CREATE initcode ceiling.
- * @throws {GhostcallSubcallError} If a subcall fails without `allowFailure: true`.
- * @throws {Error} If the response entry count does not match the request entry count.
- *
- * @example
- * const results = await aggregateCalls(provider, [
- *   {
- *     // USDC on Ethereum mainnet: balanceOf(Binance 14)
- *     to: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
- *     data: "0x70a0823100000000000000000000000028c6c06298d514db089934071355e5743bf21d60",
- *   },
- *   {
- *     // WETH9 on Ethereum mainnet: totalSupply()
- *     to: "0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
- *     data: "0x18160ddd",
- *   },
- * ]);
+ * Execute a raw batch in order. Failed calls throw GhostcallSubcallError unless
+ * their entry sets allowFailure. Provider errors pass through unchanged.
  */
 async function aggregateCalls(provider, calls, options) {
-    const resolvedOptions = options ?? {};
-    const data = encodeCalls(calls, resolvedOptions);
-    const ethCall = { data };
-    const blockTag = normalizeBlockTag(resolvedOptions.ethCall?.blockTag ?? "latest", "options.ethCall.blockTag");
-    if (resolvedOptions.ethCall?.from !== undefined) {
-        assertAddress(resolvedOptions.ethCall.from, "options.ethCall.from");
-        ethCall.from = resolvedOptions.ethCall.from;
-    }
-    if (resolvedOptions.ethCall?.gas !== undefined) {
-        ethCall.gas = assertHexQuantity(resolvedOptions.ethCall.gas, "options.ethCall.gas");
-    }
+    const { from, gas, blockTag } = options?.ethCall ?? {};
+    const ethCall = {
+        data: encodeCalls(calls, options ?? {}),
+    };
+    if (from !== undefined) {
+        assertAddress(from, "options.ethCall.from");
+        ethCall.from = from;
+    }
+    if (gas !== undefined)
+        ethCall.gas = assertHexQuantity(gas, "options.ethCall.gas");
     const result = await provider.request({
         method: "eth_call",
-        params: [ethCall, blockTag],
+        params: [ethCall, normalizeBlockTag(blockTag ?? "latest")],
     });
     const entries = decodeResults(assertHex(result, "eth_call result"));
     if (entries.length !== calls.length) {
@@ -159,243 +81,79 @@ async function aggregateCalls(provider, calls, options) {
     return entries;
 }
 /**
- * Sends a strict Ghostcall batch and decodes each successful result entry.
- *
- * This is the decoded counterpart to {@link aggregateCalls}. It sends the bundled
- * Ghostcall initcode as the `data` field of `eth_call` without a `to` address,
- * then runs each call's `decodeResult` callback over the successful return data in
- * the same order as the input calls.
- *
- * `aggregateDecodedCalls` is always strict. Its TypeScript input shape requires a
- * `decodeResult` callback on every call and does not accept `allowFailure`.
- * Any failed subcall rejects with {@link GhostcallSubcallError}. Use
- * {@link aggregateCalls} if you need raw failed entries. Use `options.ethCall`
- * to forward `from`, `gas`, or `blockTag` to the outer `eth_call`.
- *
- * @param provider - EIP-1193-compatible provider with a `request` method.
- * @param calls - Ordered list of strict decoded subcalls to execute.
- * @param options - Optional outer call and initcode controls.
- *
- * @returns Ordered list of decoded values.
- *
- * @throws {TypeError} If inputs are not valid Ghostcall call entries or if the
- *                     provider returns a non-hex `eth_call` result.
- * @throws {RangeError} If the encoded CREATE payload exceeds protocol or the
- *                      configured CREATE initcode ceiling.
- * @throws {GhostcallSubcallError} If any subcall fails.
- * @throws {Error} If the response entry count does not match the request entry count.
- *
- * @example
- * const erc20Abi = parseAbi([
- *   "function balanceOf(address account) view returns (uint256)",
- * ]);
- * const usdc = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48";
- * const owner = "0x28C6c06298d514Db089934071355E5743bf21d60";
- *
- * const [balance] = await aggregateDecodedCalls(provider, [
- *   {
- *     to: usdc,
- *     data: "0x70a0823100000000000000000000000028c6c06298d514db089934071355e5743bf21d60",
- *     decodeResult: (returnData) => decodeFunctionResult({
- *       abi: erc20Abi,
- *       functionName: "balanceOf",
- *       data: returnData,
- *     }),
- *   },
- * ]);
+ * Execute ABI-described calls or raw calls with custom decoders. Each tuple position
+ * retains its result type. Any failed call throws; encoding/decoding errors pass through.
  */
 async function aggregateDecodedCalls(provider, calls, options) {
-    const entries = await aggregateCalls(provider, calls, options);
+    const preparedCalls = calls.map((call) => call.abi === undefined ? call : prepareAbiCall(call));
+    const entries = await aggregateCalls(provider, preparedCalls, options);
     return entries.map((entry, index) => {
-        const call = calls[index];
-        const successEntry = entry;
-        return call.decodeResult(successEntry.returnData, successEntry, index);
+        // aggregateCalls has checked the count. Hidden allowFailure fields still cannot
+        // bypass this guard and send failed returndata to a success-only decoder.
+        const call = preparedCalls[index];
+        if (!entry.success)
+            throw new GhostcallSubcallError(index, call, entry);
+        return call.decodeResult(entry.returnData, entry, index);
     });
 }
-/**
- * Decodes the packed result blob returned by Ghostcall.
- *
- * Each decoded entry corresponds to exactly one subcall in the original batch and
- * preserves the original ordering. The SDK intentionally returns raw result bytes
- * rather than ABI-decoding them so higher-level callers can apply their own
- * decoding and failure policy.
- *
- * @param data - Raw bytes returned by Ghostcall, typically the direct result of a
- *               CREATE-style `eth_call`.
- *
- * @returns Ordered list of decoded Ghostcall result entries. Returns an empty
- *          array for `0x`.
- *
- * @throws {TypeError} If the provided data is not valid hex, if a result header is
- *                     truncated, or if an entry body is shorter than advertised.
- *
- * @example
- * const results = decodeResults("0x8002cafe0004deadbeef");
- *
- * console.log(results);
- * // [
- * //   { success: true, returnData: "0xcafe" },
- * //   { success: false, returnData: "0xdeadbeef" }
- * // ]
- */
+/** Decode ordered [success bit | uint15 length][returndata] entries. Reject malformed data. */
 function decodeResults(data) {
-    const normalizedData = assertHex(data, "data");
-    if (normalizedData === "0x") {
-        return [];
-    }
+    const encodedData = assertHex(data, "data").slice(2);
     const results = [];
-    const encodedData = normalizedData.slice(2);
     let cursor = 0;
     while (cursor < encodedData.length) {
         if (cursor + encodedHeaderHexLength > encodedData.length) {
             throw new TypeError("Truncated Ghostcall response header");
         }
         const header = Number.parseInt(encodedData.slice(cursor, cursor + encodedHeaderHexLength), 16);
-        const success = (header & successFlagMask) !== 0;
-        const returnDataSize = header & returnDataLengthMask;
-        const nextCursor = cursor + encodedHeaderHexLength;
-        const returnDataEnd = nextCursor + returnDataSize * 2;
+        cursor += encodedHeaderHexLength;
+        const returnDataEnd = cursor + (header & returnDataLengthMask) * 2;
         if (returnDataEnd > encodedData.length) {
             throw new TypeError("Truncated Ghostcall response body");
         }
         results.push({
-            success,
-            returnData: `0x${encodedData.slice(nextCursor, returnDataEnd)}`,
+            success: (header & successFlagMask) !== 0,
+            returnData: `0x${encodedData.slice(cursor, returnDataEnd)}`,
         });
         cursor = returnDataEnd;
     }
     return results;
 }
-/**
- * Validates that a value is a canonical 20-byte hex address.
- *
- * @param value - Unknown input to validate.
- * @param label - Field name used in thrown error messages.
- *
- * @throws {TypeError} If the value is not valid `0x`-prefixed hex or is not
- *                     exactly 20 bytes long.
- *
- * @internal
- */
 function assertAddress(value, label) {
-    const normalizedValue = assertHex(value, label);
-    if (normalizedValue.length !== addressHexLength + 2) {
+    if (typeof value !== "string" || !isAddress(value, { strict: false })) {
         throw new TypeError(`${label} must be a 20-byte hex string`);
     }
 }
-/**
- * Validates that a value is an even-length `0x`-prefixed hex string.
- *
- * @param value - Unknown input to validate.
- * @param label - Field name used in thrown error messages.
- *
- * @returns The validated value narrowed to {@link Hex}.
- *
- * @throws {TypeError} If the value is not a string, lacks the `0x` prefix, has an
- *                     odd number of hex characters, or contains non-hex digits.
- *
- * @internal
- */
 function assertHex(value, label) {
-    if (typeof value !== "string") {
-        throw new TypeError(`${label} must be a hex string`);
-    }
-    if (!value.startsWith("0x")) {
-        throw new TypeError(`${label} must start with 0x`);
-    }
-    const rawValue = value.slice(2);
-    if (rawValue.length % 2 !== 0) {
-        throw new TypeError(`${label} must have an even number of hex characters`);
-    }
-    if (!/^[0-9a-fA-F]*$/.test(rawValue)) {
-        throw new TypeError(`${label} must contain only hexadecimal characters`);
+    // ox checks prefix/digits; the wire format additionally requires whole bytes.
+    if (!isHex(value, { strict: true }) || value.length % 2 !== 0) {
+        throw new TypeError(`${label} must be an even-length 0x-prefixed hex string`);
     }
     return value;
 }
-/**
- * Validates that a value is an RPC hex quantity.
- *
- * @param value - Unknown input to validate.
- * @param label - Field name used in thrown error messages.
- * @returns The validated value narrowed to {@link HexQuantity}.
- * @throws {TypeError} If the value is not a valid `0x`-prefixed quantity.
- *
- * @internal
- */
 function assertHexQuantity(value, label) {
-    if (typeof value !== "string") {
-        throw new TypeError(`${label} must be a hex quantity string`);
-    }
-    if (!/^0x(?:0|[1-9a-fA-F][0-9a-fA-F]*)$/.test(value)) {
+    if (typeof value !== "string" ||
+        !/^0x(?:0|[1-9a-fA-F][0-9a-fA-F]*)$/.test(value)) {
         throw new TypeError(`${label} must be a 0x-prefixed hex quantity`);
     }
     return value;
 }
-/**
- * Normalizes a block reference into the RPC shape expected by `eth_call`.
- *
- * @param value - Block reference to normalize.
- * @param label - Field name used in thrown error messages.
- * @returns Normalized block reference.
- * @throws {TypeError} If the value is not a supported block reference.
- *
- * @internal
- */
-function normalizeBlockTag(value, label) {
-    if (typeof value === "number") {
-        if (!Number.isSafeInteger(value) || value < 0) {
-            throw new TypeError(`${label} must be a non-negative safe integer, bigint, or non-empty string`);
-        }
-        return `0x${value.toString(16)}`;
-    }
-    if (typeof value === "bigint") {
-        if (value < 0n) {
-            throw new TypeError(`${label} must be a non-negative safe integer, bigint, or non-empty string`);
-        }
-        return `0x${value.toString(16)}`;
-    }
-    if (typeof value !== "string" || value.length === 0) {
-        throw new TypeError(`${label} must be a non-negative safe integer, bigint, or non-empty string`);
-    }
-    if (/^-?[0-9]+$/.test(value)) {
-        if (value.startsWith("-")) {
-            throw new TypeError(`${label} must be a non-negative safe integer, bigint, or non-empty string`);
-        }
-        return `0x${BigInt(value).toString(16)}`;
-    }
-    if (value.startsWith("0x") || value.startsWith("0X")) {
-        return assertHexQuantity(`0x${value.slice(2)}`, label);
-    }
-    return value;
-}
-/**
- * Resolves the active CREATE initcode ceiling.
- *
- * @param value - Optional caller override.
- * @returns Active initcode ceiling in bytes.
- * @throws {TypeError} If the override is not a non-negative safe integer.
- *
- * @internal
- */
-function resolveMaxInitcodeBytes(value) {
-    if (value === undefined) {
-        return defaultMaxCreateInitcodeSize;
-    }
-    if (!Number.isSafeInteger(value) || value < 0) {
-        throw new TypeError("options.maxInitcodeBytes must be a non-negative safe integer");
-    }
-    return value;
-}
-/**
- * Returns the byte length of a validated hex string.
- *
- * @param value - Validated hex string.
- * @returns Number of bytes represented by {@link value}.
- *
- * @internal
- */
-function byteLength(value) {
-    return (value.length - 2) / 2;
+function normalizeBlockTag(value) {
+    if (typeof value === "bigint" ||
+        (typeof value === "number" && Number.isSafeInteger(value))) {
+        if (value >= 0)
+            return `0x${value.toString(16)}`;
+    }
+    else if (typeof value === "string" &&
+        value.length > 0 &&
+        !/^-\d+$/.test(value)) {
+        if (/^\d+$/.test(value))
+            return `0x${BigInt(value).toString(16)}`;
+        return /^0x/i.test(value)
+            ? assertHexQuantity(`0x${value.slice(2)}`, "options.ethCall.blockTag")
+            : value;
+    }
+    throw new TypeError("options.ethCall.blockTag must be a non-negative safe integer, bigint, or non-empty string");
 }
 export { aggregateCalls, aggregateDecodedCalls, decodeResults, encodeCalls, GhostcallSubcallError, };
 //# sourceMappingURL=index.js.map

package/dist/sdk/index.js.map

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

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@volga-sh/evm-ghostcall",
-	"version": "0.0.3",
-	"description": "Batch EVM blockchain reads without deployment dependencies.",
+	"version": "0.0.4",
+	"description": "Batch EVM contract reads without deploying a Multicall contract.",
 	"license": "MIT",
 	"type": "module",
 	"repository": {
@@ -48,11 +48,12 @@
 		"test:watch": "node --disable-warning=ExperimentalWarning --experimental-strip-types --test --watch test/*.test.ts",
 		"typecheck": "tsc --project tsconfig.json"
 	},
-	"dependencies": {},
+	"dependencies": {
+		"ox": "0.9.6"
+	},
 	"devDependencies": {
 		"@biomejs/biome": "2.4.12",
 		"@safe-global/mock-contract": "4.1.0",
-		"ox": "0.9.6",
 		"@types/node": "24.3.1",
 		"typescript": "5.9.2"
 	}

package/src/Ghostcall.yul

@@ -1,130 +1,49 @@
 object "Ghostcall" {
     code {
-        // Ghostcall is an "initcode program" rather than a normal deployed contract.
-        //
-        // Mental model:
-        // 1. A normal CREATE transaction executes initcode.
-        // 2. That initcode usually builds runtime bytecode and RETURNs it.
-        // 3. Ghostcall uses the same mechanism, but inside eth_call.
-        // 4. Because this is only a simulation, nothing is deployed.
-        // 5. Whatever bytes this program RETURNs become the eth_call result.
-        //
-        // In other words: Ghostcall treats CREATE initcode like a tiny one-shot program that can
-        // batch external CALLs and return their raw results.
-        //
-        // The caller sends one byte blob:
-        //   <compiled ghostcall initcode><payload>
-        //
-        // The payload is appended directly after the compiled initcode. It is not normal calldata.
-        // This program reads that appended payload back out of its own code using CODECOPY.
-        //
-        // Payload layout:
-        //   repeated call entries
-        //
-        // Each call entry:
-        //    2 bytes  calldata length (big-endian uint16)
-        //   20 bytes  target address
-        //    N bytes  calldata
-        //
-        // Output layout:
-        //   repeated result entries
-        //
-        // Each result entry:
-        //    2 bytes  packed header
-        //             bit 15    = success flag from CALL
-        //             bits 0-14 = returndata length (big-endian uint15)
-        //    N bytes  returndata
-        //
-        // The program does the same high-level loop for every entry:
-        // - read the next calldata length + target
-        // - copy that call's calldata into memory
-        // - execute CALL(target, calldata)
-        // - append (success, returndata) to the response buffer
-        // - continue until the payload is fully consumed
-        //
-        // The SDK is expected to validate caller-facing input invariants ahead of time. The only
-        // top-level check left here protects response packing, because returndata size is learned
-        // from the EVM after each CALL.
+        // CREATE-style eth_call initcode: RETURN becomes the simulated runtime bytes.
+        // Input: appended [uint16 calldata length][20-byte target][calldata] entries.
+        // Output: [success bit | uint15 returndata length][returndata] entries.
+        // The SDK validates inputs; malformed hand-built payloads are unsupported.
 
-        // dataoffset("user_payload_anchor") is the byte offset of the empty data section declared at
-        // the bottom of this file. Because that data section is placed after the code, its offset is
-        // exactly "the first byte after the compiled initcode". That makes it the start of the
-        // caller-appended payload.
+        // The empty trailing data section marks the first caller-appended byte.
         let payloadCursor := dataoffset("user_payload_anchor")
 
-        // Memory layout used by this program:
-        // - 0x00..writePtr: finalized output buffer that will become the eth_call return value
-        // - writePtr..writePtr+0x1f: scratch space for reading the current entry header
-        //
-        // writePtr always points to where the next result entry starts. The entry's memory is
-        // scratch until CALL completes, then the packed result overwrites that same region.
+        // [0, writePtr) is finalized output. Everything after it is scratch until
+        // CALL finishes, then overwritten with the next packed result.
         let writePtr := 0x00
 
-        // Process entries until the cursor reaches the end of the CREATE payload. SDK-generated
-        // payloads always land exactly on codesize(); raw malformed trailing bytes are outside the
-        // supported boundary and are not checked here.
         for {} lt(payloadCursor, codesize()) {} {
-            // Read the 22-byte fixed-size entry header into scratch memory at writePtr.
-            //
-            // The header layout is [len(2)][target(20)]. One mload gives us:
-            //   [2-byte len][20-byte target][10 trailing bytes]
+            // One word holds [length(2)][target(20)][unused(10)].
             codecopy(writePtr, payloadCursor, 0x16)
-
             let headerWord := mload(writePtr)
-
-            // The high 2 bytes hold the big-endian uint16 calldata length. The target occupies the
-            // next 20 bytes, so shr(80, headerWord) yields the address for CALL.
             let calldataSize := shr(240, headerWord)
 
-            // Put calldata after the 22-byte input header scratch. The returned entry later uses
-            // only writePtr..writePtr+0x01 for its packed header and writePtr+0x02 onward for
-            // returndata, so this staging area can be safely overwritten after CALL.
+            // Stage calldata after the input header; returndata later overwrites it.
             let calldataPtr := add(writePtr, 0x16)
             let returndataPtr := add(writePtr, 0x02)
-
-            // Copy just this call's calldata into memory so CALL can read it.
             codecopy(calldataPtr, add(payloadCursor, 0x16), calldataSize)
 
-            // Execute the external call with:
-            // - all remaining gas
-            // - zero ETH value
-            // - calldata in memory at calldataPtr
-            // - no output buffer yet, because we do not know returndata size in advance
-            //
+            // CALL truncates the shifted word to the low 160 address bits.
+            // Zero-value CALL (not STATICCALL) exposes state changes to later calls.
             let success := call(gas(), shr(80, headerWord), 0, calldataPtr, calldataSize, 0, 0)
             let returndataSize := returndatasize()
 
-            // The packed result header has 15 returndata length bits; bit 15 is the success flag.
-            // Revert rather than letting oversized returndata collide with the success bit.
+            // Reject lengths that would collide with the success bit.
             if shr(15, returndataSize) {
                 revert(0x00, 0x00)
             }
 
-            // Intentionally do not enforce an aggregate response-size cap here. CREATE-style
-            // execution already treats returned bytes as would-be runtime code, so the active
-            // chain/client/RPC environment will reject oversized responses according to its own
-            // code-size policy. Keeping this uncapped lets the same Ghostcall initcode benefit from
-            // networks with larger limits, such as Monad's MIP-2:
-            // https://mips.monad.xyz/MIPS/MIP-2
-
-            // Write the packed 2-byte result header into the high 2 bytes of the 32-byte word at
-            // writePtr. The rest of that word does not matter because the return length is computed
-            // explicitly at the end.
+            // Put the header in the high two bytes; only the final written length
+            // is returned, so the remainder of this word may be overwritten freely.
             mstore(writePtr, shl(240, or(shl(15, success), returndataSize)))
-
-            // Append the raw returndata bytes immediately after the 2-byte header.
             returndatacopy(returndataPtr, 0, returndataSize)
 
-            // Advance both cursors:
-            // - writePtr moves to the start of the next result entry
-            // - payloadCursor moves to the next input entry
             writePtr := add(returndataPtr, returndataSize)
             payloadCursor := add(payloadCursor, add(0x16, calldataSize))
         }
 
-        // Return exactly the bytes that were written to the response buffer.
+        // Aggregate size is governed by the active chain/client's CREATE policy.
         return(0x00, writePtr)
-
     }
 
     data "user_payload_anchor" hex""