@settlemint/dalp-sdk 3.1.33 → 3.2.0-rc.1

package/dist/routes/index.d.ts

@@ -0,0 +1,6 @@
+import { data as routeTable } from "../generated/routes.ts";
+export declare const routeIds: ReadonlyArray<keyof typeof routeTable.routes>;
+export { routeTable };
+export type { ResponseScalarTable, RouteRow, RouteTable } from "./types.ts";
+export { apiLineFor, cliCommandFor, commandPathForUrl, INDEX_COMMAND, isNonCliOperation, NON_CLI_OPERATIONS, staticUrlSegments, } from "./cli-command.ts";
+export type { CliCommand, CliCommandInput, CliInputValues } from "./cli-command.ts";

package/dist/routes/index.js

@@ -0,0 +1,122 @@
+import {
+  data2
+} from "../chunk-7mvx7xq8.js";
+
+// src/routes/cli-command.ts
+var INDEX_COMMAND = "index";
+var METHOD_VERB = {
+  GET: "get",
+  POST: "create",
+  PUT: "replace",
+  PATCH: "patch",
+  DELETE: "delete"
+};
+var NON_CLI_OPERATIONS = new Map([
+  ["token/conversionFeatureProbe", "Dapp converter form-validation probe."],
+  [
+    "platform.invitations.invitationsHasOnChainRoles",
+    "Dapp resend-dialog branch probe with no operator or scripting value."
+  ]
+]);
+function isNonCliOperation(operation) {
+  return NON_CLI_OPERATIONS.has(operation);
+}
+function verbForMethod(method) {
+  return METHOD_VERB[method.toUpperCase()] ?? method.toLowerCase();
+}
+var isPathParameter = (part) => part.startsWith("{") && part.endsWith("}") || part.startsWith(":");
+function staticUrlSegments(url) {
+  const parts = url.split("/").filter((part) => part.length > 0);
+  let start = 0;
+  if (parts[0] === "api" && parts[1] === "v2") {
+    start = 2;
+  } else if (parts[0] === "api") {
+    start = 1;
+  }
+  return parts.slice(start).filter((part) => !isPathParameter(part));
+}
+function commandPathForUrl(method, url) {
+  const verb = verbForMethod(method);
+  const segments = staticUrlSegments(url);
+  return segments.length === 0 ? [verb] : [verb, ...segments];
+}
+var PATH_SEPARATOR = "\x00";
+var BARE_ARGUMENT = /^[A-Za-z0-9_.:/@=,+-]+$/u;
+var parentPaths;
+function commandParents() {
+  if (parentPaths === undefined) {
+    const parents = new Set;
+    for (const [routeId, row] of Object.entries(data2.routes)) {
+      if (row === undefined || isNonCliOperation(routeId)) {
+        continue;
+      }
+      const path = commandPathForUrl(row.method, row.path);
+      for (let length = 1;length < path.length; length += 1) {
+        parents.add(path.slice(0, length).join(PATH_SEPARATOR));
+      }
+    }
+    parentPaths = parents;
+  }
+  return parentPaths;
+}
+function quote(argument) {
+  return BARE_ARGUMENT.test(argument) ? argument : `'${argument.replaceAll("'", String.raw`'\''`)}'`;
+}
+function positionalArguments(row, params) {
+  const values = [];
+  for (const name of row.params) {
+    const value = params[name];
+    if (typeof value !== "string" && typeof value !== "number") {
+      return null;
+    }
+    values.push(String(value));
+  }
+  return values;
+}
+var PATH_PARAMETER = /\{(\w+)\}|:(\w+)/gu;
+function apiLineFor(routeId, input) {
+  const row = Object.hasOwn(data2.routes, routeId) ? data2.routes[routeId] : undefined;
+  if (row === undefined) {
+    return null;
+  }
+  const params = input.params ?? {};
+  const path = row.path.replaceAll(PATH_PARAMETER, (_match, braced, colon) => {
+    const name = braced ?? colon ?? "";
+    const value = params[name];
+    return typeof value === "string" || typeof value === "number" ? encodeURIComponent(String(value)) : `:${name}`;
+  });
+  return `${row.method.toUpperCase()} /api/v2${path.startsWith("/") ? path : `/${path}`}`;
+}
+function cliCommandFor(routeId, input) {
+  const row = Object.hasOwn(data2.routes, routeId) ? data2.routes[routeId] : undefined;
+  if (row === undefined || isNonCliOperation(routeId) || row.method.toUpperCase() !== "GET") {
+    return null;
+  }
+  const positional = positionalArguments(row, input.params ?? {});
+  if (positional === null) {
+    return null;
+  }
+  const query = input.query ?? {};
+  const hasQuery = Object.keys(query).length > 0;
+  if (hasQuery && row.queryParams.length === 0) {
+    return null;
+  }
+  const path = commandPathForUrl(row.method, row.path);
+  const mounted = commandParents().has(path.join(PATH_SEPARATOR)) ? [...path, INDEX_COMMAND] : path;
+  const argv = ["dalp", ...mounted, ...positional, ...hasQuery ? ["--query", JSON.stringify(query)] : []];
+  return { argv, text: argv.map(quote).join(" ") };
+}
+
+// src/routes/index.ts
+var routeIds = Object.keys(data2.routes).sort();
+export {
+  INDEX_COMMAND,
+  NON_CLI_OPERATIONS,
+  apiLineFor,
+  cliCommandFor,
+  commandPathForUrl,
+  isNonCliOperation,
+  routeIds,
+  data2 as routeTable,
+  staticUrlSegments
+};

package/dist/routes/types.d.ts

@@ -0,0 +1,73 @@
+export interface RouteRow {
+    readonly method: string;
+    readonly path: string;
+    readonly params: ReadonlyArray<string>;
+    readonly successStatuses: ReadonlyArray<number>;
+    readonly errorStatuses: ReadonlyArray<number>;
+    readonly queueBacked: boolean;
+    readonly settlementTrait: string;
+    readonly serializer: string;
+    readonly auth: string;
+    readonly access: string;
+    readonly idempotency: boolean;
+    readonly hasPayload: boolean;
+    readonly bodyParams: ReadonlyArray<string>;
+    readonly queryParams: ReadonlyArray<string>;
+    readonly scalars: Readonly<Record<string, string | undefined>>;
+}
+export interface RouteTable {
+    readonly version: 1;
+    readonly routes: Readonly<Record<string, RouteRow | undefined>>;
+    readonly settlementDisagreements: ReadonlyArray<string>;
+}
+export interface ErrorCodeTable {
+    readonly version: 1;
+    readonly codes: ReadonlyArray<string>;
+}
+export interface ErrorCatalogEntry {
+    readonly id: string;
+    readonly status: number;
+}
+export interface ErrorCatalogTable {
+    readonly version: 1;
+    readonly entries: Readonly<Record<string, ErrorCatalogEntry>>;
+}
+export interface RouteErrorCodeTable {
+    readonly version: 1;
+    readonly routes: Readonly<Record<string, ReadonlyArray<number> | undefined>>;
+}
+export interface JsonSchemaNode {
+    readonly $ref?: string;
+    readonly type?: string | ReadonlyArray<string>;
+    readonly properties?: Readonly<Record<string, JsonSchemaNode>>;
+    readonly required?: ReadonlyArray<string>;
+    readonly additionalProperties?: boolean | JsonSchemaNode;
+    readonly propertyNames?: JsonSchemaNode;
+    readonly items?: JsonSchemaNode;
+    readonly prefixItems?: ReadonlyArray<JsonSchemaNode>;
+    readonly anyOf?: ReadonlyArray<JsonSchemaNode>;
+    readonly oneOf?: ReadonlyArray<JsonSchemaNode>;
+    readonly allOf?: ReadonlyArray<JsonSchemaNode>;
+    readonly enum?: ReadonlyArray<unknown>;
+    readonly const?: unknown;
+    readonly pattern?: string;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly minimum?: number;
+    readonly maximum?: number;
+    readonly exclusiveMinimum?: number;
+    readonly exclusiveMaximum?: number;
+    readonly multipleOf?: number;
+    readonly minItems?: number;
+    readonly maxItems?: number;
+    readonly uniqueItems?: boolean;
+}
+export interface ResponseSchemaTable {
+    readonly version: 1;
+    readonly definitions: Readonly<Record<string, JsonSchemaNode>>;
+    readonly routes: Readonly<Record<string, Readonly<Record<string, JsonSchemaNode | null>> | undefined>>;
+}
+export interface ResponseScalarTable {
+    readonly version: 1;
+    readonly routes: Readonly<Record<string, Readonly<Record<string, string>> | undefined>>;
+}

package/dist/runtime-exports.d.ts

@@ -0,0 +1,4 @@
+export declare const SDK_RUNTIME_EXPORT_RELATIVE_PATHS: readonly ["dist/index.js", "dist/types.js", "dist/react-query.js", "dist/effect.js", "dist/routes/index.js", "dist/routes/console.js", "dist/scalars/index.js", "dist/auth.js", "dist/verify-webhook.js", "dist/wait-for-transaction.js", "dist/errors/public-error.js", "dist/errors/sdk-error.js", "dist/sign-webhook-receipt.js", "dist/runtime-exports.js", "dist/index.d.ts", "dist/types.d.ts", "dist/react-query.d.ts", "dist/effect.d.ts", "dist/routes/index.d.ts", "dist/routes/console.d.ts", "dist/scalars/index.d.ts", "dist/auth.d.ts", "dist/verify-webhook.d.ts", "dist/wait-for-transaction.d.ts", "dist/errors/public-error.d.ts", "dist/errors/sdk-error.d.ts", "dist/sign-webhook-receipt.d.ts", "dist/runtime-exports.d.ts"];
+export declare const SDK_TYPE_ONLY_EXPORT_RELATIVE_PATHS: readonly ["dist/types.js"];
+export type SdkRuntimeExportRelativePath = (typeof SDK_RUNTIME_EXPORT_RELATIVE_PATHS)[number];
+export declare const SDK_BUILD_SENTINEL_RELATIVE_PATH: "dist/index.js";

package/dist/runtime-exports.js

@@ -0,0 +1,38 @@
+// src/runtime-exports.ts
+var SDK_RUNTIME_EXPORT_RELATIVE_PATHS = [
+  "dist/index.js",
+  "dist/types.js",
+  "dist/react-query.js",
+  "dist/effect.js",
+  "dist/routes/index.js",
+  "dist/routes/console.js",
+  "dist/scalars/index.js",
+  "dist/auth.js",
+  "dist/verify-webhook.js",
+  "dist/wait-for-transaction.js",
+  "dist/errors/public-error.js",
+  "dist/errors/sdk-error.js",
+  "dist/sign-webhook-receipt.js",
+  "dist/runtime-exports.js",
+  "dist/index.d.ts",
+  "dist/types.d.ts",
+  "dist/react-query.d.ts",
+  "dist/effect.d.ts",
+  "dist/routes/index.d.ts",
+  "dist/routes/console.d.ts",
+  "dist/scalars/index.d.ts",
+  "dist/auth.d.ts",
+  "dist/verify-webhook.d.ts",
+  "dist/wait-for-transaction.d.ts",
+  "dist/errors/public-error.d.ts",
+  "dist/errors/sdk-error.d.ts",
+  "dist/sign-webhook-receipt.d.ts",
+  "dist/runtime-exports.d.ts"
+];
+var SDK_TYPE_ONLY_EXPORT_RELATIVE_PATHS = ["dist/types.js"];
+var [SDK_BUILD_SENTINEL_RELATIVE_PATH] = SDK_RUNTIME_EXPORT_RELATIVE_PATHS;
+export {
+  SDK_BUILD_SENTINEL_RELATIVE_PATH,
+  SDK_RUNTIME_EXPORT_RELATIVE_PATHS,
+  SDK_TYPE_ONLY_EXPORT_RELATIVE_PATHS
+};

package/dist/runtime.d.ts

@@ -0,0 +1,8 @@
+export type DalpRuntime = "browser" | "server" | "react-native";
+export declare function detectDalpRuntime(): DalpRuntime;
+export declare function runtimeCredentials(runtime: DalpRuntime): RequestCredentials;
+export declare function refuseCrossOriginBrowserSession(runtime: DalpRuntime, baseUrl: string, usesApiKey: boolean): void;
+export declare function isBufferingFetch(fetchImpl: unknown): boolean;
+export declare function keepBufferingMarker<Wrapper extends object>(wrapped: unknown, wrapper: Wrapper): Wrapper;
+export declare function globalFetch(): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+export declare function refuseBundledApiKey(runtime: DalpRuntime): void;

package/dist/scalars/big-decimal.d.ts

@@ -0,0 +1,22 @@
+import * as dn from "dnum";
+import type { Dnum } from "dnum";
+export type BigDecimalValue = Dnum;
+export declare function decodeBigDecimal(wire: string): BigDecimalValue;
+export declare const encodeBigDecimal: (value: Dnum) => string;
+export declare const decimalOps: {
+    from: typeof dn.from;
+    isDnum: typeof dn.isDnum;
+    toString: typeof dn.toString;
+    toNumber: typeof dn.toNumber;
+    add: typeof dn.add;
+    subtract: typeof dn.sub;
+    multiply: typeof dn.mul;
+    divide: typeof dn.div;
+    setDecimals: typeof dn.setDecimals;
+    abs: typeof dn.abs;
+    equal: typeof dn.eq;
+    greaterThan: typeof dn.greaterThan;
+    lessThan: typeof dn.lessThan;
+    compare: typeof dn.cmp;
+};
+export type DecimalRounding = dn.Rounding;

package/dist/scalars/big-int.d.ts

@@ -0,0 +1,3 @@
+export type BigIntWireValue = string | number | bigint;
+export declare function tryDecodeBigInt(wire: unknown): bigint | undefined;
+export declare function decodeBigInt(wire: unknown, fallback?: bigint): bigint;

package/dist/scalars/dalp-scalars.d.ts

@@ -0,0 +1,28 @@
+import type { DalpScalar } from "../generated/api-types.ts";
+export type EvmAddress = DalpScalar<"EvmAddress">;
+export type EthereumHash = DalpScalar<"EthereumHash">;
+export type EthereumHex = DalpScalar<"EthereumHex">;
+export type CantonPartyId = DalpScalar<"CantonPartyId">;
+export type FiatCurrency = DalpScalar<"FiatCurrency">;
+export type NetworkId = DalpScalar<"NetworkId">;
+export type Timestamp = DalpScalar<"Timestamp">;
+export type IntegerString = `${bigint}`;
+export type DecimalString = `${number}`;
+export declare function isEvmAddress(value: unknown): value is EvmAddress;
+export declare function isEthereumHash(value: unknown): value is EthereumHash;
+export declare function isEthereumHex(value: unknown): value is EthereumHex;
+export declare function isCantonPartyId(value: unknown): value is CantonPartyId;
+export declare function isFiatCurrency(value: unknown): value is FiatCurrency;
+export declare function isNetworkId(value: unknown): value is NetworkId;
+export declare function isTimestamp(value: unknown): value is Timestamp;
+export declare function isIntegerString(value: unknown): value is IntegerString;
+export declare function isDecimalString(value: unknown): value is DecimalString;
+export declare const evmAddress: (value: string) => EvmAddress;
+export declare const ethereumHash: (value: string) => EthereumHash;
+export declare const ethereumHex: (value: string) => EthereumHex;
+export declare const cantonPartyId: (value: string) => CantonPartyId;
+export declare const fiatCurrency: (value: string) => FiatCurrency;
+export declare const networkId: (value: string) => NetworkId;
+export declare function timestamp(value: Date | string): Timestamp;
+export declare function integerString(value: bigint | number | string): IntegerString;
+export declare function decimalString(value: number | string): DecimalString;

package/dist/scalars/ethereum-address.d.ts

@@ -0,0 +1,3 @@
+import { type EvmAddress } from "./dalp-scalars.ts";
+export declare function decodeEthereumAddress(wire: string): EvmAddress;
+export declare function tryDecodeEthereumAddress(wire: unknown): EvmAddress | undefined;

package/dist/scalars/exchange-rates.d.ts

@@ -0,0 +1,13 @@
+import { type BigDecimalValue } from "./big-decimal.ts";
+import type { EvmAddress } from "./dalp-scalars.ts";
+export interface ExchangeRateRow {
+    readonly rate: BigDecimalValue | null;
+    readonly feedAddress: EvmAddress | null;
+    readonly [key: string]: unknown;
+}
+export interface ExchangeRatesListResponse {
+    readonly data: ReadonlyArray<ExchangeRateRow>;
+    readonly [key: string]: unknown;
+}
+export declare function decodeExchangeRatesListResponse(payload: unknown): ExchangeRatesListResponse;
+export declare const exchangeRatesListTransformer: (data: unknown) => Promise<ExchangeRatesListResponse>;

package/dist/scalars/index.d.ts

@@ -0,0 +1,14 @@
+export { decodeBigInt, tryDecodeBigInt } from "./big-int.ts";
+export type { BigIntWireValue } from "./big-int.ts";
+export { decodeBigDecimal, decimalOps, encodeBigDecimal } from "./big-decimal.ts";
+export type { DecimalRounding } from "./big-decimal.ts";
+export type { BigDecimalValue } from "./big-decimal.ts";
+export { decodeTokenDecimals } from "./token-decimals.ts";
+export type { TokenDecimals } from "./token-decimals.ts";
+export { decodeEthereumAddress, tryDecodeEthereumAddress } from "./ethereum-address.ts";
+export { cantonPartyId, decimalString, ethereumHash, ethereumHex, evmAddress, fiatCurrency, integerString, isCantonPartyId, isDecimalString, isEthereumHash, isEthereumHex, isEvmAddress, isFiatCurrency, isIntegerString, isNetworkId, isTimestamp, networkId, timestamp, } from "./dalp-scalars.ts";
+export type { CantonPartyId, DecimalString, EthereumHash, EthereumHex, EvmAddress, FiatCurrency, IntegerString, NetworkId, Timestamp, } from "./dalp-scalars.ts";
+export { decodeOrganizationId, tryDecodeOrganizationId } from "./organization-id.ts";
+export type { OrganizationIdValue } from "./organization-id.ts";
+export { decodeExchangeRatesListResponse, exchangeRatesListTransformer } from "./exchange-rates.ts";
+export type { ExchangeRateRow, ExchangeRatesListResponse } from "./exchange-rates.ts";

package/dist/scalars/index.js

@@ -0,0 +1,236 @@
+import {
+  DalpSdkError2
+} from "../chunk-k3ntysxx.js";
+
+// src/scalars/big-int.ts
+var INTEGER_WIRE = /^[+-]?\d+$/u;
+function tryDecodeBigInt(wire) {
+  if (typeof wire === "bigint") {
+    return wire;
+  }
+  if (typeof wire === "number") {
+    return Number.isSafeInteger(wire) ? BigInt(wire) : undefined;
+  }
+  return typeof wire === "string" && INTEGER_WIRE.test(wire) ? BigInt(wire) : undefined;
+}
+function decodeBigInt(wire, fallback) {
+  const value = tryDecodeBigInt(wire);
+  if (value !== undefined) {
+    return value;
+  }
+  if (fallback !== undefined) {
+    return fallback;
+  }
+  throw new TypeError("The value is not a safe integer or decimal integer string.");
+}
+// src/scalars/big-decimal.ts
+import * as dn from "dnum";
+var DECIMAL_WIRE = /^-?\d+(?:\.\d+)?$/u;
+function decodeBigDecimal(wire) {
+  if (!DECIMAL_WIRE.test(wire)) {
+    throw new DalpSdkError2({
+      code: "sdk.scalar.BIG_DECIMAL_INVALID",
+      category: "sdk.configuration",
+      retryable: false,
+      message: `\`${wire}\` is not a plain decimal string.`,
+      why: "A BigDecimal field carries an unscaled decimal, with no exponent and no separators.",
+      fix: "Pass the value exactly as the API returned it."
+    });
+  }
+  return dn.from(wire);
+}
+var encodeBigDecimal = (value) => dn.toString(value);
+var decimalOps = {
+  from: dn.from,
+  isDnum: dn.isDnum,
+  toString: dn.toString,
+  toNumber: dn.toNumber,
+  add: dn.add,
+  subtract: dn.subtract,
+  multiply: dn.multiply,
+  divide: dn.divide,
+  setDecimals: dn.setDecimals,
+  abs: dn.abs,
+  equal: dn.equal,
+  greaterThan: dn.greaterThan,
+  lessThan: dn.lessThan,
+  compare: dn.compare
+};
+// src/scalars/token-decimals.ts
+var DIGITS_PATTERN = /^\d+$/u;
+function decodeTokenDecimals(wire) {
+  const value = typeof wire === "string" && DIGITS_PATTERN.test(wire) ? Number(wire) : wire;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0 || value > 18) {
+    throw new DalpSdkError2({
+      code: "sdk.scalar.TOKEN_DECIMALS_INVALID",
+      category: "sdk.configuration",
+      retryable: false,
+      message: "Token decimals are missing or outside the range 0–18.",
+      why: "An ERC-20 token scale is a whole number from 0 through 18.",
+      fix: "Pass the decimals field exactly as the API returned it."
+    });
+  }
+  return value;
+}
+// src/scalars/ethereum-address.ts
+import { getAddress, isAddress as isAddress2 } from "viem/utils";
+
+// src/scalars/dalp-scalars.ts
+import { isAddress, isHash, isHex } from "viem/utils";
+var FIAT_CURRENCY = /^[A-Z]{3}$/u;
+var EPOCH_DIGITS = /^\d{1,16}$/u;
+var INTEGER_TEXT = /^-?\d+$/u;
+var DECIMAL_TEXT = /^[+-]?\d*\.?\d+(?:[Ee][+-]?\d+)?$/u;
+function isEvmAddress(value) {
+  return typeof value === "string" && isAddress(value);
+}
+function isEthereumHash(value) {
+  return typeof value === "string" && isHash(value);
+}
+function isEthereumHex(value) {
+  return typeof value === "string" && isHex(value, { strict: true });
+}
+function isCantonPartyId(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isFiatCurrency(value) {
+  return typeof value === "string" && FIAT_CURRENCY.test(value);
+}
+function isNetworkId(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isTimestamp(value) {
+  return typeof value === "string" && (EPOCH_DIGITS.test(value) || !Number.isNaN(Date.parse(value)));
+}
+function isIntegerString(value) {
+  return typeof value === "string" && INTEGER_TEXT.test(value);
+}
+function isDecimalString(value) {
+  return typeof value === "string" && DECIMAL_TEXT.test(value);
+}
+function refuse(code, value, identity, why) {
+  return new DalpSdkError2({
+    code,
+    category: "sdk.configuration",
+    retryable: false,
+    message: `\`${String(value)}\` is not a ${identity}.`,
+    why,
+    fix: `Pass a ${identity} the API returned, or check the value before you build the request.`
+  });
+}
+function scalar(guard, code, identity, why) {
+  return (value) => {
+    if (guard(value)) {
+      return value;
+    }
+    throw refuse(code, value, identity, why);
+  };
+}
+var evmAddress = scalar(isEvmAddress, "sdk.scalar.EVM_ADDRESS_INVALID", "EVM address", "An EVM address is 0x followed by 40 hex digits, with a valid checksum when it mixes upper and lower case.");
+var ethereumHash = scalar(isEthereumHash, "sdk.scalar.VALUE_INVALID", "transaction or block hash", "A hash is 0x followed by 64 hex digits.");
+var ethereumHex = scalar(isEthereumHex, "sdk.scalar.VALUE_INVALID", "hex string", "A hex string is 0x followed by hex digits.");
+var cantonPartyId = scalar(isCantonPartyId, "sdk.scalar.VALUE_INVALID", "Canton party id", "A Canton party id is a non-empty string.");
+var fiatCurrency = scalar(isFiatCurrency, "sdk.scalar.VALUE_INVALID", "currency code", "A currency code is three upper-case letters (ISO 4217).");
+var networkId = scalar(isNetworkId, "sdk.scalar.VALUE_INVALID", "network id", "A network id is a non-empty string.");
+var timestampText = scalar(isTimestamp, "sdk.scalar.VALUE_INVALID", "timestamp", "A timestamp is epoch milliseconds as digits, or a date and time such as an ISO 8601 string.");
+function timestamp(value) {
+  if (typeof value !== "string" && Number.isNaN(value.getTime())) {
+    throw refuse("sdk.scalar.VALUE_INVALID", value, "timestamp", "A Date must hold a valid point in time.");
+  }
+  return timestampText(typeof value === "string" ? value : value.toISOString());
+}
+var integerText = scalar(isIntegerString, "sdk.scalar.VALUE_INVALID", "whole number", "A whole number is written as digits, with an optional leading minus sign.");
+function integerString(value) {
+  if (typeof value === "bigint") {
+    return `${value}`;
+  }
+  if (typeof value === "number" && !Number.isSafeInteger(value)) {
+    throw refuse("sdk.scalar.VALUE_INVALID", value, "whole number", "A number must be a safe integer.");
+  }
+  return integerText(String(value));
+}
+var decimalText = scalar(isDecimalString, "sdk.scalar.VALUE_INVALID", "decimal number", "A decimal number is written as digits with an optional fraction and exponent.");
+function decimalString(value) {
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw refuse("sdk.scalar.VALUE_INVALID", value, "decimal number", "A number must be finite.");
+  }
+  return decimalText(String(value));
+}
+
+// src/scalars/ethereum-address.ts
+function decodeEthereumAddress(wire) {
+  return evmAddress(isAddress2(wire, { strict: false }) ? getAddress(wire) : wire);
+}
+function tryDecodeEthereumAddress(wire) {
+  if (typeof wire !== "string" || !isAddress2(wire, { strict: false })) {
+    return;
+  }
+  const checksummed = getAddress(wire);
+  return isEvmAddress(checksummed) ? checksummed : undefined;
+}
+// src/scalars/organization-id.ts
+function decodeOrganizationId(wire) {
+  if (wire.length === 0) {
+    throw new DalpSdkError2({
+      code: "sdk.scalar.ORGANIZATION_ID_INVALID",
+      category: "sdk.configuration",
+      retryable: false,
+      message: "An organization id cannot be empty.",
+      why: "The organization id scopes every tenant-owned request.",
+      fix: "Pass the id the platform returned for the active organization."
+    });
+  }
+  return wire;
+}
+function tryDecodeOrganizationId(wire) {
+  return typeof wire === "string" && wire.length > 0 ? wire : undefined;
+}
+// src/scalars/exchange-rates.ts
+function decodeRow(row) {
+  const source = row !== null && typeof row === "object" ? row : { rate: null, feedAddress: null };
+  const rate = Reflect.get(source, "rate");
+  const feedAddress = Reflect.get(source, "feedAddress");
+  return {
+    ...source,
+    rate: typeof rate === "string" ? decodeBigDecimal(rate) : null,
+    feedAddress: typeof feedAddress === "string" ? decodeEthereumAddress(feedAddress) : null
+  };
+}
+function decodeExchangeRatesListResponse(payload) {
+  const source = payload !== null && typeof payload === "object" ? payload : { data: [] };
+  const rows = Reflect.get(source, "data");
+  return { ...source, data: Array.isArray(rows) ? rows.map(decodeRow) : [] };
+}
+var exchangeRatesListTransformer = async (data) => decodeExchangeRatesListResponse(data);
+export {
+  cantonPartyId,
+  decimalOps,
+  decimalString,
+  decodeBigDecimal,
+  decodeBigInt,
+  decodeEthereumAddress,
+  decodeExchangeRatesListResponse,
+  decodeOrganizationId,
+  decodeTokenDecimals,
+  encodeBigDecimal,
+  ethereumHash,
+  ethereumHex,
+  evmAddress,
+  exchangeRatesListTransformer,
+  fiatCurrency,
+  integerString,
+  isCantonPartyId,
+  isDecimalString,
+  isEthereumHash,
+  isEthereumHex,
+  isEvmAddress,
+  isFiatCurrency,
+  isIntegerString,
+  isNetworkId,
+  isTimestamp,
+  networkId,
+  timestamp,
+  tryDecodeBigInt,
+  tryDecodeEthereumAddress,
+  tryDecodeOrganizationId
+};

package/dist/scalars/organization-id.d.ts

@@ -0,0 +1,5 @@
+export type OrganizationIdValue = string & {
+    readonly __brand: "OrganizationId";
+};
+export declare function decodeOrganizationId(wire: string): OrganizationIdValue;
+export declare function tryDecodeOrganizationId(wire: unknown): OrganizationIdValue | undefined;

package/dist/scalars/token-decimals.d.ts

@@ -0,0 +1,4 @@
+export type TokenDecimals = number & {
+    readonly __brand: "TokenDecimals";
+};
+export declare function decodeTokenDecimals(wire: string | number | undefined): TokenDecimals;

package/dist/secret.d.ts

@@ -0,0 +1,12 @@
+export declare const SECRET_REDACTION_MARKER = "[REDACTED]";
+declare const inspectSymbol: unique symbol;
+export declare class Secret {
+    private constructor();
+    static from(value: string): Secret;
+    toString(): string;
+    toJSON(): string;
+    [inspectSymbol](): string;
+}
+export declare const secret: (value: string) => Secret;
+export declare const unwrapSecret: (value: Secret) => string;
+export {};

package/dist/server-proxy.d.ts

@@ -0,0 +1,39 @@
+/** Edge proxy profile used to recover one verified client address. */
+export type DalpTrustedProxyProfile = "none" | "envoy" | "nginx" | "openshift";
+/** Fetch implementation used by the proxy; override this in tests or runtimes with a custom fetch. */
+export type DalpProxyFetch = (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+/** Structured details reported when the upstream cannot serve a proxied request. */
+export interface DalpProxyUpstreamFailure {
+    readonly method: string;
+    readonly path: string;
+    readonly upstream: string;
+    readonly errorName: string;
+    readonly errorMessage: string;
+    readonly errorCode: string | undefined;
+}
+/** Configuration for a same-origin DALP server proxy. */
+export interface CreateDalpProxyOptions {
+    readonly upstream: string | URL;
+    /** Public app origin stamped when the incoming request has no Origin header. */
+    readonly origin?: string | URL;
+    readonly trustedProxyProfile?: DalpTrustedProxyProfile;
+    /**
+     * `identity` (the default) asks the upstream for an uncompressed body. `forward` passes the browser's
+     * `Accept-Encoding` on and returns the compressed bytes untouched; use it only on a runtime whose fetch
+     * honours `decompress: false`, such as Bun, or the browser receives a decoded body labelled as compressed.
+     */
+    readonly acceptEncoding?: "identity" | "forward";
+    readonly fetch?: DalpProxyFetch;
+    readonly onUpstreamFailure?: (failure: DalpProxyUpstreamFailure) => void;
+    readonly upstreamFailureMessage?: (path: string) => string;
+}
+/** Standard Fetch handler returned by {@link createDalpProxy}. */
+export type DalpProxyHandler = (request: Request) => Promise<Response>;
+/**
+ * Create a same-origin proxy for DALP API and asset routes.
+ *
+ * The handler forwards cookies and supported request bodies, sanitizes proxy
+ * headers, preserves cookies and framed event streams, and returns a 502 when
+ * the configured upstream is unavailable.
+ */
+export declare function createDalpProxy(options: CreateDalpProxyOptions): DalpProxyHandler;