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

package/dist/client/query-serializer.d.ts

@@ -0,0 +1 @@
+export declare function serializeDalpQuery(query: unknown): string;

package/dist/client/request-compression.d.ts

@@ -0,0 +1,12 @@
+import type { DalpFetch } from "./ssr-fetch.ts";
+export declare const DALP_SDK_REQUEST_COMPRESSION_MIN_BODY_BYTES = 1024;
+export declare const DALP_SDK_REQUEST_COMPRESSION_MAX_BODY_BYTES = 16777216;
+export type FetchRequestCompression = true | "gzip" | "deflate" | "br" | "zstd";
+export interface CompressionRequestInit extends RequestInit {
+    readonly compress?: FetchRequestCompression;
+}
+export interface RequestBodyCompressionOptions {
+    readonly minBodyBytes?: number;
+    readonly maxBodyBytes?: number;
+}
+export declare function withRequestBodyCompression(fetchImpl: DalpFetch, options?: RequestBodyCompressionOptions): DalpFetch;

package/dist/client/ssr-fetch.d.ts

@@ -0,0 +1,10 @@
+export type DalpFetch = ((input: RequestInfo | URL, init?: RequestInit) => Promise<Response>) & {
+    readonly preconnect?: typeof fetch.preconnect;
+};
+export interface CreateSsrFetchOptions {
+    readonly allowedOrigins?: ReadonlyArray<string | URL>;
+    readonly baseUrl: string | URL;
+    readonly fetch: DalpFetch;
+    readonly requestHeaders: HeadersInit;
+}
+export declare function createSsrFetch(options: CreateSsrFetchOptions): DalpFetch;

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

@@ -0,0 +1,10 @@
+export declare const STEP_UP_CHALLENGE_HEADER = "X-Step-Up-Challenge";
+export declare const WALLET_VERIFICATION_HEADER = "X-Wallet-Verification";
+export declare const STEP_UP_CHALLENGE_PATH = "/api/v2/step-up-challenges";
+export interface StepUpChallengeRequest {
+    readonly operation: string;
+    readonly target: string | null;
+    readonly payloadDigest: string;
+}
+export declare function carriesWalletProof(body: unknown): boolean;
+export declare function stepUpChallengeRequest(operation: string, target: string | null, body: unknown): Promise<StepUpChallengeRequest>;

package/dist/effect.d.ts

@@ -0,0 +1,38 @@
+import * as Effect from "effect/Effect";
+import type { DalpApi, DalpRouteId, DalpRouteTypes } from "./generated/api-types.d.ts";
+import { type CallOptions } from "./proxy/builder.ts";
+import { type CreateDalpClientOptions } from "./proxy/transport.ts";
+import { DalpApiError } from "./errors/api-error.ts";
+export declare class DalpRequestError<Code extends string = string> extends Error {
+    readonly _tag = "DalpRequestError";
+    readonly id: string;
+    readonly code: Code;
+    readonly status: number | undefined;
+    readonly retryable: boolean;
+    readonly retryAfterSeconds: number | undefined;
+    readonly routeId: string;
+    readonly data: DalpApiError["data"];
+    constructor(routeId: string, cause: unknown);
+}
+export type DalpEffectApi = DalpEffectApiNode<DalpApi>;
+type DalpEffectApiNode<T> = {
+    readonly [K in keyof T]: T[K] extends (...args: infer Args) => AsyncIterable<infer Frame> ? T[K] extends {
+        readonly __errorCode?: infer Code extends string;
+    } ? (...args: Args) => Effect.Effect<AsyncIterable<Frame>, DalpRequestError<Code>> : (...args: Args) => Effect.Effect<AsyncIterable<Frame>, DalpRequestError> : T[K] extends (...args: infer Args) => Promise<infer A> ? T[K] extends {
+        readonly __errorCode?: infer Code extends string;
+    } ? (...args: Args) => Effect.Effect<A, DalpRequestError<Code>> : (...args: Args) => Effect.Effect<A, DalpRequestError> : DalpEffectApiNode<T[K]>;
+};
+export type DalpStreamingRouteId = {
+    [Id in DalpRouteId]: DalpRouteTypes[Id]["streaming"] extends true ? Id : never;
+}[DalpRouteId];
+export interface DalpEffectClient {
+    readonly api: DalpEffectApi;
+    readonly execute: {
+        <Id extends DalpStreamingRouteId>(routeId: Id, input?: DalpRouteTypes[Id]["request"], options?: CallOptions): Effect.Effect<AsyncIterable<DalpRouteTypes[Id]["response"]>, DalpRequestError>;
+        <Id extends DalpRouteId>(routeId: Id, input?: DalpRouteTypes[Id]["request"], options?: CallOptions): Effect.Effect<DalpRouteTypes[Id]["response"], DalpRequestError>;
+    };
+}
+export declare function createDalpEffectClient(options: CreateDalpClientOptions): DalpEffectClient;
+export type { CallOptions } from "./proxy/builder.ts";
+export type { CreateDalpClientOptions } from "./proxy/transport.ts";
+export type { DalpRouteId, DalpRouteTypes } from "./generated/api-types.d.ts";

package/dist/effect.js

@@ -0,0 +1,87 @@
+import {
+  data2
+} from "./chunk-hqz56e6q.js";
+import"./chunk-k3ntysxx.js";
+import {
+  DalpApiError2,
+  createTransport,
+  streamRequest,
+  sendRequest,
+  queryKeyFor2
+} from "./chunk-h241xecg.js";
+import"./chunk-4f4kjtt0.js";
+import {
+  buildProxy,
+  findRoute
+} from "./chunk-b03ycwb7.js";
+
+// src/effect.ts
+import * as Effect from "effect/Effect";
+class DalpRequestError extends Error {
+  _tag = "DalpRequestError";
+  id;
+  code;
+  status;
+  retryable;
+  retryAfterSeconds;
+  routeId;
+  data;
+  constructor(routeId, cause) {
+    const api = cause instanceof DalpApiError2 ? cause : undefined;
+    super(api?.message ?? `DALP request failed for ${routeId}`, { cause });
+    this.name = "DalpRequestError";
+    this._tag = "DalpRequestError";
+    this.routeId = routeId;
+    this.code = api?.code ?? "sdk.transport.REQUEST_FAILED";
+    this.id = api?.id ?? this.code;
+    this.status = api?.status;
+    this.retryable = api?.retryable ?? true;
+    this.retryAfterSeconds = api?.retryAfterSeconds;
+    this.data = api?.data;
+  }
+}
+function runRoute(transport, route, id, input, options) {
+  return Effect.callback((resume) => {
+    const controller = new AbortController;
+    const signal = options?.signal ?? controller.signal;
+    const run = async () => {
+      try {
+        resume(Effect.succeed(route.serializer === "sse" ? streamRequest(transport, route, id, { flat: input }, { ...options, signal }) : await sendRequest(transport, route, id, { flat: input }, { ...options, signal })));
+      } catch (error) {
+        resume(Effect.fail(new DalpRequestError(id, error)));
+      }
+    };
+    run();
+    return Effect.sync(() => {
+      controller.abort();
+    });
+  });
+}
+function createDalpEffectClient(options) {
+  const transport = createTransport(options);
+  const executor = (route, id, input, callOptions) => runRoute(transport, route, id, input, callOptions);
+  const factories = {
+    queryOptions: (route, id, input, callOptions) => ({
+      queryKey: queryKeyFor2(id, input),
+      queryFn: () => runRoute(transport, route, id, input, callOptions)
+    }),
+    mutationOptions: (route, id, callOptions) => ({
+      mutationKey: ["dalp", id],
+      mutationFn: (input) => runRoute(transport, route, id, input, callOptions)
+    })
+  };
+  return {
+    api: buildProxy(data2, executor, factories),
+    execute: (routeId, input, callOptions) => {
+      const route = findRoute(data2, routeId);
+      if (route === undefined) {
+        return Effect.fail(new DalpRequestError(routeId, new TypeError(`Unknown DALP route \`${routeId}\``)));
+      }
+      return runRoute(transport, route, routeId, input, callOptions);
+    }
+  };
+}
+export {
+  DalpRequestError,
+  createDalpEffectClient
+};

package/dist/errors/api-error.d.ts

@@ -0,0 +1,35 @@
+import { findCurrentError } from "./find-current-error.ts";
+import type { DalpSdkErrorDetails } from "./sdk-error.ts";
+import type { DalpApiErrorCode } from "./error-codes.ts";
+export type DalpApiErrorCategory = "client" | "auth" | "permission" | "domain" | "contract" | "dependency" | "operational" | "config" | "unknown";
+export interface DalpApiErrorOptions<Code extends DalpApiErrorCode = DalpApiErrorCode> {
+    readonly message: string;
+    readonly cause?: unknown;
+    readonly id?: string;
+    readonly code: Code;
+    readonly routeId?: string;
+    readonly category: DalpApiErrorCategory;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly why: string;
+    readonly fix: string;
+    readonly retryAfterSeconds?: number;
+    readonly data?: DalpSdkErrorDetails;
+}
+export declare class DalpApiError<Code extends DalpApiErrorCode = DalpApiErrorCode> extends Error {
+    readonly id?: string;
+    readonly code: Code;
+    readonly routeId?: string;
+    readonly category: DalpApiErrorCategory;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly why: string;
+    readonly fix: string;
+    readonly retryAfterSeconds?: number;
+    readonly data?: DalpSdkErrorDetails;
+    constructor(options: DalpApiErrorOptions<Code>);
+    static make(options: DalpApiErrorOptions): DalpApiError;
+}
+export declare const isDalpApiError: (error: unknown) => error is DalpApiError;
+export declare const findDalpSdkError: typeof findCurrentError;
+export declare const makeDalpApiError: (error: unknown) => DalpApiError;

package/dist/errors/error-codes.d.ts

@@ -0,0 +1,21 @@
+import type { DalpErrorCode, DalpRouteErrorCode, DalpRouteId } from "../generated/api-types.d.ts";
+import { type DalpApiError } from "./api-error.ts";
+export type DalpSdkLocalErrorCode = "DALP_SDK_ERROR" | "sdk.transport.REQUEST_FAILED" | "sdk.transport.MALFORMED_RESPONSE" | "sdk.transport.UNPUBLISHED_ERROR_CODE" | "sdk.transport.UNVERIFIED_ERROR_CODE" | `sdk.transport.HTTP_${number}` | "sdk.response.MALFORMED_SUCCESS" | "sdk.stream.FAILED" | "sdk.stream.UNREADABLE_BODY" | "sdk.scalar.BIG_DECIMAL_INVALID" | "sdk.scalar.EVM_ADDRESS_INVALID" | "sdk.scalar.ORGANIZATION_ID_INVALID" | "sdk.scalar.TOKEN_DECIMALS_INVALID";
+export type DalpApiErrorCode = DalpErrorCode | DalpSdkLocalErrorCode;
+export declare const isDalpErrorCode: (code: string) => code is DalpErrorCode;
+export declare const isDalpSdkLocalErrorCode: (code: string) => code is DalpSdkLocalErrorCode;
+export declare const isDalpApiErrorCode: (code: string) => code is DalpApiErrorCode;
+/** @internal */
+export type RouteErrorCodeCheck = {
+    readonly kind: "published";
+    readonly code: DalpErrorCode;
+} | {
+    readonly kind: "unpublished";
+} | {
+    readonly kind: "unverified";
+};
+/** @internal */
+export declare function checkRouteErrorCode(routeId: string, code: string): Promise<RouteErrorCodeCheck>;
+/** @internal */
+export declare const answeredByRoute: (error: DalpApiError, routeIds: ReadonlyArray<string>) => boolean;
+export declare const isDalpRouteError: <Id extends DalpRouteId>(error: unknown, ...routeIds: readonly [Id, ...ReadonlyArray<Id>]) => error is DalpApiError<DalpRouteErrorCode<Id> | DalpSdkLocalErrorCode>;

package/dist/errors/find-current-error.d.ts

@@ -0,0 +1,2 @@
+import { DalpSdkError } from "./sdk-error.ts";
+export declare const findCurrentError: (error: unknown, maxNodes?: number) => DalpSdkError | undefined;

package/dist/errors/sdk-error.d.ts

@@ -0,0 +1,52 @@
+import type { DalpApiErrorCode } from "./error-codes.ts";
+export interface DalpSdkErrorOptions {
+    readonly code?: DalpApiErrorCode;
+    readonly routeId?: string;
+    readonly category: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly message: string;
+    readonly why: string;
+    readonly fix: string;
+    readonly details?: DalpSdkErrorDetails;
+    readonly retryAfterSeconds?: number;
+    readonly cause?: unknown;
+}
+export type DalpSdkJsonValue = null | boolean | number | string | ReadonlyArray<DalpSdkJsonValue> | DalpSdkJsonObject;
+export interface DalpSdkJsonObject {
+    readonly [key: string]: DalpSdkJsonValue;
+}
+export type DalpSdkErrorDetails = DalpSdkJsonObject;
+export interface DalpSdkConfigurationErrorInput {
+    readonly message: string;
+    readonly why: string;
+    readonly fix: string;
+    readonly cause?: unknown;
+}
+export interface DalpSdkErrorJson {
+    readonly name: "DalpSdkError";
+    readonly code: DalpApiErrorCode;
+    readonly routeId?: string;
+    readonly category: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly message: string;
+    readonly why: string;
+    readonly fix: string;
+    readonly details?: DalpSdkErrorDetails;
+    readonly retryAfterSeconds?: number;
+}
+export declare class DalpSdkError extends Error {
+    readonly code: DalpApiErrorCode;
+    readonly routeId?: string;
+    readonly category: string;
+    readonly status?: number;
+    readonly retryable: boolean;
+    readonly why: string;
+    readonly fix: string;
+    readonly details?: DalpSdkErrorDetails;
+    readonly retryAfterSeconds?: number;
+    constructor(options: Readonly<DalpSdkErrorOptions>);
+    toJSON(): DalpSdkErrorJson;
+}
+export declare function createDalpSdkConfigurationError(input: Readonly<DalpSdkConfigurationErrorInput>): DalpSdkError;

package/dist/errors/sdk-error.js

@@ -0,0 +1,8 @@
+import {
+  DalpSdkError2,
+  createDalpSdkConfigurationError2
+} from "../chunk-k3ntysxx.js";
+export {
+  DalpSdkError2 as DalpSdkError,
+  createDalpSdkConfigurationError2 as createDalpSdkConfigurationError
+};