@settlemint/dalp-sdk 3.1.25 → 3.1.26-main.37116470199

package/dist/proxy/builder.d.ts

@@ -0,0 +1,17 @@
+import type { RouteRow, RouteTable } from "../routes/types.ts";
+export interface CallOptions {
+    readonly signal?: AbortSignal;
+    readonly settlementTimeoutMs?: number;
+    readonly headers?: Readonly<Record<string, string>> | (() => Readonly<Record<string, string>>);
+}
+export type Executor = (route: RouteRow, id: string, input: unknown, options: CallOptions | undefined) => unknown;
+export interface LeafExtras {
+    readonly queryOptions: (input?: unknown, options?: CallOptions) => unknown;
+    readonly mutationOptions: (options?: CallOptions) => unknown;
+}
+export interface LeafFactories {
+    readonly queryOptions: (route: RouteRow, id: string, input: unknown, options: CallOptions | undefined) => unknown;
+    readonly mutationOptions: (route: RouteRow, id: string, options: CallOptions | undefined) => unknown;
+}
+export declare function buildProxy(table: RouteTable, executor: Executor, factories: LeafFactories): unknown;
+export declare function findRoute(table: RouteTable, id: string): RouteRow | undefined;

package/dist/proxy/client-core.d.ts

@@ -0,0 +1,28 @@
+import type { DalpApi, DalpRouteTypes } from "../generated/api-types.d.ts";
+import type { RouteTable } from "../routes/types.ts";
+import { type CallOptions } from "./builder.ts";
+import type { DalpRequestParts } from "./flat-args.ts";
+import { type CreateDalpClientOptions } from "./transport.ts";
+export interface DalpRouteTypeEntry {
+    readonly request: unknown;
+    readonly requestParts?: unknown;
+    readonly response: unknown;
+    readonly streaming?: boolean;
+}
+export type DalpExecuteResult<Entry extends DalpRouteTypeEntry> = Promise<Entry["streaming"] extends true ? AsyncIterable<Entry["response"]> : Entry["response"]>;
+export type DalpStreamRouteKey<RouteTypes> = {
+    [Id in keyof RouteTypes]: RouteTypes[Id] extends {
+        readonly streaming: true;
+    } ? Id : never;
+}[keyof RouteTypes];
+export type DalpRequestRouteKey<RouteTypes> = Exclude<keyof RouteTypes, DalpStreamRouteKey<RouteTypes>>;
+export interface DalpClient<Api = DalpApi, RouteTypes extends Record<keyof RouteTypes, DalpRouteTypeEntry> = DalpRouteTypes> {
+    readonly api: Api;
+    readonly conditionalRequests: {
+        readonly clear: () => void;
+    };
+    readonly execute: <Id extends keyof RouteTypes>(routeId: Id, input?: RouteTypes[Id]["request"], options?: CallOptions) => DalpExecuteResult<RouteTypes[Id]>;
+    readonly sendParts: <Id extends DalpRequestRouteKey<RouteTypes>>(routeId: Id, parts?: DalpRequestParts<RouteTypes[Id]["requestParts"]>, options?: CallOptions) => Promise<RouteTypes[Id]["response"]>;
+    readonly streamParts: <Id extends DalpStreamRouteKey<RouteTypes>>(routeId: Id, parts?: DalpRequestParts<RouteTypes[Id]["requestParts"]>, options?: CallOptions) => AsyncIterable<RouteTypes[Id]["response"]>;
+}
+export declare function buildDalpClient<Api, RouteTypes extends Record<keyof RouteTypes, DalpRouteTypeEntry>>(options: CreateDalpClientOptions, table: RouteTable): DalpClient<Api, RouteTypes>;

package/dist/proxy/client.d.ts

@@ -0,0 +1,5 @@
+import { type DalpClient } from "./client-core.ts";
+import type { CreateDalpClientOptions } from "./transport.ts";
+export type { DalpClient, DalpExecuteResult, DalpRequestRouteKey, DalpRouteTypeEntry, DalpStreamRouteKey, } from "./client-core.ts";
+export type { DalpRequestParts } from "./flat-args.ts";
+export declare function createDalpClient(options: CreateDalpClientOptions): DalpClient;

package/dist/proxy/fetch-executor.d.ts

@@ -0,0 +1,6 @@
+import type { CallOptions, Executor } from "./builder.ts";
+import { type Transport } from "./transport.ts";
+import type { RouteRow } from "../routes/types.ts";
+import type { RequestInput } from "./flat-args.ts";
+export declare function sendRequest(transport: Transport, route: RouteRow, routeId: string, input: RequestInput, options: CallOptions | undefined): Promise<unknown>;
+export declare function createFetchExecutor(transport: Transport): Executor;

package/dist/proxy/flat-args.d.ts

@@ -0,0 +1,24 @@
+import type { RouteRow } from "../routes/types.ts";
+export type FlatCallValue = null | boolean | number | string | ReadonlyArray<FlatCallValue> | FlatCallObject;
+export interface FlatCallObject {
+    readonly [key: string]: FlatCallValue;
+}
+export type FlatCallInput = FlatCallObject;
+export interface SplitArgs {
+    readonly path: FlatCallInput;
+    readonly query: FlatCallInput;
+    readonly body: FlatCallInput | undefined;
+}
+export declare function splitFlatArgs(route: RouteRow, input: unknown): SplitArgs;
+export type DalpRequestParts<Parts> = {
+    [K in keyof Parts as K extends "path" ? "params" : K extends "url" ? never : K]: Parts[K];
+};
+export type RequestInput = {
+    readonly flat: unknown;
+} | {
+    readonly parts: unknown;
+};
+export declare function splitRequestParts(route: RouteRow, parts: unknown): SplitArgs;
+export declare function splitRequestInput(route: RouteRow, input: RequestInput): SplitArgs;
+export declare function buildPath(route: RouteRow, path: FlatCallInput): string;
+export declare function pathTarget(route: RouteRow, path: FlatCallInput): string | null;

package/dist/proxy/response-decode.d.ts

@@ -0,0 +1,37 @@
+import type { JsonSchemaNode, ResponseSchemaTable } from "../routes/types.ts";
+export declare const MALFORMED_SUCCESS_ERROR_CODE = "sdk.response.MALFORMED_SUCCESS";
+export interface ResponseMismatch {
+    readonly path: string;
+    readonly expected: string;
+    readonly received: string;
+}
+export declare class ResponseSchemaChecker {
+    private readonly compiled;
+    private readonly patterns;
+    private readonly definitions;
+    constructor(definitions: ResponseSchemaTable["definitions"]);
+    validate(node: JsonSchemaNode, value: unknown): boolean;
+    explain(node: JsonSchemaNode, value: unknown, path?: string): ResponseMismatch | undefined;
+    private definition;
+    private pattern;
+    private compile;
+    private build;
+    private buildValueChecks;
+    private buildObjectChecks;
+    private buildArrayChecks;
+    private buildCompositionChecks;
+    private explainType;
+    private explainValue;
+    private explainObject;
+    private explainArray;
+    private explainComposition;
+    private tagsMatch;
+}
+export declare class ResponseDecoder {
+    private readonly checker;
+    private readonly table;
+    constructor(table: ResponseSchemaTable);
+    declaresBody(routeId: string, status: number): boolean;
+    decode(routeId: string, status: number, payload: unknown): unknown;
+}
+export declare function loadResponseDecoder(): Promise<ResponseDecoder>;

package/dist/proxy/sse.d.ts

@@ -0,0 +1,11 @@
+import type { CallOptions } from "./builder.ts";
+import type { RouteRow } from "../routes/types.ts";
+import type { RequestInput } from "./flat-args.ts";
+import { type Transport } from "./transport.ts";
+export declare const RESERVED_STREAM_FAILURE_EVENT = "effect/http-api/stream/failure";
+export declare const STREAM_FAILED_ERROR_CODE = "sdk.stream.FAILED";
+export declare const STREAM_UNREADABLE_BODY_ERROR_CODE = "sdk.stream.UNREADABLE_BODY";
+type FrameDecoder = (frame: unknown) => unknown;
+export declare function decodeEventStream(body: ReadableStream<Uint8Array>, decodeFrame?: FrameDecoder, routeId?: string): AsyncGenerator<unknown>;
+export declare function streamRequest(transport: Transport, route: RouteRow, routeId: string, input: RequestInput, options: CallOptions | undefined): AsyncGenerator<unknown>;
+export {};

package/dist/proxy/step-up-challenge.d.ts

@@ -0,0 +1,4 @@
+import type { RouteRow } from "../routes/types.ts";
+import type { CallOptions } from "./builder.ts";
+import { type PreparedRequest, type Transport } from "./transport.ts";
+export declare function presentStepUpChallenge(transport: Transport, route: RouteRow, prepared: PreparedRequest, options: CallOptions | undefined): Promise<void>;

package/dist/proxy/tanstack.d.ts

@@ -0,0 +1,6 @@
+import type { LeafFactories } from "./builder.ts";
+import type { Transport } from "./transport.ts";
+export declare function canonicalize(value: unknown): unknown;
+export declare function queryKeyFor(id: string, input: unknown): ReadonlyArray<unknown>;
+export declare const UI_SETTLEMENT_TIMEOUT_MS = 30000;
+export declare function createTanstackFactories(transport: Transport): LeafFactories;

package/dist/proxy/transport.d.ts

@@ -0,0 +1,63 @@
+import { type DalpAuthSurface } from "../auth-surface.ts";
+import { Secret } from "../secret.ts";
+import { type DalpRuntime } from "../runtime.ts";
+import { type DalpFetch } from "../client/ssr-fetch.ts";
+import { type ConditionalRequestStore } from "../client/conditional-request.ts";
+import type { RouteRow } from "../routes/types.ts";
+import { type FlatCallInput, type RequestInput } from "./flat-args.ts";
+import type { CallOptions } from "./builder.ts";
+export interface DalpClientContext {
+    readonly organizationId?: string;
+    readonly participant?: string;
+    readonly executor?: "eoa" | "smart-wallet";
+    readonly chainId?: number | string;
+    readonly selectedSigners?: ReadonlyArray<string>;
+    readonly idempotencyKey?: string;
+}
+export interface DalpSsrOptions {
+    readonly requestHeaders: HeadersInit;
+    readonly allowedOrigins?: ReadonlyArray<string | URL>;
+}
+export interface CreateDalpClientOptions {
+    readonly baseUrl: string | URL;
+    readonly apiKey?: string | Secret;
+    readonly authSurface?: DalpAuthSurface;
+    readonly context?: DalpClientContext;
+    readonly fetch?: DalpFetch;
+    readonly runtime?: DalpRuntime;
+    readonly ssr?: DalpSsrOptions;
+    readonly settlementTimeoutMs?: number;
+}
+export declare const CONTEXT_HEADERS: {
+    readonly organizationId: "X-Organization-Id";
+    readonly participant: "X-Participant";
+    readonly executor: "X-Executor";
+    readonly chainId: "X-Chain-Id";
+    readonly selectedSigners: "X-Selected-Signers";
+    readonly idempotencyKey: "Idempotency-Key";
+};
+export declare function createDalpContextHeaders(context: DalpClientContext): Headers;
+export interface PreparedRequest {
+    readonly url: string;
+    readonly method: string;
+    readonly headers: Headers;
+    readonly pathParams: FlatCallInput;
+    readonly body: string | undefined;
+}
+export interface Transport {
+    readonly baseUrl: string;
+    readonly fetch: DalpFetch;
+    readonly credentials: RequestCredentials;
+    readonly apiKey: Secret | undefined;
+    readonly contextHeaders: Headers;
+    readonly settlementTimeoutMs: number | undefined;
+    readonly conditionalRequests: ConditionalRequestStore;
+    readonly streamsResponseBody: boolean;
+}
+export declare const DEFAULT_PREFER_WAIT_SECONDS = 15;
+export declare function createTransport(options: CreateDalpClientOptions): Transport;
+export declare function callHeaders(transport: Transport, options: CallOptions | undefined): Headers;
+export declare function prepareRequest(transport: Transport, route: RouteRow, input: RequestInput, options: CallOptions | undefined): PreparedRequest;
+export declare function raiseResponseError(response: Response, routeId: string): Promise<never>;
+export declare function readBinaryResponse(response: Response, routeId: string): Promise<Uint8Array>;
+export declare function readResponse(response: Response, routeId: string, bodyDeclared: boolean): Promise<unknown>;

package/dist/react-query.d.ts

@@ -0,0 +1,2 @@
+export { canonicalize, queryKeyFor, UI_SETTLEMENT_TIMEOUT_MS } from "./proxy/tanstack.ts";
+export type { CallOptions } from "./proxy/builder.ts";

package/dist/react-query.js

@@ -0,0 +1,12 @@
+import"./chunk-k3ntysxx.js";
+import {
+  canonicalize2,
+  queryKeyFor2,
+  UI_SETTLEMENT_TIMEOUT_MS2
+} from "./chunk-h241xecg.js";
+import"./chunk-4f4kjtt0.js";
+export {
+  UI_SETTLEMENT_TIMEOUT_MS2 as UI_SETTLEMENT_TIMEOUT_MS,
+  canonicalize2 as canonicalize,
+  queryKeyFor2 as queryKeyFor
+};

package/dist/readonly-deep.d.ts

@@ -0,0 +1,3 @@
+export type ReadonlyDeep<T> = T extends string | number | bigint | boolean | symbol | null | undefined | Date | RegExp | Map<unknown, unknown> | Set<unknown> | Promise<unknown> ? T : T extends CallableFunction ? T : T extends object ? {
+    readonly [Key in keyof T]: ReadonlyDeep<T[Key]>;
+} : T;

package/dist/routes/console.d.ts

@@ -0,0 +1,14 @@
+import { data as routeTable } from "../generated/console-routes.ts";
+import type { DalpConsoleApi, DalpConsoleRouteErrorCode, DalpConsoleRouteId, DalpConsoleRouteTypes } from "../generated/api-types.d.ts";
+import { type DalpApiError } from "../errors/api-error.ts";
+import { type DalpSdkLocalErrorCode } from "../errors/error-codes.ts";
+import { type DalpClient } from "../proxy/client-core.ts";
+import type { CreateDalpClientOptions } from "../proxy/transport.ts";
+export declare const routeIds: ReadonlyArray<keyof typeof routeTable.routes>;
+export type DalpConsoleClient = DalpClient<DalpConsoleApi, DalpConsoleRouteTypes>;
+export declare function createDalpConsoleClient(options: CreateDalpClientOptions): DalpConsoleClient;
+export declare const isDalpConsoleRouteError: <Id extends DalpConsoleRouteId>(error: unknown, ...routeIds: readonly [Id, ...ReadonlyArray<Id>]) => error is DalpApiError<DalpConsoleRouteErrorCode<Id> | DalpSdkLocalErrorCode>;
+export { routeTable };
+export type { DalpConsoleApi, DalpConsoleRouteErrorCode, DalpConsoleRouteId, DalpConsoleRouteTypes, } from "../generated/api-types.d.ts";
+export type { DalpRequestRouteKey, DalpStreamRouteKey } from "../proxy/client-core.ts";
+export type { DalpRequestParts } from "../proxy/flat-args.ts";