@settlemint/dalp-sdk 3.1.11-main.33576239970 → 3.1.11-main.33590924340

package/README.md

@@ -1,9 +1,14 @@
 # DALP SDK
 
-The DALP SDK is a Promise-based client generated from the canonical v2 OpenAPI
-declaration ([Hey API](https://heyapi.dev/)), validated at runtime with
-[zod](https://zod.dev/). It is Effect-free: no `Effect` values, no branded
-Effect Schema identifiers on the wire.
+One typed client for the Platform API v2, derived from the platform's own route
+declaration. Calls are namespaced (`dalp.api.token.transfer(...)`), a queue
+backed write resolves once the chain has settled, and TanStack Query factories
+sit on the same nodes as the calls. The package ships no runtime schema
+library: the types are compile time only.
+
+Two interpreters over one route table. The package root returns promises. The
+`./effect` subpath returns Effect values with a typed failure channel. Neither
+pulls the other in, and a build gate keeps the root free of Effect.
 
 ## Client
 
@@ -15,77 +20,117 @@ const dalp = createDalpClient({
   apiKey: "sm_dalp_...",
 });
 
-const tokens = await dalp.token.list({ query: {} }, { signal });
+const tokens = await dalp.api.token.list({ limit: 25 }, { signal });
+```
+
+A call takes one flat object. The route table says which of its keys are path
+parameters and which are query or body fields, so a call site names what it
+means and never restates the transport. The build refuses any route whose path
+parameter would collide with a body or query key, which is what makes the
+merge safe.
+
+`createDalpClient` owns the shared transport policy once: the credential
+mechanism, the acting-context headers (`organizationId`, `participant`,
+`executor`, `chainId`, `selectedSigners`, `idempotencyKey`), conditional
+`If-None-Match` reuse, custom fetch injection, the settlement bound, and abort
+propagation.
+
+**An API key cannot reach a browser.** `createDalpClient` throws at
+construction when a key is passed with `runtime: "browser"`, rather than at the
+first request. A key carries the full authority of the identity it belongs to.
+In a browser the client authenticates with the session cookie instead.
+
+### Dispatch by route id
+
+```ts
+const token = await dalp.execute("token/read", { assetId });
 ```
 
-`createDalpClient` owns shared transport policy once: the credential mechanism
-(session cookie in the browser and on SSR, or an `X-Api-Key` header for
-server/CLI callers — never both from the same runtime), organization headers,
-idempotency keys, `Prefer`, conditional `If-None-Match` / ETag reuse, custom fetch
-injection, and abort propagation. See the "Credential ownership matrix" JSDoc
-on `createDalpClient` in `src/client/factory.ts` for which runtime may use
-which credential.
+`execute` is typed against the id through the `DalpRouteTypes` registry, so a
+command surface built from route ids keeps the same request and response types
+the namespaced tree gives a call site. The CLI, the end-to-end harness, and the
+demo scripts are all built on it.
+
+### Settlement
 
-Response decoding is strict: every generated operation parses its response
-against the declared zod schema and throws on a mismatch.
+A queue-backed write resolves with the settled record, not with the platform's
+acceptance. The platform answers such a route either with the settled body or
+with a handle to poll, and the client follows the handle so no caller writes
+that loop.
+
+A wait that runs out raises `SettlementTimeoutError` carrying the transaction
+id and the status URL. That is not a failed write: the transaction is still on
+its way to a block, and resubmitting is a second transfer. `settlementTimeoutMs`
+sets the bound per client, and a call may override it.
 
 ### Conditional requests and ETags
 
-`createDalpClient` installs `If-None-Match` / 304 interceptors that reuse a
-held body when the server returns a matching ETag. Server ETags must be
-**strong content digests** computed **after authorization** inside the
-requester's partition. The dapi response cache guarantees this: it hashes the
-serialized body after the request-context middleware has authenticated the
-session. Version-stamp ETags (generation counters, watermarks, table versions)
-are forbidden for conditional-request adopters — a stamp can collide across
-tenants or lag a body change.
+The client reuses a held body when the server answers a matching ETag with 304.
+Server ETags must be **strong content digests** computed **after
+authorization** inside the requester's partition. Version-stamp ETags
+(generation counters, watermarks, table versions) are forbidden for conditional
+request adopters: a stamp can collide across tenants or lag a body change.
 
 Identity changes that do not ride this client (browser sign-out, organization
-switch) must call `clearConditionalRequestStore(client)` so a later GET cannot
-send another session's `If-None-Match`.
+switch) must clear the held bodies, so a later GET cannot send another
+session's `If-None-Match`.
 
 ```ts
-import { clearConditionalRequestStore, createDalpClient } from "@settlemint/dalp-sdk";
-
-clearConditionalRequestStore(dalp);
+dalp.conditionalRequests.clear();
 ```
 
-## Generated operations
+## Effect
 
 ```ts
-import { createClient } from "@settlemint/dalp-sdk/operations";
+import { createDalpEffectClient } from "@settlemint/dalp-sdk/effect";
+
+const dalp = createDalpEffectClient({ baseUrl, apiKey });
+const tokens = yield * dalp.api.token.list({ limit: 25 });
 ```
 
-`./operations` re-exports the generated v2 operation functions and generated
-client primitives (585 operations) on their own subpath, so a consumer who
-only signs webhooks or builds a client never loads that module. Pair it with
-`createDalpClient` from the package root.
+The same routes, returning `Effect` values that fail with `DalpRequestError`
+rather than throwing. `execute` is typed by route id here too.
 
-## Scalars
+## The route table
+
+```ts
+import { routeIds, routeTable } from "@settlemint/dalp-sdk/routes";
+```
 
-Custom wire formats — BigDecimal amounts, EVM addresses, and the
-`OrganizationId` entity brand — are not expressed structurally in the
-generated OpenAPI spec (it carries no `format:`/`x-` extension for them), so
-each has a hand-maintained wrapper under `src/scalars/`:
-`big-decimal.ts`, `ethereum-address.ts`, `exchange-rates.ts`,
-`organization-id.ts`. `OrganizationId` is the only entity ID branded
-end-to-end across the platform (see `AGENTS.md`); every other identifier
-crossing this SDK's boundary is a plain string. `tools/scripts/src/check-sdk-scalar-coverage.ts`
-gates new generated scalar-shaped symbols against a curated allowlist so a
-spec change that introduces a new custom scalar fails the build instead of
-shipping unwrapped.
+`./routes` publishes the generated table both interpreters dispatch through:
+every v2 route's id, method, path template, statuses, and traits. It carries no
+client and no Effect, so a tool that only needs to know what the platform
+serves loads this rather than a client.
 
-## React Query
+## TanStack Query
 
 ```ts
-import { tokenListOptions } from "@settlemint/dalp-sdk/react-query";
+const options = dalp.api.token.list.queryOptions({ limit: 25 });
+const transfer = dalp.api.token.transfer.mutationOptions();
 ```
 
-`./react-query` re-exports the generated TanStack Query option factories
-(`queryOptions`, `infiniteOptions`, `mutationOptions`) — spread into your own
-hooks; the generator emits no hooks itself. This is the only module that
-imports `@tanstack/react-query`, so that peer dependency stays optional for
-non-React consumers.
+Every read node carries `queryOptions`; every write node carries
+`mutationOptions`. They are plain objects in the shapes TanStack
+Query expects, so nothing forces you into that library and nothing stops you
+using something else.
+
+Cache keys are derived from route identity plus canonicalized input, so two
+callers passing the same parameters in a different key order share one entry.
+`./react-query` exports `queryKeyFor` and `canonicalize` for building a
+matching invalidation filter, and `UI_SETTLEMENT_TIMEOUT_MS`, the shorter bound
+the mutation factories default to.
+
+## Scalars
+
+Custom wire formats (BigDecimal amounts, EVM addresses, and the
+`OrganizationId` entity brand) are not expressed structurally in the generated
+OpenAPI document, so `./scalars` carries a decoder for each:
+`decodeBigDecimal`, `decodeEthereumAddress`, `decodeOrganizationId`, and the
+exchange-rate response transformer. The route table names which fields carry a
+scalar, keyed by dotted path, so a consumer applies a decoder where the
+declaration says one lives rather than guessing from a field name.
+`OrganizationId` is the only entity id branded end to end across the platform;
+every other identifier crossing this boundary is a plain string.
 
 ## Auth
 
@@ -93,13 +138,17 @@ non-React consumers.
 import { createDalpAuthClient } from "@settlemint/dalp-sdk/auth";
 ```
 
-The generated SDK already exposes every auth REST operation; `./auth` covers
-what a REST call cannot express — the session/cookie state machine, plugin
-actions that must run in the browser (`passkeyClient` drives the WebAuthn
-ceremony through `navigator.credentials`), and the access-control model that
-evaluates a permission locally instead of round-tripping `has-permission`. Off
-the package root because it costs roughly 70 KiB of Better Auth a
-pure-operations consumer should not pay.
+The route surface already carries every auth REST route. `./auth` covers what a
+REST call cannot express: the session and cookie state machine, plugin actions
+that must run in the browser (`passkeyClient` drives the WebAuthn ceremony
+through `navigator.credentials`), and the access-control model that evaluates a
+permission locally instead of round-tripping. It sits off the package root
+because it costs roughly 70 KiB of Better Auth that a consumer who only calls
+routes should not pay.
+
+Better Auth's client types reference zod, so `zod` is an optional peer
+dependency: install it if you use `./auth`, skip it otherwise. No code in this
+package imports zod at runtime.
 
 ## Bundler and paymaster
 
@@ -107,34 +156,27 @@ pure-operations consumer should not pay.
 import { createDalpBundlerClient } from "@settlemint/dalp-sdk/bundler";
 ```
 
-`createDalpBundlerClient` retains the eight established ERC-4337 method names
-while calling the generated v2 REST resources underneath. The SDK accepts
-EntryPoint v0.9 `viem` shapes and returns the corresponding typed values.
+`createDalpBundlerClient` keeps the eight established ERC-4337 method names
+while calling the v2 REST resources underneath. It accepts EntryPoint v0.9
+`viem` shapes and returns the corresponding typed values.
 
 ## Webhooks and transaction wait
 
-- `./verify-webhook` — verify an inbound webhook signature.
-- `./sign-webhook-receipt` — sign a webhook delivery receipt (Node-only).
-- `./wait-for-transaction` — bounded poll for on-chain transaction settlement;
-  calls a generated operation and so inherits the generated validator
-  module's full weight.
+- `./verify-webhook` verifies an inbound webhook signature.
+- `./sign-webhook-receipt` signs a webhook delivery receipt (Node only).
+- `./wait-for-transaction` is a bounded poll for on-chain settlement, for a
+  transaction id you hold from somewhere other than a client call. A write made
+  through the client already waits.
 
 ## Package root
 
-The package root (`@settlemint/dalp-sdk`) stays deliberately small — the
-client factory, its config and errors, cookie-store transport, SSE lifecycle
-handling, and SDK version constants — so a consumer
-who only needs to call operations never pays for auth, bundler, react-query,
-or webhook code. See the `@module` doc at the top of `src/index.ts` for the
-current weight breakdown per subpath.
-
-## Migrating from the Effect client
-
-Prior major versions exposed an `Effect`-returning client
-(`makeDalpEffectClient`, `makeDalpApiLayer`, `DalpEffectClient`) alongside the
-Promise client. That dual surface, the `contracts/` schema re-exports, and
-`makeDalpPlatformClient`/`waitForTransactionEffect` are removed — see
-`CHANGELOG.md` and the
-[v2 migration guide](../docs/content/docs/api-reference/reference/v2-migration.mdx).
-No published consumer depended on the Effect surface, so this ships without a
-major version bump.
+The root stays small: the client factory, its options and errors, cookie-store
+transport, the settlement types, and the version constants. A consumer who only
+calls routes never pays for auth, bundler, TanStack Query, or webhook code.
+
+## Documentation
+
+The integrator guide lives under Developer reference in the platform docs:
+install and credentials, calling routes, mutations and settlement, streaming,
+TanStack Query, server rendering in TanStack Start and Next.js, and the Effect
+surface.

package/dist/auth/client.d.ts

@@ -1,5 +1,5 @@
 import type { DalpFetch } from "../client/ssr-fetch.ts";
-import type { AuthGetApiKeyListResponse, AuthGetOrganizationListResponse, AuthPostApiKeyCreateData, AuthPostApiKeyCreateResponse, AuthPostApiKeyDeleteData, AuthPostApiKeyDeleteResponse, AuthPostDeviceApproveData, AuthPostDeviceApproveResponse, AuthPostDeviceDenyData, AuthPostDeviceDenyResponse, AuthPostOrganizationAcceptInvitationData, AuthPostOrganizationAcceptInvitationResponse, AuthPostOrganizationCreateData, AuthPostOrganizationCreateResponse, AuthPostOrganizationRemoveMemberData, AuthPostOrganizationRemoveMemberResponse, AuthPostRevokeOtherSessionsResponse, AuthPostRevokeSessionData, AuthPostRevokeSessionResponse, AuthPostTwoFactorDisableData, AuthPostTwoFactorDisableResponse, AuthPostTwoFactorEnableData, AuthPostTwoFactorEnableResponse, AuthPostTwoFactorGenerateBackupCodesData, AuthPostTwoFactorGenerateBackupCodesResponse, AuthPostTwoFactorVerifyBackupCodeData, AuthPostTwoFactorVerifyBackupCodeResponse, AuthPostTwoFactorVerifyTotpData, AuthPostTwoFactorVerifyTotpResponse, CreateOrganizationInvitationData, CreateOrganizationInvitationResponse, GetSessionResponse, ListUserSessionsResponse, Member, SetActiveOrganizationData, SetActiveOrganizationResponse } from "../generated/types.gen.ts";
+import type { AuthGetApiKeyListResponse, AuthGetOrganizationListResponse, AuthPostApiKeyCreateData, AuthPostApiKeyCreateResponse, AuthPostApiKeyDeleteData, AuthPostApiKeyDeleteResponse, AuthPostDeviceApproveData, AuthPostDeviceApproveResponse, AuthPostDeviceDenyData, AuthPostDeviceDenyResponse, AuthPostOrganizationAcceptInvitationData, AuthPostOrganizationAcceptInvitationResponse, AuthPostOrganizationCreateData, AuthPostOrganizationCreateResponse, AuthPostOrganizationRemoveMemberData, AuthPostOrganizationRemoveMemberResponse, AuthPostRevokeOtherSessionsResponse, AuthPostRevokeSessionData, AuthPostRevokeSessionResponse, AuthPostTwoFactorDisableData, AuthPostTwoFactorDisableResponse, AuthPostTwoFactorEnableData, AuthPostTwoFactorEnableResponse, AuthPostTwoFactorGenerateBackupCodesData, AuthPostTwoFactorGenerateBackupCodesResponse, AuthPostTwoFactorVerifyBackupCodeData, AuthPostTwoFactorVerifyBackupCodeResponse, AuthPostTwoFactorVerifyTotpData, AuthPostTwoFactorVerifyTotpResponse, CreateOrganizationInvitationData, CreateOrganizationInvitationResponse, GetSessionResponse, ListUserSessionsResponse, Member, SetActiveOrganizationData, SetActiveOrganizationResponse } from "../generated/api-types.d.ts";
 import { Secret } from "../secret.ts";
 import type { CookieStoreShape } from "../transport/cookie-store.ts";
 export interface DalpAuthClientConfig {
@@ -31,9 +31,7 @@ export interface DalpAuthResult<TData = unknown, TError = DalpAuthError> {
 export type DalpAuthOperation<TInput, TData = unknown> = (input?: TInput, options?: unknown) => Promise<DalpAuthResult<TData>>;
 export type DalpRequiredAuthOperation<TInput, TData> = (input: TInput, options?: unknown) => Promise<DalpAuthResult<TData>>;
 export type DalpNoInputAuthOperation<TData> = (options?: unknown) => Promise<DalpAuthResult<TData>>;
-export type RequestBody<TData extends {
-    readonly body?: unknown;
-}> = NonNullable<TData["body"]>;
+export type RequestBody<TData> = TData;
 export interface DalpOrganizationMember extends Member {
     readonly user: {
         readonly id: string;

package/dist/auth.js

@@ -2,7 +2,7 @@ import {
   SDK_USER_AGENT,
   createCookieStoreFetch,
   makeCookieStore
-} from "./chunk-bz92thwh.js";
+} from "./chunk-mdegh3gh.js";
 import {
   normalizeDalpBaseUrl,
   secret,
@@ -26,24 +26,105 @@ import {
 } from "better-auth/client/plugins";
 
 // src/auth/client.ts
-import { z } from "zod";
-var authConfigSchema = z.object({
-  url: z.string().url().refine((value) => ["http:", "https:"].includes(new URL(value).protocol)),
-  apiKey: z.string().trim().min(1).transform(secret).optional(),
-  sessionToken: z.string().trim().min(1).transform(secret).optional(),
-  cookie: z.string().trim().min(1).transform(secret).optional(),
-  cookieStore: z.custom((value) => typeof value === "object" && value !== null && typeof value.header === "function" && typeof value.storeSetCookieHeaders === "function").optional(),
-  organizationId: z.string().trim().min(1).optional(),
-  headers: z.record(z.string(), z.string()).optional(),
-  fetch: z.custom((value) => typeof value === "function").optional()
-}).superRefine((value, context) => {
-  if ([value.apiKey, value.sessionToken, value.cookie].filter(Boolean).length > 1) {
-    context.addIssue({ code: "custom", message: "configure only one auth credential source" });
+class AuthConfigError extends Error {
+  constructor(field, requirement) {
+    super(`\`${field}\` ${requirement}`);
+    this.name = "AuthConfigError";
   }
-});
+}
+function optionalText(value, field) {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "string") {
+    return handleNonString(field);
+  }
+  const trimmed = value.trim();
+  if (trimmed.length === 0) {
+    throw new AuthConfigError(field, "must not be blank");
+  }
+  return trimmed;
+}
+function handleNonString(field) {
+  throw new AuthConfigError(field, "must be a string");
+}
+function requiredUrl(value) {
+  if (typeof value !== "string") {
+    return handleNonString("url");
+  }
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch {
+    throw new AuthConfigError("url", "must be a valid URL");
+  }
+  if (!["http:", "https:"].includes(parsed.protocol)) {
+    throw new AuthConfigError("url", "must use http or https");
+  }
+  return value;
+}
+function optionalHeaders(value) {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new AuthConfigError("headers", "must be an object of strings");
+  }
+  const headers = {};
+  for (const [name, header] of Object.entries(value)) {
+    if (typeof header !== "string") {
+      throw new AuthConfigError("headers", "must be an object of strings");
+    }
+    headers[name] = header;
+  }
+  return headers;
+}
+function optionalFetch(value) {
+  if (value === undefined) {
+    return;
+  }
+  if (typeof value !== "function") {
+    throw new AuthConfigError("fetch", "must be a function");
+  }
+  return value;
+}
+function optionalCookieStore(value) {
+  if (value === undefined) {
+    return;
+  }
+  const store = value;
+  if (typeof value !== "object" || value === null || typeof store.header !== "function" || typeof store.storeSetCookieHeaders !== "function") {
+    throw new AuthConfigError("cookieStore", "must expose header and storeSetCookieHeaders");
+  }
+  return store;
+}
+function decodeAuthConfig(input) {
+  const raw = input;
+  const apiKey = optionalText(raw.apiKey, "apiKey");
+  const sessionToken = optionalText(raw.sessionToken, "sessionToken");
+  const cookie = optionalText(raw.cookie, "cookie");
+  if ([apiKey, sessionToken, cookie].filter((credential) => credential !== undefined).length > 1) {
+    throw new AuthConfigError("apiKey/sessionToken/cookie", "configure only one auth credential source");
+  }
+  const url = requiredUrl(raw.url);
+  const cookieStore = optionalCookieStore(raw.cookieStore);
+  const organizationId = optionalText(raw.organizationId, "organizationId");
+  const headers = optionalHeaders(raw.headers);
+  const configuredFetch = optionalFetch(raw.fetch);
+  return {
+    url,
+    ...apiKey === undefined ? {} : { apiKey: secret(apiKey) },
+    ...sessionToken === undefined ? {} : { sessionToken: secret(sessionToken) },
+    ...cookie === undefined ? {} : { cookie: secret(cookie) },
+    ...cookieStore === undefined ? {} : { cookieStore },
+    ...organizationId === undefined ? {} : { organizationId },
+    ...headers === undefined ? {} : { headers },
+    ...configuredFetch === undefined ? {} : { fetch: configuredFetch }
+  };
+}
 async function decodeDalpAuthClientConfig(input) {
   try {
-    return await authConfigSchema.parseAsync(input);
+    return decodeAuthConfig(input);
   } catch (error) {
     throw createDalpSdkConfigurationError({
       message: "DALP SDK: auth client configuration is invalid.",

package/dist/bundler.d.ts

@@ -21,7 +21,4 @@ export interface DalpBundlerClient {
     getPaymasterStubData(operation: ReadonlyDeep<DalpUserOperationRequest>, entryPoint: Address): Promise<unknown>;
     getPaymasterData(operation: ReadonlyDeep<DalpUserOperationRequest>, entryPoint: Address): Promise<unknown>;
 }
-export type GeneratedEnvelope<T> = {
-    readonly data: T;
-};
 export declare function createDalpBundlerClient(config: DalpBundlerClientConfig): DalpBundlerClient;

package/dist/bundler.js

@@ -1,24 +1,19 @@
 import {
   createDalpClient
-} from "./chunk-cy9b59s6.js";
-import {
-  v2TransactionsBundlerEstimateUserOperationGas,
-  v2TransactionsBundlerGetChainId,
-  v2TransactionsBundlerGetPaymasterData,
-  v2TransactionsBundlerGetPaymasterStubData,
-  v2TransactionsBundlerGetSupportedEntryPoints,
-  v2TransactionsBundlerGetUserOperationByHash,
-  v2TransactionsBundlerGetUserOperationReceipt,
-  v2TransactionsBundlerSendUserOperation
-} from "./chunk-y0cggmp9.js";
-import"./chunk-w21k7p99.js";
-import"./chunk-gxtczja0.js";
+} from "./chunk-42msy2x5.js";
+import"./chunk-f4t1bm86.js";
+import"./chunk-armnnx1b.js";
+import"./chunk-apc9awed.js";
 import"./chunk-h12fatty.js";
 import"./chunk-y0d2c7kp.js";
 
 // src/bundler.ts
 import { getAddress, hexToBigInt, isHex } from "viem";
-var responseData = (result) => result.data.data;
+var responseData = (result) => {
+  const body = result !== null && typeof result === "object" ? Reflect.get(result, "data") : undefined;
+  const unwrapped = body ?? result;
+  return unwrapped !== null && typeof unwrapped === "object" ? unwrapped : {};
+};
 var requireHex = (value, field) => {
   if (typeof value !== "string" || !isHex(value)) {
     throw new TypeError(`DALP bundler response: ${field} must be an Ethereum hex value.`);
@@ -35,49 +30,43 @@ function createDalpBundlerClient(config) {
   });
   return {
     async sendUserOperation(operation, entryPoint) {
-      const result = await v2TransactionsBundlerSendUserOperation({
-        client,
-        body: { userOperation: operation, entryPoint },
-        throwOnError: true
+      const result = await client.execute("transactions/bundler/sendUserOperation", {
+        userOperation: operation,
+        entryPoint
       });
-      return requireHex(responseData(result).userOperationHash, "userOperationHash");
+      return requireHex(responseData(result)["userOperationHash"], "userOperationHash");
     },
     async estimateUserOperationGas(operation, entryPoint) {
-      const result = await v2TransactionsBundlerEstimateUserOperationGas({
-        client,
-        body: { userOperation: operation, entryPoint },
-        throwOnError: true
+      const result = await client.execute("transactions/bundler/estimateUserOperationGas", {
+        userOperation: operation,
+        entryPoint
       });
       const data = responseData(result);
       return {
-        preVerificationGas: requireHex(data.preVerificationGas, "preVerificationGas"),
-        verificationGasLimit: requireHex(data.verificationGasLimit, "verificationGasLimit"),
-        callGasLimit: requireHex(data.callGasLimit, "callGasLimit"),
-        ...data.paymasterVerificationGasLimit === undefined ? {} : {
-          paymasterVerificationGasLimit: requireHex(data.paymasterVerificationGasLimit, "paymasterVerificationGasLimit")
+        preVerificationGas: requireHex(data["preVerificationGas"], "preVerificationGas"),
+        verificationGasLimit: requireHex(data["verificationGasLimit"], "verificationGasLimit"),
+        callGasLimit: requireHex(data["callGasLimit"], "callGasLimit"),
+        ...data["paymasterVerificationGasLimit"] === undefined ? {} : {
+          paymasterVerificationGasLimit: requireHex(data["paymasterVerificationGasLimit"], "paymasterVerificationGasLimit")
         },
-        ...data.paymasterPostOpGasLimit === undefined ? {} : { paymasterPostOpGasLimit: requireHex(data.paymasterPostOpGasLimit, "paymasterPostOpGasLimit") }
+        ...data["paymasterPostOpGasLimit"] === undefined ? {} : { paymasterPostOpGasLimit: requireHex(data["paymasterPostOpGasLimit"], "paymasterPostOpGasLimit") }
       };
     },
     async getUserOperationByHash(hash) {
-      const result = await v2TransactionsBundlerGetUserOperationByHash({
-        client,
-        path: { userOperationHash: hash },
-        throwOnError: true
-      });
+      const result = await client.execute("transactions/bundler/getUserOperationByHash", { userOperationHash: hash });
       return responseData(result);
     },
     async getUserOperationReceipt(hash) {
-      const result = await v2TransactionsBundlerGetUserOperationReceipt({
-        client,
-        path: { userOperationHash: hash },
-        throwOnError: true
-      });
+      const result = await client.execute("transactions/bundler/getUserOperationReceipt", { userOperationHash: hash });
       return responseData(result);
     },
     async getSupportedEntryPoints() {
-      const result = await v2TransactionsBundlerGetSupportedEntryPoints({ client, throwOnError: true });
-      return responseData(result).entryPoints.map((entryPoint) => {
+      const result = await client.execute("transactions/bundler/getSupportedEntryPoints");
+      const entryPoints = responseData(result)["entryPoints"];
+      if (!Array.isArray(entryPoints)) {
+        throw new TypeError("DALP bundler response: entryPoints must be an array.");
+      }
+      return entryPoints.map((entryPoint) => {
         if (typeof entryPoint !== "string") {
           throw new TypeError("DALP bundler response: each entry point must be a string address.");
         }
@@ -85,22 +74,20 @@ function createDalpBundlerClient(config) {
       });
     },
     async getChainId() {
-      const result = await v2TransactionsBundlerGetChainId({ client, throwOnError: true });
-      return hexToBigInt(requireHex(responseData(result).chainId, "chainId"));
+      const result = await client.execute("transactions/bundler/getChainId");
+      return hexToBigInt(requireHex(responseData(result)["chainId"], "chainId"));
     },
     async getPaymasterStubData(operation, entryPoint) {
-      const result = await v2TransactionsBundlerGetPaymasterStubData({
-        client,
-        body: { userOperation: operation, entryPoint },
-        throwOnError: true
+      const result = await client.execute("transactions/bundler/getPaymasterStubData", {
+        userOperation: operation,
+        entryPoint
       });
       return responseData(result);
     },
     async getPaymasterData(operation, entryPoint) {
-      const result = await v2TransactionsBundlerGetPaymasterData({
-        client,
-        body: { userOperation: operation, entryPoint },
-        throwOnError: true
+      const result = await client.execute("transactions/bundler/getPaymasterData", {
+        userOperation: operation,
+        entryPoint
       });
       return responseData(result);
     }

package/dist/chunk-42msy2x5.js

@@ -0,0 +1,33 @@
+import {
+  buildProxy,
+  findRoute
+} from "./chunk-f4t1bm86.js";
+import {
+  createFetchExecutor,
+  createTanstackFactories,
+  createTransport,
+  sendRequest,
+  streamRequest
+} from "./chunk-armnnx1b.js";
+import {
+  data
+} from "./chunk-apc9awed.js";
+
+// src/proxy/client.ts
+function createDalpClient(options) {
+  const transport = createTransport(options);
+  const api = buildProxy(data, createFetchExecutor(transport), createTanstackFactories(transport));
+  return {
+    api,
+    conditionalRequests: transport.conditionalRequests,
+    execute: async (routeId, input, callOptions) => {
+      const route = findRoute(data, routeId);
+      if (route === undefined) {
+        throw new TypeError(`Unknown DALP route \`${routeId}\``);
+      }
+      const result = route.serializer === "sse" ? streamRequest(transport, route, input, callOptions) : await sendRequest(transport, route, input, callOptions);
+      return result;
+    }
+  };
+}
+export { createDalpClient };