@otim/utils 0.0.5 → 0.0.7

package/dist/api/index.mjs

@@ -1,2066 +1,1509 @@
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { i as getOffchainApiUrl } from "../api-urls-DJcIKBCy.mjs";
+import { t as _defineProperty } from "../defineProperty-DzhmunJg.mjs";
+import { z as z$1 } from "zod";
+import axios from "axios";
+import { InstructionAction, PaymentsSchema, eip2098SignatureSchema, hexStringSchema, instructionActionValues, instructionSchema, instructionsSchema, numberSchema, sortValues, transactionSchema, userSchema, vrsSchema } from "@otim/utils/schemas";
+import { parseSchema } from "@otim/utils/helpers";
 
-// src/api/core/error.ts
-import { z } from "zod";
-var apiErrorSchema = z.object({
-  code: z.string().nullish(),
-  message: z.string().nullish(),
-  errorCode: z.string().nullish(),
-  errorMessage: z.string().nullish(),
-  status: z.number().nullish(),
-  context: z.object({
-    field_errors: z.record(z.string(), z.string()).nullish()
-  }).nullish()
-});
-var errorResponseSchema = z.object({
-  message: z.string().nullish(),
-  errorMessage: z.string().nullish(),
-  errorCode: z.string().nullish(),
-  errors: z.array(apiErrorSchema).nullish()
-});
-var defaultErrorCode = "unknown";
-var defaultErrorMessage = "Unexpected error";
+//#region src/api/core/error.ts
+const apiErrorSchema = z$1.object({
+	code: z$1.string().nullish(),
+	message: z$1.string().nullish(),
+	errorCode: z$1.string().nullish(),
+	errorMessage: z$1.string().nullish(),
+	status: z$1.number().nullish(),
+	context: z$1.object({ field_errors: z$1.record(z$1.string(), z$1.string()).nullish() }).nullish()
+});
+const errorResponseSchema = z$1.object({
+	message: z$1.string().nullish(),
+	errorMessage: z$1.string().nullish(),
+	errorCode: z$1.string().nullish(),
+	errors: z$1.array(apiErrorSchema).nullish()
+});
+const defaultErrorCode = "unknown";
+const defaultErrorMessage = "Unexpected error";
+/**
+* Extract the most likely server-provided error payload from a thrown value.
+* Supports common shapes from HTTP clients (Axios/fetch) and plain objects.
+*/
 function extractErrorData(maybeError) {
-  let errorData = maybeError?.body;
-  if (!errorData && maybeError?.response?.data) {
-    errorData = maybeError.response.data;
-  }
-  if (!errorData && (maybeError?.errorMessage || maybeError?.message || maybeError?.errorCode)) {
-    errorData = maybeError;
-  }
-  return errorData;
+	let errorData = maybeError?.body;
+	if (!errorData && maybeError?.response?.data) errorData = maybeError.response.data;
+	if (!errorData && (maybeError?.errorMessage || maybeError?.message || maybeError?.errorCode)) errorData = maybeError;
+	return errorData;
 }
+/**
+* Normalize Error Shapes Into One User‑Facing Message.
+* Why: Prefer server messages and avoid leaking technical details.
+*
+* @param maybeError An unknown error thrown by an HTTP client, SDK, or server.
+* @param fallbackMessage Message used when the payload cannot be parsed or
+* lacks a message.
+*/
 function getErrorMessage(maybeError, fallbackMessage) {
-  const errorMessage = fallbackMessage ?? defaultErrorMessage;
-  const errorData = extractErrorData(maybeError);
-  const result = errorResponseSchema.safeParse(errorData);
-  if (!result.success) {
-    return errorMessage;
-  }
-  const { message, errorMessage: apiErrorMessage, errors } = result.data;
-  return apiErrorMessage ?? message ?? errors?.[0]?.errorMessage ?? errors?.[0]?.message ?? errorMessage;
+	const errorMessage = fallbackMessage ?? defaultErrorMessage;
+	const errorData = extractErrorData(maybeError);
+	const result = errorResponseSchema.safeParse(errorData);
+	if (!result.success) return errorMessage;
+	const { message, errorMessage: apiErrorMessage, errors } = result.data;
+	/**
+	* Prioritize Error Message From Backend, Then Message, Then Errors Array.
+	* Surfaces the most specific, server‑intended feedback first for better UX.
+	*/
+	return apiErrorMessage ?? message ?? errors?.[0]?.errorMessage ?? errors?.[0]?.message ?? errorMessage;
 }
+/**
+* Provide A Unified Error Message And Code For UI/Control‑Flow.
+* Why: Normalize shapes and fall back to an "unknown" code.
+*
+* @param maybeError An unknown error thrown by an HTTP client, SDK, or server.
+* @param fallbackMessage Message used when the payload cannot be parsed or is
+* empty.
+*/
 function getErrorMessageWithCode(maybeError, fallbackMessage) {
-  const errorMessage = fallbackMessage ?? defaultErrorMessage;
-  const errorData = extractErrorData(maybeError);
-  const result = errorResponseSchema.safeParse(errorData);
-  if (!result.success || !result.data.errors?.[0] && !result.data.errorMessage && !result.data.message) {
-    return {
-      message: errorMessage,
-      code: defaultErrorCode
-    };
-  }
-  const {
-    message,
-    errorMessage: apiErrorMessage,
-    errorCode,
-    errors
-  } = result.data;
-  return {
-    message: apiErrorMessage ?? message ?? errors?.[0]?.errorMessage ?? errors?.[0]?.message ?? errorMessage,
-    code: errorCode ?? errors?.[0]?.errorCode ?? errors?.[0]?.code ?? defaultErrorCode
-  };
+	const errorMessage = fallbackMessage ?? defaultErrorMessage;
+	const errorData = extractErrorData(maybeError);
+	const result = errorResponseSchema.safeParse(errorData);
+	if (!result.success || !result.data.errors?.[0] && !result.data.errorMessage && !result.data.message) return {
+		message: errorMessage,
+		code: defaultErrorCode
+	};
+	const { message, errorMessage: apiErrorMessage, errorCode, errors } = result.data;
+	return {
+		message: apiErrorMessage ?? message ?? errors?.[0]?.errorMessage ?? errors?.[0]?.message ?? errorMessage,
+		code: errorCode ?? errors?.[0]?.errorCode ?? errors?.[0]?.code ?? defaultErrorCode
+	};
 }
+/**
+* Detect User Rejection (e.g., Canceled Wallet Signature).
+* Why: Treat cancellations as benign and keep telemetry clean.
+*
+* @param error The error object to check.
+* @returns true if the error is a user rejection, false otherwise.
+*/
 function isUserRejectionError(error) {
-  if (!error) return false;
-  let errorMessage = "";
-  if (typeof error === "string") {
-    errorMessage = error;
-  } else if (typeof error === "object") {
-    errorMessage = error.message || error.errorMessage || error.details || "";
-  }
-  if (!errorMessage) {
-    errorMessage = String(error);
-  }
-  errorMessage = errorMessage.toLowerCase();
-  const rejectionPatterns = [
-    "user rejected",
-    "user denied",
-    "user cancelled",
-    "cancelled by user",
-    "rejected by user",
-    "user abort",
-    "transaction rejected",
-    "signature rejected",
-    "request rejected"
-  ];
-  return rejectionPatterns.some((pattern) => errorMessage.includes(pattern));
+	if (!error) return false;
+	/**
+	* Safely Extract Error Message From Various Possible Error Formats.
+	* Providers may throw strings, plain objects, or non-Error values.
+	*/
+	let errorMessage = "";
+	if (typeof error === "string") errorMessage = error;
+	else if (typeof error === "object") errorMessage = error.message || error.errorMessage || error.details || "";
+	if (!errorMessage) errorMessage = String(error);
+	errorMessage = errorMessage.toLowerCase();
+	return [
+		"user rejected",
+		"user denied",
+		"user cancelled",
+		"cancelled by user",
+		"rejected by user",
+		"user abort",
+		"transaction rejected",
+		"signature rejected",
+		"request rejected"
+	].some((pattern) => errorMessage.includes(pattern));
 }
-var isUserAddressableError = (errorCode, errorMessage) => {
-  const isInUserErrorRange = errorCode >= 1e3 && errorCode < 2e3;
-  const hasErrorMessage = Boolean(errorMessage);
-  return isInUserErrorRange && hasErrorMessage;
+/**
+* Determine If An Error Code Is User‑Addressable.
+* Why: 1000–1999 are intended to be surfaced to users.
+*
+* @param errorCode The error code to check.
+* @param errorMessage Optional error message.
+*/
+const isUserAddressableError = (errorCode, errorMessage) => {
+	return errorCode >= 1e3 && errorCode < 2e3 && Boolean(errorMessage);
 };
+/**
+* Detect Whether An Error Looks Technical/Low‑Level.
+* Why: Avoid leaking framework/runtime details to users; rely on logging.
+*/
 function isTechnicalError(error) {
-  if (!error) return false;
-  let errorMessage = "";
-  if (typeof error === "string") {
-    errorMessage = error;
-  } else if (typeof error === "object") {
-    errorMessage = error.message || error.errorMessage || error.details || "";
-  }
-  if (!errorMessage) {
-    errorMessage = String(error);
-  }
-  errorMessage = errorMessage.toLowerCase();
-  const technicalErrorPatterns = [
-    "is not a function",
-    "cannot read prop",
-    "cannot read property",
-    "reading undefined",
-    "read undefined of",
-    "cannot access before initialization",
-    "is not defined",
-    "is undefined",
-    "is null",
-    "unexpected token",
-    "syntax error",
-    "reference error",
-    "type error",
-    "network error",
-    "failed to fetch",
-    "server components"
-  ];
-  return technicalErrorPatterns.some(
-    (pattern) => errorMessage.includes(pattern)
-  );
+	if (!error) return false;
+	/**
+	* Safely Extract Error Message From Various Possible Error Formats.
+	* Upstream code can throw strings or custom objects instead of Error
+	* instances.
+	*/
+	let errorMessage = "";
+	if (typeof error === "string") errorMessage = error;
+	else if (typeof error === "object") errorMessage = error.message || error.errorMessage || error.details || "";
+	if (!errorMessage) errorMessage = String(error);
+	errorMessage = errorMessage.toLowerCase();
+	return [
+		"is not a function",
+		"cannot read prop",
+		"cannot read property",
+		"reading undefined",
+		"read undefined of",
+		"cannot access before initialization",
+		"is not defined",
+		"is undefined",
+		"is null",
+		"unexpected token",
+		"syntax error",
+		"reference error",
+		"type error",
+		"network error",
+		"failed to fetch",
+		"server components"
+	].some((pattern) => errorMessage.includes(pattern));
 }
 function getUserFriendlyErrorMessage(error, fallbackMessage) {
-  if (isTechnicalError(error)) {
-    return "Internal server error";
-  }
-  return getErrorMessage(error, fallbackMessage);
+	if (isTechnicalError(error)) return "Internal server error";
+	return getErrorMessage(error, fallbackMessage);
 }
 
-// src/api/core/instance.ts
-import axios from "axios";
-var API_INSTANCE_DEFAULT_TIMEOUT = 3e4;
-var createInstance = (config) => {
-  const instance = axios.create({
-    timeout: API_INSTANCE_DEFAULT_TIMEOUT,
-    ...config
-  });
-  return instance;
+//#endregion
+//#region src/api/core/instance.ts
+const API_INSTANCE_DEFAULT_TIMEOUT = 3e4;
+const createInstance = (config) => {
+	return axios.create({
+		timeout: API_INSTANCE_DEFAULT_TIMEOUT,
+		...config
+	});
 };
-var createAbortController = () => {
-  return new AbortController();
+const createAbortController = () => {
+	return new AbortController();
 };
-var isInstanceInit = (init) => {
-  return !!init && typeof init === "object" && "instance" in init;
+const isInstanceInit = (init) => {
+	return !!init && typeof init === "object" && "instance" in init;
 };
 
-// src/api/core/service.ts
+//#endregion
+//#region src/api/core/service.ts
 var ServiceError = class extends Error {
-  constructor(message, code) {
-    super(message);
-    this.code = code;
-    this.name = "ServiceError";
-  }
+	constructor(message, code) {
+		super(message);
+		this.code = code;
+		this.name = "ServiceError";
+	}
 };
-var HttpMethod = {
-  Get: "GET",
-  Post: "POST",
-  Put: "PUT",
-  Delete: "DELETE"
-};
-
-// src/api/schemas/account.ts
-import { z as z2 } from "zod";
-var DelegationStatus = {
-  Undelegated: "Undelegated",
-  Pending: "Pending",
-  Delegated: "Delegated",
-  Expired: "Expired",
-  Errored: "Errored"
+const HttpMethod = {
+	Get: "GET",
+	Post: "POST",
+	Put: "PUT",
+	Delete: "DELETE"
 };
-var delegationStatusValues = Object.values(DelegationStatus);
-var delegationStatusSchema = z2.enum(delegationStatusValues);
-var delegationStatusRequestSchema = z2.object({
-  address: z2.string(),
-  chainId: z2.number()
-});
-var delegationStatusResponseSchema = z2.object({
-  delegationStatus: delegationStatusSchema
-});
-var delegationCreateRequestSchema = z2.object({
-  signedAuthorization: z2.string(),
-  signerAddress: z2.string()
-});
-var delegationCreateResponseSchema = z2.object({
-  success: z2.boolean(),
-  transactionHash: z2.string().optional(),
-  message: z2.string().optional()
-});
 
-// src/api/schemas/activity.ts
-import { z as z8 } from "zod";
-
-// src/schemas/instruction.ts
-import { z as z4 } from "zod";
-
-// src/schemas/misc.ts
-import { z as z3 } from "zod";
-var DATE_REGEX = /^(19|20)\d{2}-(0[1-9]|1[0-2])-(0[1-9]|[12]\d|3[01])$/;
-var DATE_ISO_8601_REGEX = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})?$/;
-var DATE_STANDARD_REGEX = /^(0[1-9]|1[0-2])\/(0[1-9]|[12][0-9]|3[01])\/(19|20)\d{2}$/;
-var TIME_REGEX = /^(0[1-9]|1[0-2]):[0-5][0-9]:[0-5][0-9] (AM|PM)$/;
-var regexSchema = (regex, message) => z3.string().regex(regex, message);
-var nonEmptyStringSchema = z3.string().min(1);
-var numberSchema = z3.union([
-  z3.number().finite(),
-  z3.string().regex(/^-?\d*\.?\d+(?:[eE][-+]?\d+)?$/).transform(Number)
-]);
-var decimalStringSchema = z3.string().regex(/^-?\d*\.?\d+$/).refine((val) => !isNaN(parseFloat(val)), {
-  message: "Must be a valid decimal number"
-});
-var bigintSchema = z3.union([
-  z3.bigint(),
-  z3.string().regex(/^-?\d+$/).transform(BigInt)
-]);
-var hexStringSchema = z3.string().startsWith("0x").transform((val) => val);
-var dateSchema = regexSchema(DATE_REGEX);
-var dateISO8601Schema = regexSchema(DATE_ISO_8601_REGEX);
-var dateStandardSchema = regexSchema(DATE_STANDARD_REGEX);
-var timeSchema = regexSchema(TIME_REGEX);
-var Sort = {
-  Asc: "asc",
-  Desc: "desc"
+//#endregion
+//#region src/api/schemas/account.ts
+const DelegationStatus = {
+	Undelegated: "Undelegated",
+	Pending: "Pending",
+	Delegated: "Delegated",
+	Expired: "Expired",
+	Errored: "Errored"
 };
-var sortValues = Object.values(Sort);
-var vrsSchema = z3.object({
-  v: z3.number(),
-  r: z3.string(),
-  s: z3.string()
-});
-var eip2098SignatureSchema = z3.object({
-  yParity: z3.number(),
-  r: z3.string(),
-  s: z3.string()
+const delegationStatusValues = Object.values(DelegationStatus);
+const delegationStatusSchema = z$1.enum(delegationStatusValues);
+const delegationStatusRequestSchema = z$1.object({
+	address: z$1.string(),
+	chainId: z$1.number()
+});
+const delegationStatusResponseSchema = z$1.object({ delegationStatus: delegationStatusSchema });
+const delegationCreateRequestSchema = z$1.object({
+	signedAuthorization: z$1.string(),
+	signerAddress: z$1.string()
+});
+const delegationCreateResponseSchema = z$1.object({
+	success: z$1.boolean(),
+	transactionHash: z$1.string().optional(),
+	message: z$1.string().optional()
 });
 
-// src/schemas/instruction.ts
-var instructionIdSchema = hexStringSchema;
-var InstructionState = {
-  PendingActivation: "PendingActivation",
-  Active: "Active",
-  PendingDeactivation: "PendingDeactivation",
-  Deactivated: "Deactivated",
-  Errored: "Errored",
-  Completed: "Completed",
-  UserNotDelegated: "UserNotDelegated",
-  InFlight: "InFlight",
-  NotifyUser: "NotifyUser"
+//#endregion
+//#region src/api/schemas/activity.ts
+const actionNameSchema = z$1.enum(instructionActionValues);
+/**
+* Human-readable labels for automation action names.
+*/
+const ACTION_NAME_LABELS = {
+	[InstructionAction.Refuel]: "Refuel",
+	[InstructionAction.RefuelERC20]: "Refuel",
+	[InstructionAction.Transfer]: "Transfer",
+	[InstructionAction.TransferERC20]: "Transfer",
+	[InstructionAction.TransferCCTP]: "Transfer",
+	[InstructionAction.Sweep]: "Sweep",
+	[InstructionAction.SweepERC20]: "Sweep",
+	[InstructionAction.SweepCCTP]: "Sweep",
+	[InstructionAction.SweepUniswapV3]: "Trade",
+	[InstructionAction.UniswapV3ExactInput]: "Trade",
+	[InstructionAction.DepositERC4626]: "Deposit",
+	[InstructionAction.SweepDepositERC4626]: "Deposit",
+	[InstructionAction.WithdrawERC4626]: "Withdraw",
+	[InstructionAction.SweepWithdrawERC4626]: "Withdraw",
+	[InstructionAction.DeactivateInstruction]: "Deactivate",
+	[InstructionAction.CallOnce]: "Call Once"
 };
-var instructionStateValues = Object.values(InstructionState);
-var instructionStateSchema = z4.enum(instructionStateValues);
-var InstructionAction = {
-  RefuelERC20: "refuelERC20",
-  Refuel: "refuel",
-  Transfer: "transfer",
-  TransferERC20: "transferERC20",
-  UniswapV3ExactInput: "uniswapV3ExactInput",
-  Sweep: "sweep",
-  SweepERC20: "sweepERC20",
-  SweepCCTP: "sweepCCTP",
-  SweepUniswapV3: "sweepUniswapV3",
-  SweepDepositAccount: "sweepDepositAccount",
-  SweepDepositAccountERC20: "sweepDepositAccountERC20",
-  DeactivateInstruction: "deactivateInstruction",
-  SweepSkipCCTPDepositAccount: "sweepSkipCCTPDepositAccount"
+const DEFAULT_ACTION_LABEL = "–";
+/**
+* Human-readable labels for payment rails.
+*/
+const PAYMENT_RAIL_LABELS = {
+	ach_push: "ACH",
+	pix: "PIX",
+	sepa: "SEPA",
+	spei: "SPEI",
+	wire: "Wire"
 };
-var instructionActionValues = Object.values(InstructionAction);
-var instructionActionSchema = z4.enum(instructionActionValues);
-var InstructionScheduleStartType = {
-  Now: "now",
-  DateTime: "datetime"
-};
-var instructionScheduleStartValues = Object.values(
-  InstructionScheduleStartType
-);
-var baseStartSchema = z4.object({
-  type: z4.enum(instructionScheduleStartValues)
-});
-var nowStartSchema = baseStartSchema.extend({
-  type: z4.literal(InstructionScheduleStartType.Now)
-});
-var dateTimeStartSchema = baseStartSchema.extend({
-  type: z4.literal(InstructionScheduleStartType.DateTime),
-  startDate: dateStandardSchema,
-  startTime: z4.string()
-});
-var instructionScheduleStartSchema = z4.discriminatedUnion("type", [
-  nowStartSchema,
-  dateTimeStartSchema
-]);
-var InstructionScheduleRepeatType = {
-  UntilDeactivated: "until-deactivated",
-  MaxExecutions: "max-executions"
+/**
+* Human-readable labels for virtual account event types.
+*/
+const VIRTUAL_ACCOUNT_EVENT_LABELS = {
+	funds_received: "Funds Received",
+	payment_submitted: "Payment Submitted",
+	payment_processed: "Payment Processed",
+	in_review: "In Review",
+	microdeposit: "Microdeposit",
+	funds_scheduled: "Funds Scheduled"
 };
-var instructionScheduleRepeatValues = Object.values(
-  InstructionScheduleRepeatType
-);
-var baseRepeatSchema = z4.object({});
-var untilDeactivatedRepeatSchema = baseRepeatSchema.extend({
-  type: z4.literal(InstructionScheduleRepeatType.UntilDeactivated)
-});
-var maxExecutionsRepeatSchema = baseRepeatSchema.extend({
-  type: z4.literal(InstructionScheduleRepeatType.MaxExecutions),
-  maxExecutions: numberSchema
-});
-var instructionScheduleRepeatSchema = z4.discriminatedUnion("type", [
-  untilDeactivatedRepeatSchema,
-  maxExecutionsRepeatSchema
-]);
-var InstructionScheduleRetryType = {
-  UntilDeactivated: "until-deactivated",
-  TimeLimited: "time-limited"
-};
-var instructionScheduleRetryValues = Object.values(
-  InstructionScheduleRetryType
-);
-var baseRetrySchema = z4.object({});
-var untilDeactivatedRetrySchema = baseRetrySchema.extend({
-  type: z4.literal(InstructionScheduleRetryType.UntilDeactivated)
-});
-var timeLimitedRetrySchema = baseRetrySchema.extend({
-  type: z4.literal(InstructionScheduleRetryType.TimeLimited),
-  retryCount: numberSchema
-});
-var instructionScheduleRetrySchema = z4.discriminatedUnion("type", [
-  untilDeactivatedRetrySchema,
-  timeLimitedRetrySchema
-]);
-var TimeUnit = {
-  None: "none",
-  Second: "second",
-  Minute: "minute",
-  Hour: "hour",
-  Day: "day",
-  Week: "week",
-  Month: "month"
-};
-var timeUnitValues = Object.values(TimeUnit);
-var timeUnitSchema = z4.enum(timeUnitValues);
-var instructionExecutionStateSchema = z4.object({
-  executionStatus: instructionStateSchema.optional(),
-  executionCounter: z4.number().int().optional(),
-  lastExecuted: z4.number().int().optional()
-});
-var instructionSchema = z4.object({
-  instructionId: hexStringSchema,
-  createdAt: z4.number().optional(),
-  startAt: z4.string().nullish(),
-  interval: z4.number().nullish(),
-  timeout: z4.number().nullish(),
-  maxExecutions: z4.number().nullish(),
-  executionState: instructionExecutionStateSchema.optional(),
-  actionName: z4.string().optional(),
-  arguments: z4.any(),
-  nickname: z4.string().nullish(),
-  lastInstructedValue: z4.string().optional(),
-  lastErrorCode: z4.number().nullish(),
-  lastErrorMessage: z4.string().nullish(),
-  totalInstructedValue: z4.string().optional(),
-  instructedTokenAddress: hexStringSchema.nullish(),
-  chainId: z4.number().nullish(),
-  chain: z4.string().optional()
-});
-var instructionsSchema = z4.array(instructionSchema);
-var instructionSummarySchema = z4.object({
-  instructionId: hexStringSchema,
-  chainId: z4.number().int(),
-  executionCount: z4.number().int(),
-  onTimeCount: z4.number().int(),
-  lateCount: z4.number().int(),
-  wasActivatedDuring: z4.boolean(),
-  amount: z4.number().default(0),
-  instructedValue: z4.string().nullish().default("0"),
-  instructedTokenAddress: z4.string().nullish().default(null)
-});
-var instructionSummariesSchema = z4.array(instructionSummarySchema);
-var instructionSummariesByDateSchema = z4.record(
-  z4.string(),
-  instructionSummariesSchema
-);
-var InstructionViewTimescale = {
-  Days: "days",
-  Hours: "hours",
-  Minutes: "minutes",
-  Seconds: "seconds"
-};
-var instructionViewTimescaleValues = Object.values(
-  InstructionViewTimescale
-);
-
-// src/schemas/payment.ts
-import { z as z5 } from "zod";
-var PaymentStatus = {
-  Due: "due",
-  NotDue: "not-due",
-  Paid: "paid"
-};
-var PaymentSource = {
-  Bill: "Bill",
-  Stripe: "Stripe",
-  Clio: "Clio",
-  QuickBooks: "QuickBooks"
-};
-var paymentRequestSourceValues = [
-  PaymentSource.Bill,
-  PaymentSource.Stripe,
-  PaymentSource.Clio,
-  PaymentSource.QuickBooks
-];
-var paymentSchema = z5.object({
-  id: z5.string(),
-  fromUserId: z5.string().nullable().optional(),
-  toUserId: z5.string().nullable().optional(),
-  payerAddress: z5.string().nullable().optional(),
-  ephemeralWalletAddress: z5.string(),
-  ephemeralWalletId: z5.string().optional(),
-  instructions: z5.object({
-    ids: z5.array(z5.string()),
-    completionIds: z5.array(z5.string())
-  }).optional(),
-  metadata: z5.record(z5.string(), z5.unknown()).optional(),
-  // UI-derived fields
-  status: z5.union([
-    z5.literal(PaymentStatus.Due),
-    z5.literal(PaymentStatus.NotDue),
-    z5.literal(PaymentStatus.Paid)
-  ]),
-  dueDate: z5.string(),
-  amountDue: z5.number(),
-  note: z5.string().nullable().optional(),
-  address: z5.string().nullable().optional(),
-  addedOn: z5.string(),
-  source: z5.union([
-    z5.literal(PaymentSource.Bill),
-    z5.literal(PaymentSource.Stripe),
-    z5.literal(PaymentSource.Clio),
-    z5.literal(PaymentSource.QuickBooks)
-  ]).nullish(),
-  attachmentUrl: z5.string().url().nullable().optional(),
-  attachmentName: z5.string().nullable().optional(),
-  fromAccountAddress: z5.string().nullable().optional()
-});
-var PaymentsSchema = z5.array(paymentSchema);
-
-// src/schemas/transaction.ts
-import { z as z6 } from "zod";
-var transactionSchema = z6.object({
-  instructionId: instructionIdSchema,
-  transactionHash: hexStringSchema.optional(),
-  blockHash: z6.string().nullable(),
-  transactionStatus: z6.string(),
-  error: z6.string().nullish(),
-  startedAt: z6.string(),
-  startedAtBlock: z6.number(),
-  finishedAt: z6.string().nullable(),
-  finishedAtBlock: z6.number().nullable(),
-  amount: z6.object({ value: z6.number(), token: z6.string() }).nullish(),
-  instructedValue: z6.string(),
-  instructedTokenAddress: z6.string().nullable(),
-  executionNum: z6.number(),
-  chainId: z6.number().nullish(),
-  chain: z6.string().optional()
-});
-var transactionWithValidAmountSchema = transactionSchema.extend({
-  amount: z6.object({
-    value: z6.number(),
-    token: z6.string()
-  })
-});
-var transactionsSchema = z6.array(transactionSchema);
-
-// src/schemas/user.ts
-import { z as z7 } from "zod";
-var entityIdSchema = z7.string().uuid();
-var addressSchema = z7.string().regex(/^0x[a-fA-F0-9]{40}$/).transform((v) => v.toLowerCase());
-var userPreferencesSchema = z7.object({
-  chainId: z7.number().optional(),
-  tokenSymbol: z7.string().optional(),
-  localCurrency: z7.string().optional()
-});
-var userSchema = z7.object({
-  id: entityIdSchema,
-  address: addressSchema,
-  createdAt: z7.string(),
-  updatedAt: z7.string(),
-  preferences: userPreferencesSchema.optional(),
-  isDeveloper: z7.boolean(),
-  developerPublicKey: z7.string().nullable().optional()
-});
-
-// src/api/schemas/activity.ts
-var actionNameSchema = z8.enum([
-  "refuel",
-  "transfer",
-  "refuelERC20",
-  "transferERC20",
-  "uniswapV3ExactInput",
-  "deactivateInstruction",
-  "sweepCCTP",
-  "transferCCTP",
-  "sweep",
-  "sweepERC20",
-  "sweepUniswapV3",
-  "depositERC4626",
-  "sweepDepositERC4626",
-  "withdrawERC4626",
-  "sweepWithdrawERC4626",
-  "callOnce"
-]);
-var transferFieldsSchema = z8.object({
-  token: hexStringSchema,
-  from: hexStringSchema,
-  to: hexStringSchema,
-  value: hexStringSchema
-});
-var swapFieldsSchema = z8.object({
-  poolAddress: hexStringSchema,
-  fromToken: hexStringSchema,
-  toToken: hexStringSchema,
-  from: hexStringSchema,
-  to: hexStringSchema,
-  fromAmount: hexStringSchema,
-  toAmount: hexStringSchema
-});
-var cctpBurnFieldsSchema = z8.object({
-  token: hexStringSchema,
-  from: hexStringSchema,
-  mintRecipient: hexStringSchema,
-  destinationDomain: hexStringSchema,
-  value: hexStringSchema
-});
-var erc4626DepositFieldsSchema = z8.object({
-  vault: hexStringSchema,
-  token: hexStringSchema,
-  from: hexStringSchema,
-  owner: hexStringSchema,
-  value: hexStringSchema,
-  shares: hexStringSchema
-});
-var erc4626WithdrawFieldsSchema = z8.object({
-  vault: hexStringSchema,
-  token: hexStringSchema,
-  from: hexStringSchema,
-  to: hexStringSchema,
-  value: hexStringSchema,
-  shares: hexStringSchema
-});
-var activityDataSchema = z8.union([
-  z8.object({ transfer: transferFieldsSchema }),
-  z8.object({ swap: swapFieldsSchema }),
-  z8.object({ cctpBurn: cctpBurnFieldsSchema }),
-  z8.object({ erc4626Deposit: erc4626DepositFieldsSchema }),
-  z8.object({ erc4626Withdraw: erc4626WithdrawFieldsSchema })
+/**
+* Formats a payment rail value to a human-readable label.
+*/
+function formatPaymentRail(paymentRail) {
+	if (!paymentRail) return DEFAULT_ACTION_LABEL;
+	const label = PAYMENT_RAIL_LABELS[paymentRail.toLowerCase()];
+	if (label) return label;
+	return paymentRail.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+/**
+* Formats an action name to a human-readable label.
+*/
+function formatActionName(actionName, source) {
+	if (!actionName) return DEFAULT_ACTION_LABEL;
+	if (actionName.startsWith("virtual_account_")) {
+		if (source?.payment_rail) return formatPaymentRail(source.payment_rail);
+		const eventType = actionName.replace("virtual_account_", "");
+		const label = VIRTUAL_ACCOUNT_EVENT_LABELS[eventType];
+		if (label) return label;
+		return eventType.split("_").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+	}
+	return ACTION_NAME_LABELS[actionName] ?? DEFAULT_ACTION_LABEL;
+}
+const transferFieldsSchema = z$1.object({
+	token: hexStringSchema,
+	from: hexStringSchema,
+	to: hexStringSchema,
+	value: hexStringSchema
+});
+const swapFieldsSchema = z$1.object({
+	poolAddress: hexStringSchema,
+	fromToken: hexStringSchema,
+	toToken: hexStringSchema,
+	from: hexStringSchema,
+	to: hexStringSchema,
+	fromAmount: hexStringSchema,
+	toAmount: hexStringSchema
+});
+const cctpBurnFieldsSchema = z$1.object({
+	token: hexStringSchema,
+	from: hexStringSchema,
+	mintRecipient: hexStringSchema,
+	destinationDomain: hexStringSchema,
+	value: hexStringSchema
+});
+const erc4626DepositFieldsSchema = z$1.object({
+	vault: hexStringSchema,
+	token: hexStringSchema,
+	from: hexStringSchema,
+	owner: hexStringSchema,
+	value: hexStringSchema,
+	shares: hexStringSchema
+});
+const erc4626WithdrawFieldsSchema = z$1.object({
+	vault: hexStringSchema,
+	token: hexStringSchema,
+	from: hexStringSchema,
+	to: hexStringSchema,
+	value: hexStringSchema,
+	shares: hexStringSchema
+});
+const activityDataSchema = z$1.union([
+	z$1.object({ transfer: transferFieldsSchema }),
+	z$1.object({ swap: swapFieldsSchema }),
+	z$1.object({ cctpBurn: cctpBurnFieldsSchema }),
+	z$1.object({ erc4626Deposit: erc4626DepositFieldsSchema }),
+	z$1.object({ erc4626Withdraw: erc4626WithdrawFieldsSchema })
 ]);
-var activityRecordSchema = z8.object({
-  actionName: actionNameSchema,
-  blockTimestamp: numberSchema,
-  transactionHash: hexStringSchema,
-  activity: activityDataSchema,
-  instructionId: hexStringSchema.nullable(),
-  executionCount: z8.number().nullable()
-});
-var getInstructionActivityRequestSchema = z8.object({
-  chainId: z8.number(),
-  actionNames: z8.array(actionNameSchema),
-  page: numberSchema.optional(),
-  perPage: numberSchema.optional()
-});
-var getInstructionActivityResponseSchema = z8.array(activityRecordSchema);
+const activityRecordSchema = z$1.object({
+	actionName: actionNameSchema,
+	blockTimestamp: numberSchema,
+	transactionHash: hexStringSchema,
+	activity: activityDataSchema,
+	instructionId: hexStringSchema.nullable(),
+	executionCount: z$1.number().nullable()
+});
+const getInstructionActivityRequestSchema = z$1.object({
+	chainId: z$1.number(),
+	actionNames: z$1.array(actionNameSchema),
+	page: numberSchema.optional(),
+	perPage: numberSchema.optional()
+});
+const getInstructionActivityResponseSchema = z$1.array(activityRecordSchema);
 
-// src/api/schemas/auth.ts
-import { z as z9 } from "zod";
-var authLoginRequestSchema = z9.object({
-  siwe: z9.string(),
-  signature: vrsSchema
-});
-var authLoginResponseSchema = z9.object({
-  authorization: z9.string(),
-  user: userSchema
-});
-var turnkeyVerificationRequestSchema = z9.object({
-  email: z9.string().email()
-});
-var turnkeyVerificationResponseSchema = z9.object({
-  isLogin: z9.boolean()
-});
-var attestationSchema = z9.object({
-  credentialId: z9.string(),
-  clientDataJson: z9.string(),
-  attestationObject: z9.string(),
-  transports: z9.array(z9.string()).optional()
-});
-var turnkeyLoginRequestSchema = z9.object({
-  email: z9.email(),
-  verificationCode: z9.coerce.number().int().min(1e5).max(999999),
-  passkeyChallenge: z9.string().optional(),
-  attestation: attestationSchema.optional()
-});
-var turnkeyLoginResponseSchema = z9.object({
-  email: z9.string(),
-  subOrgId: z9.string(),
-  walletAddress: z9.string(),
-  isLogin: z9.boolean().optional()
-});
-var meResponseSchema = userSchema;
-var sessionTokenRequestSchema = z9.object({
-  sessionToken: z9.string()
-});
-var sessionTokenResponseSchema = z9.object({
-  success: z9.boolean()
-});
-var sessionVerifyResponseSchema = z9.object({
-  authenticated: z9.boolean(),
-  hasSessionToken: z9.boolean()
-});
-var whitelistCheckRequestSchema = z9.object({
-  email: z9.string().email()
-});
-var whitelistCheckResponseSchema = z9.object({
-  isAllowed: z9.boolean(),
-  message: z9.string().optional()
-});
-var addressWhitelistCheckRequestSchema = z9.object({
-  address: z9.string()
-});
-var addressWhitelistCheckResponseSchema = z9.object({
-  isAllowed: z9.boolean(),
-  message: z9.string().optional()
-});
-var getCurrentUserResponseSchema = z9.object({
-  data: userSchema
+//#endregion
+//#region src/api/schemas/auth.ts
+const authLoginRequestSchema = z$1.object({
+	siwe: z$1.string(),
+	signature: vrsSchema
+});
+const authLoginResponseSchema = z$1.object({
+	authorization: z$1.string(),
+	user: userSchema
+});
+const turnkeyVerificationRequestSchema = z$1.object({ email: z$1.string().email() });
+const turnkeyVerificationResponseSchema = z$1.object({
+	isLogin: z$1.boolean(),
+	codeAlreadyExists: z$1.boolean().optional()
+});
+const attestationSchema = z$1.object({
+	credentialId: z$1.string(),
+	clientDataJson: z$1.string(),
+	attestationObject: z$1.string(),
+	transports: z$1.array(z$1.string()).optional()
+});
+const turnkeyLoginRequestSchema = z$1.object({
+	email: z$1.email(),
+	verificationCode: z$1.coerce.number().int().min(1e5).max(999999),
+	passkeyChallenge: z$1.string().optional(),
+	attestation: attestationSchema.optional()
+});
+const turnkeyLoginResponseSchema = z$1.object({
+	email: z$1.string(),
+	subOrgId: z$1.string(),
+	walletAddress: z$1.string(),
+	isLogin: z$1.boolean().optional()
+});
+const meResponseSchema = userSchema;
+const sessionTokenRequestSchema = z$1.object({
+	sessionToken: z$1.string(),
+	userId: z$1.string()
+});
+const sessionTokenResponseSchema = z$1.object({ success: z$1.boolean() });
+const sessionVerifyResponseSchema = z$1.object({
+	authenticated: z$1.boolean(),
+	hasSessionToken: z$1.boolean()
+});
+/**
+* @todo
+* - Remove later, this is a temporary schema for the whitelist check
+*/
+const whitelistCheckRequestSchema = z$1.object({ email: z$1.string().email() });
+const whitelistCheckResponseSchema = z$1.object({
+	isAllowed: z$1.boolean(),
+	message: z$1.string().optional()
+});
+const addressWhitelistCheckRequestSchema = z$1.object({ address: z$1.string() });
+const addressWhitelistCheckResponseSchema = z$1.object({
+	isAllowed: z$1.boolean(),
+	message: z$1.string().optional()
 });
 
-// src/api/schemas/chain.ts
-import { z as z10 } from "zod";
-var chainIdSchema = z10.object({
-  chainId: z10.number().nullable()
-});
-var setChainIdSchema = z10.object({
-  chainId: z10.number().positive()
-});
-var chainSuccessResponseSchema = z10.object({
-  success: z10.boolean(),
-  chainId: z10.number().optional()
+//#endregion
+//#region src/api/schemas/chain.ts
+const chainIdSchema = z$1.object({ chainId: z$1.number().nullable() });
+const setChainIdSchema = z$1.object({ chainId: z$1.number().positive() });
+const chainSuccessResponseSchema = z$1.object({
+	success: z$1.boolean(),
+	chainId: z$1.number().optional()
 });
 
-// src/api/schemas/config.ts
-import { z as z11 } from "zod";
-var getDelegateAddressSchema = z11.object({
-  chainId: z11.number()
-});
-var getDelegateAddressResponseSchema = z11.object({
-  otimDelegateAddress: z11.string()
-});
-var getConfigTokensRequestParametersSchema = z11.object({
-  chainId: z11.number()
-});
-var getConfigTokensResponseSchema = z11.object({
-  tokens: z11.array(
-    z11.object({
-      symbol: z11.any(),
-      address: hexStringSchema
-    })
-  )
-});
-var getConfigChainsResponseSchema = z11.unknown();
-var getMaxPriorityFeePerGasEstimateSchema = z11.object({
-  chainId: z11.number()
-});
-var getMaxPriorityFeePerGasEstimateResponseSchema = z11.object({
-  slowMaxPriorityFeeEstimate: z11.number(),
-  normalMaxPriorityFeeEstimate: z11.number(),
-  fastMaxPriorityFeeEstimate: z11.number()
+//#endregion
+//#region src/api/schemas/config.ts
+const getDelegateAddressSchema = z$1.object({ chainId: z$1.number() });
+const getDelegateAddressResponseSchema = z$1.object({ otimDelegateAddress: z$1.string() });
+const getConfigTokensRequestParametersSchema = z$1.object({ chainId: z$1.number() });
+const getConfigTokensResponseSchema = z$1.object({ tokens: z$1.array(z$1.object({
+	symbol: z$1.any(),
+	address: hexStringSchema
+})) });
+const getConfigChainsResponseSchema = z$1.unknown();
+const getMaxPriorityFeePerGasEstimateSchema = z$1.object({ chainId: z$1.number() });
+const getMaxPriorityFeePerGasEstimateResponseSchema = z$1.object({
+	slowMaxPriorityFeeEstimate: z$1.number(),
+	normalMaxPriorityFeeEstimate: z$1.number(),
+	fastMaxPriorityFeeEstimate: z$1.number()
 });
 
-// src/api/schemas/contacts.ts
-import { z as z12 } from "zod";
-var newContactRequestSchema = z12.object({
-  address: hexStringSchema,
-  name: z12.string()
-});
-var getContactsRequestSchema = z12.object({
-  perPage: numberSchema.optional(),
-  page: numberSchema.optional()
-});
-var contactSchema = z12.object({
-  userId: z12.string(),
-  address: hexStringSchema,
-  name: z12.string(),
-  createdAt: z12.string(),
-  updatedAt: z12.string()
-});
-var getContactsResponseSchema = z12.array(contactSchema);
+//#endregion
+//#region src/api/schemas/contacts.ts
+const newContactRequestSchema = z$1.object({
+	address: hexStringSchema,
+	name: z$1.string()
+});
+const getContactsRequestSchema = z$1.object({
+	perPage: numberSchema.optional(),
+	page: numberSchema.optional()
+});
+const contactSchema = z$1.object({
+	userId: z$1.string(),
+	address: hexStringSchema,
+	name: z$1.string(),
+	createdAt: z$1.string(),
+	updatedAt: z$1.string()
+});
+const getContactsResponseSchema = z$1.array(contactSchema);
 
-// src/api/schemas/instruction.ts
-import { z as z13 } from "zod";
-var feeSchema = z13.object({
-  executionFee: hexStringSchema,
-  maxBaseFeePerGas: hexStringSchema,
-  maxPriorityFeePerGas: hexStringSchema,
-  token: hexStringSchema
-});
-var scheduleSchema = z13.object({
-  startAt: numberSchema,
-  startBy: numberSchema,
-  interval: numberSchema,
-  timeout: numberSchema
-});
-var baseActionArgumentsSchema = z13.object({
-  target: hexStringSchema,
-  fee: feeSchema,
-  token: hexStringSchema
-});
-var refuelActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  threshold: numberSchema,
-  endBalance: numberSchema,
-  gasLimit: numberSchema
-});
-var refuelERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  threshold: numberSchema,
-  endBalance: numberSchema,
-  gasLimit: numberSchema
-});
-var transferActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  value: numberSchema,
-  gasLimit: numberSchema,
-  schedule: scheduleSchema
-});
-var transferERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  value: numberSchema,
-  gasLimit: numberSchema,
-  schedule: scheduleSchema
-});
-var sweepDepositAccountActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  threshold: numberSchema,
-  recipient: hexStringSchema,
-  depositorAddress: hexStringSchema
-});
-var sweepDepositAccountERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
-  threshold: numberSchema,
-  recipient: hexStringSchema,
-  depositorAddress: hexStringSchema
-});
-var uniswapV3ExactInputActionArgumentsSchema = z13.object({
-  tokenIn: hexStringSchema,
-  tokenOut: hexStringSchema,
-  amountIn: numberSchema,
-  floorAmountOut: numberSchema,
-  feeTier: z13.string(),
-  recipient: hexStringSchema,
-  meanPriceLookBack: numberSchema,
-  maxPriceDeviationBps: numberSchema,
-  fee: feeSchema,
-  schedule: scheduleSchema
-});
-var deactivateInstructionActionArgumentsSchema = z13.object({
-  instructionId: hexStringSchema,
-  fee: feeSchema
-});
-var actionArgumentsSchema = z13.union([
-  refuelActionArgumentsSchema,
-  refuelERC20ActionArgumentsSchema,
-  transferActionArgumentsSchema,
-  transferERC20ActionArgumentsSchema,
-  sweepDepositAccountActionArgumentsSchema,
-  sweepDepositAccountERC20ActionArgumentsSchema,
-  uniswapV3ExactInputActionArgumentsSchema,
-  deactivateInstructionActionArgumentsSchema
+//#endregion
+//#region src/api/schemas/instruction.ts
+const feeSchema = z$1.object({
+	executionFee: hexStringSchema,
+	maxBaseFeePerGas: hexStringSchema,
+	maxPriorityFeePerGas: hexStringSchema,
+	token: hexStringSchema
+});
+const scheduleSchema = z$1.object({
+	startAt: numberSchema,
+	startBy: numberSchema,
+	interval: numberSchema,
+	timeout: numberSchema
+});
+const baseActionArgumentsSchema = z$1.object({
+	target: hexStringSchema,
+	fee: feeSchema,
+	token: hexStringSchema
+});
+const refuelActionArgumentsSchema = baseActionArgumentsSchema.extend({
+	threshold: numberSchema,
+	endBalance: numberSchema,
+	gasLimit: numberSchema
+});
+const refuelERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
+	threshold: numberSchema,
+	endBalance: numberSchema,
+	gasLimit: numberSchema
+});
+const transferActionArgumentsSchema = baseActionArgumentsSchema.extend({
+	value: numberSchema,
+	gasLimit: numberSchema,
+	schedule: scheduleSchema
+});
+const transferERC20ActionArgumentsSchema = baseActionArgumentsSchema.extend({
+	value: numberSchema,
+	gasLimit: numberSchema,
+	schedule: scheduleSchema
+});
+const uniswapV3ExactInputActionArgumentsSchema = z$1.object({
+	tokenIn: hexStringSchema,
+	tokenOut: hexStringSchema,
+	amountIn: numberSchema,
+	floorAmountOut: numberSchema,
+	feeTier: z$1.string(),
+	recipient: hexStringSchema,
+	meanPriceLookBack: numberSchema,
+	maxPriceDeviationBps: numberSchema,
+	fee: feeSchema,
+	schedule: scheduleSchema
+});
+const deactivateInstructionActionArgumentsSchema = z$1.object({
+	instructionId: hexStringSchema,
+	fee: feeSchema
+});
+const depositERC4626ActionArgumentsSchema = z$1.object({
+	vault: hexStringSchema,
+	recipient: hexStringSchema,
+	value: numberSchema,
+	minDeposit: numberSchema,
+	minTotalShares: numberSchema,
+	schedule: scheduleSchema,
+	fee: feeSchema
+});
+const sweepDepositERC4626ActionArgumentsSchema = z$1.object({
+	vault: hexStringSchema,
+	recipient: hexStringSchema,
+	threshold: numberSchema,
+	endBalance: numberSchema,
+	minDeposit: numberSchema,
+	minTotalShares: numberSchema,
+	fee: feeSchema
+});
+const withdrawERC4626ActionArgumentsSchema = z$1.object({
+	vault: hexStringSchema,
+	recipient: hexStringSchema,
+	value: numberSchema,
+	minWithdraw: numberSchema,
+	schedule: scheduleSchema,
+	fee: feeSchema
+});
+const sweepWithdrawERC4626ActionArgumentsSchema = z$1.object({
+	vault: hexStringSchema,
+	recipient: hexStringSchema,
+	threshold: numberSchema,
+	endBalance: numberSchema,
+	minWithdraw: numberSchema,
+	fee: feeSchema
+});
+const actionArgumentsSchema = z$1.union([
+	refuelActionArgumentsSchema,
+	refuelERC20ActionArgumentsSchema,
+	transferActionArgumentsSchema,
+	transferERC20ActionArgumentsSchema,
+	uniswapV3ExactInputActionArgumentsSchema,
+	deactivateInstructionActionArgumentsSchema,
+	depositERC4626ActionArgumentsSchema,
+	sweepDepositERC4626ActionArgumentsSchema,
+	withdrawERC4626ActionArgumentsSchema,
+	sweepWithdrawERC4626ActionArgumentsSchema
 ]);
-var feeResponseSchema = z13.object({
-  token: hexStringSchema,
-  executionFee: hexStringSchema,
-  maxBaseFeePerGas: hexStringSchema,
-  maxPriorityFeePerGas: hexStringSchema
-});
-var scheduleResponseSchema = z13.object({
-  startAt: hexStringSchema,
-  startBy: hexStringSchema,
-  interval: hexStringSchema,
-  timeout: hexStringSchema
-});
-var refuelActionResponseSchema = z13.object({
-  target: hexStringSchema,
-  threshold: hexStringSchema,
-  endBalance: hexStringSchema,
-  gasLimit: hexStringSchema,
-  fee: feeResponseSchema
-});
-var transferActionResponseSchema = z13.object({
-  target: hexStringSchema,
-  value: hexStringSchema,
-  gasLimit: hexStringSchema,
-  schedule: scheduleResponseSchema,
-  fee: feeResponseSchema
-});
-var refuelERC20ActionResponseSchema = z13.object({
-  token: hexStringSchema,
-  target: hexStringSchema,
-  threshold: hexStringSchema,
-  endBalance: hexStringSchema,
-  fee: feeResponseSchema
-});
-var transferERC20ActionResponseSchema = z13.object({
-  token: hexStringSchema,
-  target: hexStringSchema,
-  value: hexStringSchema,
-  schedule: scheduleResponseSchema,
-  fee: feeResponseSchema
-});
-var actionArgumentsResponseSchema = z13.union([
-  refuelActionResponseSchema,
-  transferActionResponseSchema,
-  refuelERC20ActionResponseSchema,
-  transferERC20ActionResponseSchema
+const feeResponseSchema$1 = z$1.object({
+	token: hexStringSchema,
+	executionFee: hexStringSchema,
+	maxBaseFeePerGas: hexStringSchema,
+	maxPriorityFeePerGas: hexStringSchema
+});
+const scheduleResponseSchema = z$1.object({
+	startAt: hexStringSchema,
+	startBy: hexStringSchema,
+	interval: hexStringSchema,
+	timeout: hexStringSchema
+});
+const refuelActionResponseSchema = z$1.object({
+	target: hexStringSchema,
+	threshold: hexStringSchema,
+	endBalance: hexStringSchema,
+	gasLimit: hexStringSchema,
+	fee: feeResponseSchema$1
+});
+const transferActionResponseSchema = z$1.object({
+	target: hexStringSchema,
+	value: hexStringSchema,
+	gasLimit: hexStringSchema,
+	schedule: scheduleResponseSchema,
+	fee: feeResponseSchema$1
+});
+const refuelERC20ActionResponseSchema = z$1.object({
+	token: hexStringSchema,
+	target: hexStringSchema,
+	threshold: hexStringSchema,
+	endBalance: hexStringSchema,
+	fee: feeResponseSchema$1
+});
+const transferERC20ActionResponseSchema = z$1.object({
+	token: hexStringSchema,
+	target: hexStringSchema,
+	value: hexStringSchema,
+	schedule: scheduleResponseSchema,
+	fee: feeResponseSchema$1
+});
+const actionArgumentsResponseSchema = z$1.union([
+	refuelActionResponseSchema,
+	transferActionResponseSchema,
+	refuelERC20ActionResponseSchema,
+	transferERC20ActionResponseSchema
 ]);
-var instructionBuildSchema = z13.object({
-  action: hexStringSchema,
-  arguments: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  salt: hexStringSchema,
-  nickname: z13.string().nullish()
-});
-var instructionGetAllRequestSchema = z13.object({
-  address: hexStringSchema,
-  chainId: z13.number(),
-  page: z13.number().optional(),
-  perPage: z13.number().optional()
-});
-var instructionGetAllResponseSchema = z13.array(instructionSchema);
-var instructionBuildRequestSchema = z13.object({
-  address: hexStringSchema,
-  chainId: z13.number(),
-  salt: z13.number(),
-  maxExecutions: z13.number(),
-  actionArguments: z13.record(z13.string(), actionArgumentsSchema).refine(
-    (args) => {
-      const keys = Object.keys(args);
-      return keys.length === 1 && instructionActionValues.includes(
-        keys[0]
-      );
-    },
-    {
-      message: "actionArguments must contain exactly one valid instruction action"
-    }
-  )
-});
-var instructionActivateRequestSchema = z13.object({
-  nickname: z13.string().optional(),
-  address: hexStringSchema,
-  chainId: z13.number(),
-  salt: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  action: hexStringSchema,
-  arguments: hexStringSchema,
-  activationSignature: eip2098SignatureSchema
-});
-var instructionActivateResponseSchema = z13.object({
-  instructionId: hexStringSchema
-});
-var instructionDeactivateRequestSchema = z13.object({
-  address: hexStringSchema,
-  chainId: z13.number(),
-  deactivation: z13.object({
-    instructionId: hexStringSchema
-  }),
-  deactivationSignature: eip2098SignatureSchema
-});
-var instructionDeactivateResponseSchema = z13.unknown();
-var instructionDetailsRequestSchema = z13.object({
-  address: hexStringSchema,
-  instructionId: hexStringSchema,
-  chainId: z13.number()
-});
-var instructionDetailsResponseSchema = z13.object({
-  action: hexStringSchema,
-  actionArguments: z13.any(),
-  actionName: z13.string().nullish(),
-  salt: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  nickname: z13.string().nullish(),
-  lastErrorCode: z13.number().int(),
-  lastErrorMessage: z13.string().nullish()
-});
-var instructionGetRulesRequestSchema = z13.object({
-  chainId: z13.number(),
-  page: z13.number().optional(),
-  perPage: z13.number().optional()
-});
-var instructionGetRulesResponseSchema = z13.array(
-  instructionSchema
-);
+const instructionBuildSchema = z$1.object({
+	action: hexStringSchema,
+	arguments: hexStringSchema,
+	maxExecutions: hexStringSchema,
+	salt: hexStringSchema,
+	nickname: z$1.string().nullish()
+});
+const instructionGetAllRequestSchema = z$1.object({
+	address: hexStringSchema,
+	chainId: z$1.number(),
+	actionName: z$1.string().optional(),
+	page: z$1.number().optional(),
+	perPage: z$1.number().optional()
+});
+const instructionGetAllResponseSchema = z$1.array(instructionSchema);
+const instructionBuildRequestSchema = z$1.object({
+	address: hexStringSchema,
+	chainId: z$1.number(),
+	salt: z$1.number(),
+	maxExecutions: z$1.number(),
+	actionArguments: z$1.record(z$1.string(), actionArgumentsSchema).refine((args) => {
+		const keys = Object.keys(args);
+		return keys.length === 1 && instructionActionValues.includes(keys[0]);
+	}, { message: "actionArguments must contain exactly one valid instruction action" })
+});
+const instructionActivateRequestSchema = z$1.object({
+	nickname: z$1.string().optional(),
+	address: hexStringSchema,
+	chainId: z$1.number(),
+	salt: hexStringSchema,
+	maxExecutions: hexStringSchema,
+	action: hexStringSchema,
+	arguments: hexStringSchema,
+	activationSignature: eip2098SignatureSchema
+});
+const instructionActivateResponseSchema = z$1.object({ instructionId: hexStringSchema });
+const instructionDeactivateRequestSchema = z$1.object({
+	address: hexStringSchema,
+	chainId: z$1.number(),
+	deactivation: z$1.object({ instructionId: hexStringSchema }),
+	deactivationSignature: eip2098SignatureSchema
+});
+const instructionDeactivateResponseSchema = z$1.unknown();
+const instructionDetailsRequestSchema = z$1.object({
+	address: hexStringSchema,
+	instructionId: hexStringSchema,
+	chainId: z$1.number()
+});
+const instructionDetailsResponseSchema = z$1.object({
+	action: hexStringSchema,
+	actionArguments: z$1.any(),
+	actionName: z$1.string().nullish(),
+	salt: hexStringSchema,
+	maxExecutions: hexStringSchema,
+	nickname: z$1.string().nullish(),
+	lastErrorCode: z$1.number().int(),
+	lastErrorMessage: z$1.string().nullish()
+});
+const instructionGetRulesRequestSchema = z$1.object({
+	chainId: z$1.number(),
+	page: z$1.number().optional(),
+	perPage: z$1.number().optional()
+});
+const instructionGetRulesResponseSchema = z$1.array(instructionSchema);
 
-// src/api/schemas/integration.ts
-import { z as z14 } from "zod";
-var IntegrationType = {
-  Bank: "Bank",
-  Clio: "Clio",
-  Stripe: "Stripe",
-  QuickBooks: "QuickBooks",
-  Bill: "Bill",
-  Zoho: "Zoho"
+//#endregion
+//#region src/api/schemas/integration.ts
+const IntegrationType = {
+	Bank: "Bank",
+	Clio: "Clio",
+	Stripe: "Stripe",
+	QuickBooks: "QuickBooks",
+	Bill: "Bill",
+	Zoho: "Zoho"
 };
-var integrationTypeValues = [
-  IntegrationType.Bank,
-  IntegrationType.Clio,
-  IntegrationType.Stripe,
-  IntegrationType.QuickBooks,
-  IntegrationType.Bill,
-  IntegrationType.Zoho
+const integrationTypeValues = [
+	IntegrationType.Bank,
+	IntegrationType.Clio,
+	IntegrationType.Stripe,
+	IntegrationType.QuickBooks,
+	IntegrationType.Bill,
+	IntegrationType.Zoho
 ];
-var quickBooksDetailsSchema = z14.object({
-  accessToken: z14.string().optional(),
-  refreshToken: z14.string().optional(),
-  realmId: z14.string().optional(),
-  tokenType: z14.string().optional(),
-  expiresIn: z14.number().optional(),
-  xRefreshTokenExpiresIn: z14.number().optional()
-});
-var stripeTokensSchema = z14.object({
-  accessToken: z14.string(),
-  refreshToken: z14.string().optional()
-});
-var stripeDetailsSchema = z14.object({
-  clientId: z14.string().optional(),
-  clientSecret: z14.string().optional(),
-  tokens: stripeTokensSchema.optional()
-});
-var billcomDetailsSchema = z14.object({
-  devKey: z14.string().optional(),
-  sessionId: z14.string().optional(),
-  orgId: z14.string().optional(),
-  rememberMeId: z14.string().optional()
-});
-var liquidationAddressSchema = z14.object({
-  liquidationAddressId: z14.string(),
-  address: z14.string(),
-  chain: z14.string(),
-  currency: z14.string(),
-  blockchainMemo: z14.string().optional()
-});
-var plaidAccountSchema = z14.object({
-  accountId: z14.string(),
-  name: z14.string().optional(),
-  mask: z14.string().optional(),
-  subtype: z14.string().optional(),
-  externalAccountId: z14.string().optional(),
-  liquidationAddress: liquidationAddressSchema.optional()
-});
-var plaidConnectionSchema = z14.object({
-  accessToken: z14.string(),
-  itemId: z14.string(),
-  institutionId: z14.string().optional(),
-  institutionName: z14.string().optional(),
-  accounts: z14.array(plaidAccountSchema)
-});
-var bridgeConnectionSchema = z14.object({
-  customerId: z14.string(),
-  kycLinkId: z14.string().optional(),
-  kycLink: z14.string().optional(),
-  tosLink: z14.string().optional(),
-  completedSteps: z14.array(z14.string()).optional()
-});
-var bankDetailsSchema = z14.object({
-  plaid: z14.array(plaidConnectionSchema).optional(),
-  bridge: z14.array(bridgeConnectionSchema).optional()
-});
-var integrationTypeSchema = z14.enum(integrationTypeValues);
-var updateIntegrationRequestSchema = z14.discriminatedUnion(
-  "integrationType",
-  [
-    z14.object({
-      integrationType: z14.literal(IntegrationType.QuickBooks),
-      details: quickBooksDetailsSchema
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Bank),
-      details: bankDetailsSchema
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Clio),
-      details: z14.unknown()
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Stripe),
-      details: stripeDetailsSchema
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Bill),
-      details: billcomDetailsSchema
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Zoho),
-      details: z14.unknown()
-    })
-  ]
-);
-var getIntegrationRequestSchema = z14.object({
-  integrationType: integrationTypeSchema
-});
-var integrationResponseSchema = z14.discriminatedUnion(
-  "integrationType",
-  [
-    z14.object({
-      integrationType: z14.literal(IntegrationType.QuickBooks),
-      details: quickBooksDetailsSchema
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Bank),
-      details: bankDetailsSchema
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Clio),
-      details: z14.unknown()
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Stripe),
-      details: stripeDetailsSchema
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Bill),
-      details: billcomDetailsSchema
-    }),
-    z14.object({
-      integrationType: z14.literal(IntegrationType.Zoho),
-      details: z14.unknown()
-    })
-  ]
-);
+const quickBooksDetailsSchema = z$1.object({
+	accessToken: z$1.string().optional(),
+	refreshToken: z$1.string().optional(),
+	realmId: z$1.string().optional(),
+	tokenType: z$1.string().optional(),
+	expiresIn: z$1.number().optional(),
+	xRefreshTokenExpiresIn: z$1.number().optional()
+});
+const stripeTokensSchema = z$1.object({
+	accessToken: z$1.string(),
+	refreshToken: z$1.string().optional()
+});
+const stripeDetailsSchema = z$1.object({
+	clientId: z$1.string().optional(),
+	clientSecret: z$1.string().optional(),
+	tokens: stripeTokensSchema.optional()
+});
+const billcomDetailsSchema = z$1.object({
+	devKey: z$1.string().optional(),
+	sessionId: z$1.string().optional(),
+	orgId: z$1.string().optional(),
+	rememberMeId: z$1.string().optional()
+});
+const liquidationAddressSchema = z$1.object({
+	liquidationAddressId: z$1.string(),
+	address: z$1.string(),
+	chain: z$1.string(),
+	currency: z$1.string(),
+	blockchainMemo: z$1.string().optional()
+});
+const plaidAccountSchema = z$1.object({
+	accountId: z$1.string(),
+	name: z$1.string().optional(),
+	mask: z$1.string().optional(),
+	subtype: z$1.string().optional(),
+	externalAccountId: z$1.string().optional(),
+	liquidationAddress: liquidationAddressSchema.optional()
+});
+const plaidConnectionSchema = z$1.object({
+	accessToken: z$1.string(),
+	itemId: z$1.string(),
+	institutionId: z$1.string().optional(),
+	institutionName: z$1.string().optional(),
+	accounts: z$1.array(plaidAccountSchema)
+});
+const bridgeConnectionSchema = z$1.object({
+	customerId: z$1.string(),
+	kycLinkId: z$1.string().optional(),
+	kycLink: z$1.string().optional(),
+	tosLink: z$1.string().optional(),
+	completedSteps: z$1.array(z$1.string()).optional()
+});
+const bankDetailsSchema = z$1.object({
+	plaid: z$1.array(plaidConnectionSchema).optional(),
+	bridge: z$1.array(bridgeConnectionSchema).optional()
+});
+const integrationTypeSchema = z$1.enum(integrationTypeValues);
+const updateIntegrationRequestSchema = z$1.discriminatedUnion("integrationType", [
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.QuickBooks),
+		details: quickBooksDetailsSchema
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Bank),
+		details: bankDetailsSchema
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Clio),
+		details: z$1.unknown()
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Stripe),
+		details: stripeDetailsSchema
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Bill),
+		details: billcomDetailsSchema
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Zoho),
+		details: z$1.unknown()
+	})
+]);
+const getIntegrationRequestSchema = z$1.object({ integrationType: integrationTypeSchema });
+const integrationResponseSchema = z$1.discriminatedUnion("integrationType", [
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.QuickBooks),
+		details: quickBooksDetailsSchema
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Bank),
+		details: bankDetailsSchema
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Clio),
+		details: z$1.unknown()
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Stripe),
+		details: stripeDetailsSchema
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Bill),
+		details: billcomDetailsSchema
+	}),
+	z$1.object({
+		integrationType: z$1.literal(IntegrationType.Zoho),
+		details: z$1.unknown()
+	})
+]);
 
-// src/api/schemas/operating-account.ts
-import { z as z15 } from "zod";
-var newOperatingAccountSubOrgResponseSchema = z15.object({
-  subOrganizationId: z15.string(),
-  endUserId: z15.string()
-});
-var getOperatingAccountSubOrgResponseSchema = z15.object({
-  subOrganizationId: z15.string()
+//#endregion
+//#region src/api/schemas/operating-account.ts
+const newOperatingAccountSubOrgResponseSchema = z$1.object({
+	subOrganizationId: z$1.string(),
+	endUserId: z$1.string()
 });
+const getOperatingAccountSubOrgResponseSchema = z$1.object({ subOrganizationId: z$1.string() });
 
-// src/api/schemas/payments.ts
-import { z as z16 } from "zod";
-var paymentRequestsDirectionSchema = z16.enum(["from", "to"]);
-var getPaymentRequestsRequestSchema = z16.object({
-  direction: paymentRequestsDirectionSchema,
-  statuses: z16.array(z16.enum(["pending", "inProgress", "paid", "cancelled", "draft"])).optional(),
-  perPage: numberSchema.optional(),
-  page: numberSchema.optional()
-});
-var paymentRequestStatusSchema = z16.enum([
-  "pending",
-  "inProgress",
-  "paid",
-  "cancelled",
-  "draft"
+//#endregion
+//#region src/api/schemas/payments.ts
+const paymentRequestsDirectionSchema = z$1.enum(["from", "to"]);
+const orchestrationTypeSchema = z$1.enum(["AutoEarn", "PaymentRequest"]);
+const getPaymentRequestsRequestSchema = z$1.object({
+	direction: paymentRequestsDirectionSchema,
+	statuses: z$1.array(z$1.enum([
+		"pending",
+		"inProgress",
+		"paid",
+		"cancelled",
+		"draft"
+	])).optional(),
+	perPage: numberSchema.optional(),
+	page: numberSchema.optional(),
+	orchestrationType: orchestrationTypeSchema.optional()
+});
+const paymentRequestStatusSchema = z$1.enum([
+	"pending",
+	"inProgress",
+	"paid",
+	"cancelled",
+	"draft"
 ]);
-var paymentRequestSchema = z16.object({
-  id: z16.string(),
-  fromUserId: z16.string(),
-  toUserId: z16.string().nullable(),
-  payerAddress: hexStringSchema.nullable(),
-  ephemeralWalletAddress: hexStringSchema,
-  instructions: z16.object({
-    ids: z16.array(z16.string()),
-    completionIds: z16.array(z16.string())
-  }),
-  metadata: z16.record(z16.string(), z16.unknown()),
-  status: paymentRequestStatusSchema,
-  createdAt: z16.string(),
-  updatedAt: z16.string()
-});
-var getPaymentRequestsResponseSchema = z16.array(paymentRequestSchema);
-var buildEphemeralInstructionSchema = z16.object({
-  chainId: z16.number(),
-  salt: numberSchema,
-  maxExecutions: numberSchema,
-  actionArguments: z16.record(z16.string(), z16.unknown()),
-  setEphemeralTarget: z16.boolean().optional()
-});
-var paymentRequestBuildRequestSchema = z16.object({
-  payerAddress: hexStringSchema.nullish(),
-  completionInstructions: z16.array(buildEphemeralInstructionSchema),
-  instructions: z16.array(buildEphemeralInstructionSchema),
-  metadata: z16.record(z16.string(), z16.unknown()).optional().default({}),
-  maxRuns: z16.number().int().positive({ message: "maxRuns must be greater than 0" }).max(Number.MAX_SAFE_INTEGER, {
-    message: "maxRuns must be less than MAX_SAFE_INTEGER"
-  }).optional()
-});
-var feeResponseSchema2 = z16.object({
-  token: hexStringSchema,
-  executionFee: hexStringSchema,
-  maxBaseFeePerGas: hexStringSchema,
-  maxPriorityFeePerGas: hexStringSchema
-});
-var buildInstructionResponseSchema = z16.object({
-  address: hexStringSchema,
-  chainId: z16.number(),
-  salt: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  action: hexStringSchema,
-  actionName: z16.string().optional(),
-  arguments: hexStringSchema
-});
-var paymentRequestBuildResponseSchema = z16.object({
-  requestId: z16.string(),
-  subOrgId: z16.string(),
-  walletId: z16.string(),
-  ephemeralWalletAddress: hexStringSchema,
-  completionInstructions: z16.array(buildInstructionResponseSchema),
-  instructions: z16.array(buildInstructionResponseSchema)
-});
-var newInstructionRequestSchema = z16.object({
-  nickname: z16.string().optional(),
-  actionName: z16.string().optional(),
-  address: hexStringSchema,
-  chainId: z16.number(),
-  salt: hexStringSchema,
-  maxExecutions: hexStringSchema,
-  action: hexStringSchema,
-  arguments: hexStringSchema,
-  activationSignature: eip2098SignatureSchema
-});
-var paymentRequestNewRequestSchema = z16.object({
-  requestId: z16.string(),
-  signedAuthorization: z16.string(),
-  completionInstructions: z16.array(newInstructionRequestSchema),
-  instructions: z16.array(newInstructionRequestSchema)
-});
-var paymentRequestDetailsRequestSchema = z16.object({
-  requestId: z16.string()
-});
-var paymentRequestDetailsResponseSchema = z16.object({
-  requestId: z16.string(),
-  ephemeralWalletAddress: hexStringSchema,
-  ephemeralWalletId: z16.string().optional(),
-  status: z16.enum(["pending", "inProgress", "paid", "cancelled", "draft"]),
-  metadata: z16.record(z16.string(), z16.unknown()),
-  numRuns: z16.number(),
-  maxRuns: z16.number().optional()
-});
-var buildSettlementRequestSchema = z16.object({
-  acceptedTokens: z16.record(z16.string(), z16.array(hexStringSchema)),
-  settlementChain: z16.number(),
-  settlementToken: hexStringSchema,
-  settlementAmount: numberSchema,
-  recipientAddress: hexStringSchema,
-  metadata: z16.record(z16.string(), z16.unknown()),
-  payerAddress: hexStringSchema.nullish(),
-  dueDate: z16.string().datetime().nullish(),
-  maxRuns: z16.number().int().positive().nullish()
-});
-var buildSettlementResponseSchema = z16.object({
-  requestId: z16.string(),
-  subOrgId: z16.string(),
-  walletId: z16.string(),
-  ephemeralWalletAddress: hexStringSchema,
-  completionInstructions: z16.array(buildInstructionResponseSchema),
-  instructions: z16.array(buildInstructionResponseSchema)
+const paymentRequestSchema = z$1.object({
+	id: z$1.string(),
+	fromUserId: z$1.string(),
+	toUserId: z$1.string().nullable(),
+	payerAddress: hexStringSchema.nullable(),
+	ephemeralWalletAddress: hexStringSchema,
+	instructions: z$1.object({
+		ids: z$1.array(z$1.string()),
+		completionIds: z$1.array(z$1.string())
+	}),
+	metadata: z$1.record(z$1.string(), z$1.unknown()),
+	status: paymentRequestStatusSchema,
+	createdAt: z$1.string(),
+	updatedAt: z$1.string()
+});
+const getPaymentRequestsResponseSchema = z$1.array(paymentRequestSchema);
+const buildEphemeralInstructionSchema = z$1.object({
+	chainId: z$1.number(),
+	salt: numberSchema,
+	maxExecutions: numberSchema,
+	actionArguments: z$1.record(z$1.string(), z$1.unknown()),
+	setEphemeralTarget: z$1.boolean().optional()
+});
+const paymentRequestBuildRequestSchema = z$1.object({
+	payerAddress: hexStringSchema.nullish(),
+	completionInstructions: z$1.array(buildEphemeralInstructionSchema),
+	instructions: z$1.array(buildEphemeralInstructionSchema),
+	metadata: z$1.record(z$1.string(), z$1.unknown()).optional().default({}),
+	maxRuns: z$1.number().int().positive({ message: "maxRuns must be greater than 0" }).max(Number.MAX_SAFE_INTEGER, { message: "maxRuns must be less than MAX_SAFE_INTEGER" }).optional()
+});
+const feeResponseSchema = z$1.object({
+	token: hexStringSchema,
+	executionFee: hexStringSchema,
+	maxBaseFeePerGas: hexStringSchema,
+	maxPriorityFeePerGas: hexStringSchema
+});
+const buildInstructionResponseSchema = z$1.object({
+	address: hexStringSchema,
+	chainId: z$1.number(),
+	salt: hexStringSchema,
+	maxExecutions: hexStringSchema,
+	action: hexStringSchema,
+	actionName: z$1.string().optional(),
+	arguments: hexStringSchema
+});
+const paymentRequestBuildResponseSchema = z$1.object({
+	requestId: z$1.string(),
+	subOrgId: z$1.string(),
+	walletId: z$1.string(),
+	ephemeralWalletAddress: hexStringSchema,
+	completionInstructions: z$1.array(buildInstructionResponseSchema),
+	instructions: z$1.array(buildInstructionResponseSchema)
+});
+const newInstructionRequestSchema = z$1.object({
+	nickname: z$1.string().optional(),
+	actionName: z$1.string().optional(),
+	address: hexStringSchema,
+	chainId: z$1.number(),
+	salt: hexStringSchema,
+	maxExecutions: hexStringSchema,
+	action: hexStringSchema,
+	arguments: hexStringSchema,
+	activationSignature: eip2098SignatureSchema
+});
+const paymentRequestNewRequestSchema = z$1.object({
+	requestId: z$1.string(),
+	signedAuthorization: z$1.string(),
+	completionInstructions: z$1.array(newInstructionRequestSchema),
+	instructions: z$1.array(newInstructionRequestSchema)
+});
+const paymentRequestDetailsRequestSchema = z$1.object({ requestId: z$1.string() });
+const paymentRequestDetailsResponseSchema = z$1.object({
+	requestId: z$1.string(),
+	ephemeralWalletAddress: hexStringSchema,
+	ephemeralWalletId: z$1.string().optional(),
+	status: z$1.enum([
+		"pending",
+		"inProgress",
+		"paid",
+		"cancelled",
+		"draft"
+	]),
+	metadata: z$1.record(z$1.string(), z$1.unknown()),
+	numRuns: z$1.number(),
+	maxRuns: z$1.number().nullish()
+});
+const settlementParamsSchema = z$1.object({
+	acceptedTokens: z$1.record(z$1.string(), z$1.array(hexStringSchema)),
+	settlementChainId: z$1.number(),
+	settlementToken: hexStringSchema,
+	settlementAmount: numberSchema,
+	recipientAddress: hexStringSchema
+});
+const vaultWithdrawSettlementParamsSchema = z$1.object({
+	vaultAddress: hexStringSchema,
+	vaultUnderlyingToken: hexStringSchema,
+	vaultChainId: z$1.number(),
+	settlementChainId: z$1.number(),
+	settlementToken: hexStringSchema,
+	recipientAddress: hexStringSchema,
+	withdrawAmount: numberSchema
+});
+const orchestrationParamsSchema = z$1.union([z$1.object({ settlement: settlementParamsSchema }), z$1.object({ vaultWithdrawSettlement: vaultWithdrawSettlementParamsSchema })]);
+const buildSettlementRequestSchema = z$1.object({
+	params: orchestrationParamsSchema,
+	payerAddress: hexStringSchema.nullish(),
+	metadata: z$1.record(z$1.string(), z$1.unknown()).optional(),
+	dueDate: z$1.string().datetime().nullish(),
+	maxRuns: z$1.number().int().positive().nullish()
+});
+const buildSettlementResponseSchema = z$1.object({
+	requestId: z$1.string(),
+	subOrgId: z$1.string(),
+	walletId: z$1.string(),
+	ephemeralWalletAddress: hexStringSchema,
+	completionInstructions: z$1.array(buildInstructionResponseSchema),
+	instructions: z$1.array(buildInstructionResponseSchema)
 });
 
-// src/api/schemas/transaction.ts
-import { z as z17 } from "zod";
-var transactionGetListRequestSchema = z17.object({
-  address: hexStringSchema,
-  chainId: z17.number(),
-  instructionIds: z17.array(z17.string()).optional(),
-  from: z17.string().optional(),
-  to: z17.string().optional(),
-  page: z17.number().optional(),
-  perPage: z17.number().optional(),
-  sort: z17.enum(sortValues).optional()
-});
-var transactionGetListResponseSchema = z17.array(transactionSchema);
+//#endregion
+//#region src/api/schemas/transaction.ts
+const transactionGetListRequestSchema = z$1.object({
+	address: hexStringSchema,
+	chainId: z$1.number(),
+	instructionIds: z$1.array(z$1.string()).optional(),
+	from: z$1.string().optional(),
+	to: z$1.string().optional(),
+	page: z$1.number().optional(),
+	perPage: z$1.number().optional(),
+	sort: z$1.enum(sortValues).optional()
+});
+const transactionGetListResponseSchema = z$1.array(transactionSchema);
 
-// src/env.ts
-var BUILD_MODE = "development";
-
-// src/helpers/logger.ts
-var Logger = class {
-  constructor() {
-    __publicField(this, "isDevelopment", BUILD_MODE === "development");
-  }
-  debug(message, options) {
-    if (this.isDevelopment) {
-      this.log("debug", message, options);
-    }
-  }
-  info(message, options) {
-    this.log("info", message, options);
-  }
-  warn(message, options) {
-    this.log("warn", message, options);
-  }
-  error(message, options) {
-    this.log("error", message, options);
-  }
-  /**
-   * Log errors with context - useful for non-API errors
-   * For API errors, use the existing getErrorMessage from @otim/utils/api
-   */
-  logError(error, options = {}) {
-    const { context, operation, metadata } = options;
-    const prefix = this.buildPrefix(context, operation);
-    let message = "Unknown error";
-    if (error instanceof Error) {
-      message = error.message;
-    } else if (typeof error === "string") {
-      message = error;
-    } else if (error && typeof error === "object" && "message" in error) {
-      message = String(error.message);
-    }
-    console.error(prefix ? `${prefix} ${message}` : message);
-    if (metadata && Object.keys(metadata).length > 0) {
-      console.error("Context:", metadata);
-    }
-    if (error instanceof Error && error.stack) {
-      console.error("Stack:", error.stack);
-    } else {
-      console.error("Error details:", error);
-    }
-  }
-  buildPrefix(context, operation) {
-    const parts = [];
-    if (context) parts.push(`[${context}]`);
-    if (operation) parts.push(`[${operation}]`);
-    return parts.join(" ");
-  }
-  log(level, message, options) {
-    const prefix = options?.context ? `[${options.context}]` : "";
-    const fullMessage = `${prefix} ${message}`.trim();
-    switch (level) {
-      case "debug":
-      case "info":
-        console.log(fullMessage);
-        break;
-      case "warn":
-        console.warn(fullMessage);
-        break;
-      case "error":
-        console.error(fullMessage);
-        break;
-    }
-    if (options?.data) {
-      console.dir(options.data, { depth: null });
-    }
-  }
-};
-var logger = new Logger();
-
-// src/helpers/zod.ts
-import { z as z18 } from "zod";
-var parseSchema = (values, schema) => {
-  const inputValues = schema.safeParse(values);
-  if (!inputValues.success) {
-    throw new Error(
-      `parseSchema: invalid input values ${JSON.stringify(inputValues.error)}`
-    );
-  }
-  return inputValues.data;
+//#endregion
+//#region src/api/utils/backoff.ts
+const DEFAULT_INITIAL_INTERVAL = 5e3;
+const DEFAULT_MAX_INTERVAL = 3e4;
+const DEFAULT_MULTIPLIER = 1.5;
+/**
+* Calculates an exponential backoff interval based on the failure count.
+*
+* @param failureCount - Number of consecutive failures
+* @param options - Configuration options for the backoff calculation
+* @returns The calculated interval in milliseconds, capped at maxInterval
+*/
+const calculateBackoffInterval = (failureCount, options = {}) => {
+	const { initialInterval = DEFAULT_INITIAL_INTERVAL, maxInterval = DEFAULT_MAX_INTERVAL, multiplier = DEFAULT_MULTIPLIER } = options;
+	return Math.min(initialInterval * Math.pow(multiplier, failureCount), maxInterval);
 };
 
-// src/api/utils/pagination.ts
+//#endregion
+//#region src/api/utils/pagination.ts
+/**
+* Determine if additional pages are likely available based on the number of
+* items received and the requested page size.
+*
+* Returns true when the current page contains at least `requestedPageSize`
+* items, implying there may be more data to fetch.
+*
+* @param items Array of items returned for the current page.
+* @param requestedPageSize The `perPage` value requested for this fetch.
+* @returns Whether another page may be available.
+*/
 function calculateHasMore(items, requestedPageSize) {
-  return items.length >= requestedPageSize;
+	return items.length >= requestedPageSize;
 }
+/**
+* Extract pagination-related fields from a request object and return them
+* separately from the remaining parameters.
+*
+* @param request Request object containing `page`, `perPage`, and other fields.
+* @returns Object with `paginationParams` and `restParams` split for
+* convenience.
+*/
 function extractPaginationParams(request) {
-  const { page, perPage, ...restParams } = request;
-  return {
-    paginationParams: { page, perPage },
-    restParams
-  };
+	const { page, perPage, ...restParams } = request;
+	return {
+		paginationParams: {
+			page,
+			perPage
+		},
+		restParams
+	};
 }
+/**
+* Provide a standard default for pagination parameters.
+*
+* @returns Default pagination with `page: 0` and `perPage: 100`.
+*/
 function getDefaultPagination() {
-  return {
-    page: 0,
-    perPage: 100
-  };
+	return {
+		page: 0,
+		perPage: 100
+	};
 }
 
-// src/api/services/base.ts
+//#endregion
+//#region src/api/services/base.ts
 var BaseService = class {
-  constructor(instance) {
-    this.instance = instance;
-  }
-  async makeRequest({
-    url,
-    method = HttpMethod.Get,
-    data,
-    schema,
-    validateResponse,
-    ...config
-  }) {
-    try {
-      const res = await this.instance.request({ url, method, data, ...config });
-      if (validateResponse && !validateResponse(res.data)) {
-        throw new ServiceError("Invalid response format", "INVALID_RESPONSE");
-      }
-      const parsedData = schema ? parseSchema(res.data, schema) : res.data;
-      return { data: parsedData };
-    } catch (error) {
-      if (error instanceof ServiceError) {
-        throw error;
-      }
-      let errorMessage = "Unknown error";
-      let errorCode;
-      if (error && typeof error === "object" && "response" in error) {
-        const axiosError = error;
-        const responseData = axiosError.response?.data;
-        errorMessage = responseData?.errorMessage || responseData?.message || errorMessage;
-        errorCode = responseData?.errorCode;
-      } else if (error instanceof Error) {
-        errorMessage = error.message;
-      }
-      throw new ServiceError(errorMessage, errorCode || "REQUEST_FAILED");
-    }
-  }
-  async makePaginatedRequest({
-    url,
-    method = HttpMethod.Get,
-    data,
-    schema,
-    validateResponse,
-    ...config
-  }) {
-    const { paginationParams, restParams } = extractPaginationParams(
-      data || {}
-    );
-    const { page, perPage } = {
-      ...getDefaultPagination(),
-      ...paginationParams
-    };
-    const requestData = { ...restParams, page, perPage };
-    const response = await this.makeRequest({
-      url,
-      method,
-      data: requestData,
-      schema,
-      validateResponse,
-      ...config
-    });
-    const hasMore = Array.isArray(response.data) ? calculateHasMore(response.data, perPage) : false;
-    return {
-      data: response.data,
-      hasMore
-    };
-  }
+	constructor(instance) {
+		this.instance = instance;
+	}
+	async makeRequest({ url, method = HttpMethod.Get, data, schema, validateResponse, ...config }) {
+		try {
+			const res = await this.instance.request({
+				url,
+				method,
+				data,
+				...config
+			});
+			if (validateResponse && !validateResponse(res.data)) throw new ServiceError("Invalid response format", "INVALID_RESPONSE");
+			return { data: schema ? parseSchema(res.data, schema) : res.data };
+		} catch (error) {
+			if (error instanceof ServiceError) throw error;
+			let errorMessage = "Unknown error";
+			let errorCode;
+			if (error && typeof error === "object" && "response" in error) {
+				const responseData = error.response?.data;
+				errorMessage = responseData?.errorMessage || responseData?.message || errorMessage;
+				errorCode = responseData?.errorCode;
+			} else if (error instanceof Error) errorMessage = error.message;
+			throw new ServiceError(errorMessage, errorCode || "REQUEST_FAILED");
+		}
+	}
+	async makePaginatedRequest({ url, method = HttpMethod.Get, data, schema, validateResponse, ...config }) {
+		const { paginationParams, restParams } = extractPaginationParams(data || {});
+		const { page, perPage } = {
+			...getDefaultPagination(),
+			...paginationParams
+		};
+		const requestData = {
+			...restParams,
+			page,
+			perPage
+		};
+		const response = await this.makeRequest({
+			url,
+			method,
+			data: requestData,
+			schema,
+			validateResponse,
+			...config
+		});
+		const hasMore = Array.isArray(response.data) ? calculateHasMore(response.data, perPage) : false;
+		return {
+			data: response.data,
+			hasMore
+		};
+	}
 };
 
-// src/api/services/account.ts
+//#endregion
+//#region src/api/services/account.ts
 var AccountService = class extends BaseService {
-  async getDelegationStatus(requestBody) {
-    const res = await this.makeRequest({
-      url: "/delegation/status",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: delegationStatusResponseSchema
-    });
-    return res;
-  }
-  async createDelegation(requestBody) {
-    await this.makeRequest({
-      url: "/delegation/new",
-      method: HttpMethod.Post,
-      data: requestBody
-    });
-    return {
-      data: { success: true, message: "Delegation created" }
-    };
-  }
+	async getDelegationStatus(requestBody) {
+		return await this.makeRequest({
+			url: "/delegation/status",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: delegationStatusResponseSchema
+		});
+	}
+	async createDelegation(requestBody) {
+		await this.makeRequest({
+			url: "/delegation/new",
+			method: HttpMethod.Post,
+			data: requestBody
+		});
+		return { data: {
+			success: true,
+			message: "Delegation created"
+		} };
+	}
 };
 
-// src/api/services/activity.ts
-import { z as z19 } from "zod";
-var safeParseActivityArray = (data) => {
-  if (!Array.isArray(data)) {
-    return [];
-  }
-  const validRecords = [];
-  data.forEach((record) => {
-    const result = activityRecordSchema.safeParse(record);
-    if (result.success) {
-      validRecords.push(result.data);
-    }
-  });
-  return validRecords;
+//#endregion
+//#region src/api/services/activity.ts
+const safeParseActivityArray = (data) => {
+	if (!Array.isArray(data)) return [];
+	const validRecords = [];
+	data.forEach((record) => {
+		const result = activityRecordSchema.safeParse(record);
+		if (result.success) validRecords.push(result.data);
+	});
+	return validRecords;
 };
-var safeActivityArraySchema = z19.unknown().transform(safeParseActivityArray);
+const safeActivityArraySchema = z$1.unknown().transform(safeParseActivityArray);
 var ActivityService = class extends BaseService {
-  async getInstructionActivity(requestBody) {
-    return this.makePaginatedRequest({
-      url: "/instructions/activity",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: safeActivityArraySchema
-    });
-  }
+	async getInstructionActivity(requestBody) {
+		return this.makePaginatedRequest({
+			url: "/instructions/activity",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: safeActivityArraySchema
+		});
+	}
 };
 
-// src/api/services/auth.ts
+//#endregion
+//#region src/api/services/auth.ts
 var AuthService = class extends BaseService {
-  async login(requestBody) {
-    const res = await this.makeRequest({
-      url: "/auth/login",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: authLoginResponseSchema
-    });
-    return res;
-  }
-  async turnkeyVerification(requestBody) {
-    const res = await this.makeRequest({
-      url: "/turnkey/verification",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: turnkeyVerificationResponseSchema
-    });
-    return res;
-  }
-  async turnkeyLogin(requestBody) {
-    const res = await this.makeRequest({
-      url: "/turnkey/login",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: turnkeyLoginResponseSchema
-    });
-    return res;
-  }
-  async me() {
-    const res = await this.makeRequest({
-      url: "/auth/me",
-      method: HttpMethod.Get,
-      schema: userSchema
-    });
-    return res;
-  }
-  async updatePreferences(preferences) {
-    const res = await this.makeRequest({
-      url: "/user/preferences",
-      method: HttpMethod.Put,
-      data: { preferences }
-    });
-    return res;
-  }
+	async login(requestBody) {
+		return await this.makeRequest({
+			url: "/auth/login",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: authLoginResponseSchema
+		});
+	}
+	async turnkeyVerification(requestBody) {
+		return await this.makeRequest({
+			url: "/turnkey/verification",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: turnkeyVerificationResponseSchema
+		});
+	}
+	async turnkeyLogin(requestBody) {
+		return await this.makeRequest({
+			url: "/turnkey/login",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: turnkeyLoginResponseSchema
+		});
+	}
+	async me() {
+		return await this.makeRequest({
+			url: "/auth/me",
+			method: HttpMethod.Get,
+			schema: userSchema
+		});
+	}
+	async updatePreferences(preferences) {
+		return await this.makeRequest({
+			url: "/user/preferences",
+			method: HttpMethod.Put,
+			data: { preferences }
+		});
+	}
 };
 
-// src/api/services/config.ts
+//#endregion
+//#region src/api/services/config.ts
 var ConfigService = class extends BaseService {
-  async getDelegateAddress(requestBody) {
-    const res = await this.makeRequest({
-      url: `/config/delegate/address/${requestBody.chainId}`,
-      method: HttpMethod.Get,
-      schema: getDelegateAddressResponseSchema
-    });
-    return res;
-  }
-  async getConfigTokens({
-    chainId
-  }) {
-    const res = await this.makeRequest({
-      url: `/config/tokens/${chainId}`,
-      method: HttpMethod.Get,
-      schema: getConfigTokensResponseSchema
-    });
-    return res;
-  }
-  async getConfigChains() {
-    const res = await this.makeRequest({
-      url: `/config/chains`,
-      method: HttpMethod.Get,
-      schema: getConfigChainsResponseSchema
-    });
-    return res;
-  }
-  async getMaxPriorityFeePerGasEstimate(requestBody) {
-    const res = await this.makeRequest({
-      url: `/instruction/estimate/max_priority_fee_per_gas/${requestBody.chainId}`,
-      method: HttpMethod.Get,
-      schema: getMaxPriorityFeePerGasEstimateResponseSchema
-    });
-    return res;
-  }
+	async getDelegateAddress(requestBody) {
+		return await this.makeRequest({
+			url: `/config/delegate/address/${requestBody.chainId}`,
+			method: HttpMethod.Get,
+			schema: getDelegateAddressResponseSchema
+		});
+	}
+	async getConfigTokens({ chainId }) {
+		return await this.makeRequest({
+			url: `/config/tokens/${chainId}`,
+			method: HttpMethod.Get,
+			schema: getConfigTokensResponseSchema
+		});
+	}
+	async getConfigChains() {
+		return await this.makeRequest({
+			url: `/config/chains`,
+			method: HttpMethod.Get,
+			schema: getConfigChainsResponseSchema
+		});
+	}
+	async getMaxPriorityFeePerGasEstimate(requestBody) {
+		return await this.makeRequest({
+			url: `/instruction/estimate/max_priority_fee_per_gas/${requestBody.chainId}`,
+			method: HttpMethod.Get,
+			schema: getMaxPriorityFeePerGasEstimateResponseSchema
+		});
+	}
 };
 
-// src/api/services/contacts.ts
+//#endregion
+//#region src/api/services/contacts.ts
 var ContactsService = class extends BaseService {
-  async create(request) {
-    const validated = newContactRequestSchema.parse(request);
-    return this.makeRequest({
-      url: "/contacts",
-      method: HttpMethod.Put,
-      data: validated
-    });
-  }
-  async list(request) {
-    const validated = getContactsRequestSchema.parse(request);
-    return this.makePaginatedRequest({
-      url: "/contacts",
-      method: HttpMethod.Get,
-      data: validated,
-      schema: getContactsResponseSchema
-    });
-  }
+	async create(request) {
+		const validated = newContactRequestSchema.parse(request);
+		return this.makeRequest({
+			url: "/contacts",
+			method: HttpMethod.Put,
+			data: validated
+		});
+	}
+	async list(request) {
+		const validated = getContactsRequestSchema.parse(request);
+		return this.makePaginatedRequest({
+			url: "/contacts",
+			method: HttpMethod.Get,
+			data: validated,
+			schema: getContactsResponseSchema
+		});
+	}
 };
 
-// src/api/services/developer.ts
+//#endregion
+//#region src/api/services/developer.ts
 var DeveloperService = class extends BaseService {
-  async updatePublicKey(developerPublicKey) {
-    return this.makeRequest({
-      url: "/developer/public_key",
-      method: HttpMethod.Put,
-      data: { developerPublicKey }
-    });
-  }
-  async generateApiKey() {
-    return this.makeRequest({
-      url: "/developer/api_key",
-      method: HttpMethod.Post
-    });
-  }
+	async updatePublicKey(developerPublicKey) {
+		return this.makeRequest({
+			url: "/developer/public_key",
+			method: HttpMethod.Put,
+			data: { developerPublicKey }
+		});
+	}
+	async generateApiKey() {
+		return this.makeRequest({
+			url: "/developer/api_key",
+			method: HttpMethod.Post
+		});
+	}
 };
 
-// src/api/services/instruction.ts
+//#endregion
+//#region src/api/services/instruction.ts
 var InstructionService = class extends BaseService {
-  async all(requestBody) {
-    return this.makePaginatedRequest({
-      url: "/instructions/all",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: instructionsSchema
-    });
-  }
-  async build(requestBody) {
-    const res = await this.makeRequest({
-      url: "/instruction/build",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: instructionBuildSchema
-    });
-    return res;
-  }
-  async activate(requestBody) {
-    const res = await this.makeRequest({
-      url: "/instruction/new",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: instructionActivateResponseSchema
-    });
-    return res;
-  }
-  async deactivate(requestBody) {
-    const res = await this.makeRequest({
-      url: "/instruction/deactivate",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: instructionDeactivateResponseSchema
-    });
-    return res;
-  }
-  async details(requestBody) {
-    const res = await this.makeRequest({
-      url: "/instruction/details",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: instructionDetailsResponseSchema
-    });
-    return res;
-  }
-  async rules(requestBody) {
-    return this.makePaginatedRequest({
-      url: "/instructions/rules",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: instructionGetRulesResponseSchema
-    });
-  }
+	async all(requestBody) {
+		return this.makePaginatedRequest({
+			url: "/instructions/all",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: instructionsSchema
+		});
+	}
+	async build(requestBody) {
+		return await this.makeRequest({
+			url: "/instruction/build",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: instructionBuildSchema
+		});
+	}
+	async activate(requestBody) {
+		return await this.makeRequest({
+			url: "/instruction/new",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: instructionActivateResponseSchema
+		});
+	}
+	async deactivate(requestBody) {
+		return await this.makeRequest({
+			url: "/instruction/deactivate",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: instructionDeactivateResponseSchema
+		});
+	}
+	async details(requestBody) {
+		return await this.makeRequest({
+			url: "/instruction/details",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: instructionDetailsResponseSchema
+		});
+	}
+	async rules(requestBody) {
+		return this.makePaginatedRequest({
+			url: "/instructions/rules",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: instructionGetRulesResponseSchema
+		});
+	}
 };
 
-// src/api/services/transaction.ts
+//#endregion
+//#region src/api/services/transaction.ts
 var TransactionService = class extends BaseService {
-  async list(requestBody) {
-    return this.makePaginatedRequest({
-      url: "/transactions",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: transactionGetListResponseSchema
-    });
-  }
+	async list(requestBody) {
+		return this.makePaginatedRequest({
+			url: "/transactions",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: transactionGetListResponseSchema
+		});
+	}
 };
 
-// src/api/services/payments.ts
+//#endregion
+//#region src/api/services/payments.ts
 var PaymentsService = class extends BaseService {
-  async getOutgoingPaymentsList(request) {
-    return this.makePaginatedRequest({
-      url: "/api/payments/outgoing",
-      method: HttpMethod.Get,
-      data: request,
-      schema: PaymentsSchema
-    });
-  }
-  async getIncomingPaymentsList(request) {
-    return this.makePaginatedRequest({
-      url: "/api/payments/incoming",
-      method: HttpMethod.Get,
-      data: request,
-      schema: PaymentsSchema
-    });
-  }
-  async buildPaymentRequest(requestBody) {
-    return this.makeRequest({
-      url: "/orchestration/build",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: paymentRequestBuildResponseSchema
-    });
-  }
-  async newPaymentRequest(requestBody) {
-    return this.makeRequest({
-      url: "/orchestration/new",
-      method: HttpMethod.Post,
-      data: requestBody,
-      validateResponse: () => true
-    });
-  }
-  async getPaymentRequestDetails(requestBody) {
-    return this.makeRequest({
-      url: "/orchestration/details",
-      method: HttpMethod.Get,
-      data: requestBody,
-      schema: paymentRequestDetailsResponseSchema
-    });
-  }
-  async getPaymentRequests(request) {
-    return this.makePaginatedRequest({
-      url: "/orchestrations",
-      method: HttpMethod.Get,
-      data: request,
-      schema: getPaymentRequestsResponseSchema
-    });
-  }
-  async buildSettlementOrchestration(requestBody) {
-    return this.makeRequest({
-      url: "/orchestration/build/settlement",
-      method: HttpMethod.Post,
-      data: requestBody,
-      schema: buildSettlementResponseSchema
-    });
-  }
+	async getOutgoingPaymentsList(request) {
+		return this.makePaginatedRequest({
+			url: "/api/payments/outgoing",
+			method: HttpMethod.Get,
+			data: request,
+			schema: PaymentsSchema
+		});
+	}
+	async getIncomingPaymentsList(request) {
+		return this.makePaginatedRequest({
+			url: "/api/payments/incoming",
+			method: HttpMethod.Get,
+			data: request,
+			schema: PaymentsSchema
+		});
+	}
+	async buildPaymentRequest(requestBody) {
+		return this.makeRequest({
+			url: "/orchestration/build",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: paymentRequestBuildResponseSchema
+		});
+	}
+	async newPaymentRequest(requestBody) {
+		return this.makeRequest({
+			url: "/orchestration/new",
+			method: HttpMethod.Post,
+			data: requestBody,
+			validateResponse: () => true
+		});
+	}
+	async getPaymentRequestDetails(requestBody) {
+		return this.makeRequest({
+			url: "/orchestration/details",
+			method: HttpMethod.Get,
+			data: requestBody,
+			schema: paymentRequestDetailsResponseSchema
+		});
+	}
+	async getPaymentRequests(request) {
+		return this.makePaginatedRequest({
+			url: "/orchestrations",
+			method: HttpMethod.Get,
+			data: request,
+			schema: getPaymentRequestsResponseSchema
+		});
+	}
+	async buildSettlementOrchestration(requestBody) {
+		return this.makeRequest({
+			url: "/orchestration/build/settlement",
+			method: HttpMethod.Post,
+			data: requestBody,
+			schema: buildSettlementResponseSchema
+		});
+	}
 };
 
-// src/api/services/integration.ts
-import axios2 from "axios";
+//#endregion
+//#region src/api/services/integration.ts
 function createEmptyIntegrationResponse(integrationType) {
-  switch (integrationType) {
-    case IntegrationType.QuickBooks:
-      return { integrationType: IntegrationType.QuickBooks, details: {} };
-    case IntegrationType.Bank:
-      return { integrationType: IntegrationType.Bank, details: {} };
-    case IntegrationType.Clio:
-      return { integrationType: IntegrationType.Clio, details: {} };
-    case IntegrationType.Stripe:
-      return { integrationType: IntegrationType.Stripe, details: {} };
-    case IntegrationType.Bill:
-      return { integrationType: IntegrationType.Bill, details: {} };
-    case IntegrationType.Zoho:
-      return { integrationType: IntegrationType.Zoho, details: {} };
-    default:
-      return { integrationType: IntegrationType.Bank, details: {} };
-  }
+	switch (integrationType) {
+		case IntegrationType.QuickBooks: return {
+			integrationType: IntegrationType.QuickBooks,
+			details: {}
+		};
+		case IntegrationType.Bank: return {
+			integrationType: IntegrationType.Bank,
+			details: {}
+		};
+		case IntegrationType.Clio: return {
+			integrationType: IntegrationType.Clio,
+			details: {}
+		};
+		case IntegrationType.Stripe: return {
+			integrationType: IntegrationType.Stripe,
+			details: {}
+		};
+		case IntegrationType.Bill: return {
+			integrationType: IntegrationType.Bill,
+			details: {}
+		};
+		case IntegrationType.Zoho: return {
+			integrationType: IntegrationType.Zoho,
+			details: {}
+		};
+		default: return {
+			integrationType: IntegrationType.Bank,
+			details: {}
+		};
+	}
 }
 var IntegrationService = class extends BaseService {
-  async upsert(request) {
-    return this.makeRequest({
-      url: "/integration",
-      method: HttpMethod.Put,
-      data: request,
-      schema: integrationResponseSchema
-    });
-  }
-  async get(request) {
-    try {
-      return await this.makeRequest(
-        {
-          url: "/integration/get",
-          method: HttpMethod.Post,
-          data: request,
-          schema: integrationResponseSchema
-        }
-      );
-    } catch (error) {
-      if (axios2.isAxiosError(error) && error.response?.status === 404) {
-        const defaultResponse = createEmptyIntegrationResponse(
-          request.integrationType
-        );
-        return { data: defaultResponse };
-      }
-      throw error;
-    }
-  }
+	async upsert(request) {
+		return this.makeRequest({
+			url: "/integration",
+			method: HttpMethod.Put,
+			data: request,
+			schema: integrationResponseSchema
+		});
+	}
+	async get(request) {
+		try {
+			return await this.makeRequest({
+				url: "/integration/get",
+				method: HttpMethod.Post,
+				data: request,
+				schema: integrationResponseSchema
+			});
+		} catch (error) {
+			if (axios.isAxiosError(error) && error.response?.status === 404) return { data: createEmptyIntegrationResponse(request.integrationType) };
+			throw error;
+		}
+	}
 };
 
-// src/api/services/operating-account.ts
+//#endregion
+//#region src/api/services/operating-account.ts
 var OperatingAccountService = class extends BaseService {
-  async createSubOrganization() {
-    const res = await this.makeRequest({
-      url: "/operating_accounts/sub_organization/new",
-      method: HttpMethod.Post,
-      schema: newOperatingAccountSubOrgResponseSchema
-    });
-    return res;
-  }
-  async getSubOrganization() {
-    const res = await this.makeRequest({
-      url: "/operating_accounts/sub_organization",
-      method: HttpMethod.Get,
-      schema: getOperatingAccountSubOrgResponseSchema
-    });
-    return res;
-  }
+	async createSubOrganization() {
+		return await this.makeRequest({
+			url: "/operating_accounts/sub_organization/new",
+			method: HttpMethod.Post,
+			schema: newOperatingAccountSubOrgResponseSchema
+		});
+	}
+	async getSubOrganization() {
+		return await this.makeRequest({
+			url: "/operating_accounts/sub_organization",
+			method: HttpMethod.Get,
+			schema: getOperatingAccountSubOrgResponseSchema
+		});
+	}
 };
 
-// src/api/services/uniswap-token-list-service.ts
-var UniswapTokenListService = class extends BaseService {
-  constructor() {
-    super(...arguments);
-    __publicField(this, "UNISWAP_TOKEN_LIST_URL", "https://ipfs.io/ipns/tokens.uniswap.org");
-    __publicField(this, "FALLBACK_URL", "https://tokens.uniswap.org/");
-    __publicField(this, "CACHE_DURATION", 30 * 60 * 1e3);
-    // 30 minutes
-    __publicField(this, "SUPPORTED_CHAIN_IDS", [1, 10, 42161, 8453]);
-    // mainnet, optimism, arbitrum, base
-    __publicField(this, "tokenListCache", null);
-    __publicField(this, "lastFetch", 0);
-  }
-  /**
-   * Get tokens for a specific chain
-   */
-  async getTokensForChain({
-    chainId,
-    limit = 50
-  }) {
-    try {
-      const tokenList = await this.fetchTokenList();
-      if (!this.SUPPORTED_CHAIN_IDS.includes(chainId)) {
-        return {
-          data: {
-            tokens: [],
-            source: "uniswap",
-            timestamp: tokenList.timestamp
-          }
-        };
-      }
-      const chainTokens = tokenList.tokens.filter(
-        (token) => token.chainId === chainId
-      );
-      const filteredTokens = chainTokens.filter((token) => {
-        const suspiciousPatterns = [
-          /test/i,
-          /fake/i,
-          /scam/i,
-          /shit/i,
-          /moon/i,
-          /doge/i,
-          /inu/i,
-          /baby/i,
-          /mini/i,
-          /micro/i,
-          /nano/i,
-          /pico/i,
-          /mega/i,
-          /ultra/i,
-          /super/i,
-          /hyper/i,
-          /meta/i,
-          /safe/i,
-          /new/i,
-          /old/i,
-          /v2/i,
-          /v3/i,
-          /v4/i,
-          /v5/i,
-          /2\.0/i,
-          /3\.0/i,
-          /4\.0/i,
-          /5\.0/i
-        ];
-        const name = token.name?.toLowerCase() || "";
-        const symbol = token.symbol?.toLowerCase() || "";
-        if (suspiciousPatterns.some(
-          (pattern) => pattern.test(name) || pattern.test(symbol)
-        )) {
-          return false;
-        }
-        if (name.length < 2 || name.length > 50) return false;
-        if (symbol.length < 2 || symbol.length > 20) return false;
-        if (!token.name || !token.symbol || !token.address) return false;
-        return true;
-      });
-      const limitedTokens = filteredTokens.slice(0, limit);
-      return {
-        data: {
-          tokens: limitedTokens,
-          source: "uniswap",
-          timestamp: tokenList.timestamp
-        }
-      };
-    } catch (error) {
-      throw new Error(error instanceof Error ? error.message : "Unknown error");
-    }
-  }
-  /**
-   * Get all supported chains from the token list
-   */
-  async getSupportedChains() {
-    try {
-      const tokenList = await this.fetchTokenList();
-      const chainIds = Array.from(
-        new Set(tokenList.tokens.map((token) => token.chainId))
-      ).sort((a, b) => a - b);
-      return {
-        data: chainIds
-      };
-    } catch (error) {
-      throw new Error(error instanceof Error ? error.message : "Unknown error");
-    }
-  }
-  /**
-   * Search for a specific token by address or symbol
-   */
-  async findToken(chainId, query) {
-    try {
-      const tokenList = await this.fetchTokenList();
-      const token = tokenList.tokens.find(
-        (t) => t.chainId === chainId && (t.address.toLowerCase() === query.toLowerCase() || t.symbol.toLowerCase() === query.toLowerCase() || t.name.toLowerCase().includes(query.toLowerCase()))
-      );
-      return {
-        data: token || null
-      };
-    } catch (error) {
-      throw new Error(error instanceof Error ? error.message : "Unknown error");
-    }
-  }
-  /**
-   * Get bridge information for a token
-   */
-  async getBridgeInfo(chainId, tokenAddress) {
-    try {
-      const tokenList = await this.fetchTokenList();
-      const token = tokenList.tokens.find(
-        (t) => t.chainId === chainId && t.address.toLowerCase() === tokenAddress.toLowerCase()
-      );
-      if (!token || !token.extensions?.bridgeInfo) {
-        return {
-          data: {}
-        };
-      }
-      const bridgeInfo = {};
-      for (const [targetChainId, info] of Object.entries(
-        token.extensions.bridgeInfo
-      )) {
-        bridgeInfo[targetChainId] = info.tokenAddress;
-      }
-      return {
-        data: bridgeInfo
-      };
-    } catch (error) {
-      throw new Error(error instanceof Error ? error.message : "Unknown error");
-    }
-  }
-  /**
-   * Fetch the Uniswap token list
-   */
-  async fetchTokenList() {
-    const now = Date.now();
-    if (this.tokenListCache && now - this.lastFetch < this.CACHE_DURATION) {
-      return this.tokenListCache;
-    }
-    try {
-      const response = await fetch(this.UNISWAP_TOKEN_LIST_URL, {
-        headers: {
-          Accept: "application/json"
-        }
-      });
-      if (!response.ok) {
-        throw new Error(`IPFS fetch failed: ${response.status}`);
-      }
-      const data = await response.json();
-      this.tokenListCache = data;
-      this.lastFetch = now;
-      return data;
-    } catch (error) {
-      logger.logError(error, {
-        context: this.fetchTokenList.name
-      });
-      try {
-        const response = await fetch(this.FALLBACK_URL, {
-          headers: {
-            Accept: "application/json"
-          }
-        });
-        if (!response.ok) {
-          throw new Error(`Fallback fetch failed: ${response.status}`);
-        }
-        const data = await response.json();
-        this.tokenListCache = data;
-        this.lastFetch = now;
-        return data;
-      } catch (fallbackError) {
-        logger.logError(fallbackError, {
-          context: this.fetchTokenList.name
-        });
-        throw new Error("Unable to fetch Uniswap token list");
-      }
-    }
-  }
-};
-
-// src/api/api.ts
+//#endregion
+//#region src/api/api.ts
 var APIClient = class {
-  constructor(init) {
-    __publicField(this, "account");
-    __publicField(this, "activity");
-    __publicField(this, "auth");
-    __publicField(this, "operatingAccount");
-    __publicField(this, "config");
-    __publicField(this, "contacts");
-    __publicField(this, "developer");
-    __publicField(this, "instruction");
-    __publicField(this, "transaction");
-    __publicField(this, "payments");
-    __publicField(this, "integration");
-    const instance = isInstanceInit(init) ? init.instance : createInstance(init);
-    this.account = new AccountService(instance);
-    this.activity = new ActivityService(instance);
-    this.auth = new AuthService(instance);
-    this.config = new ConfigService(instance);
-    this.contacts = new ContactsService(instance);
-    this.developer = new DeveloperService(instance);
-    this.instruction = new InstructionService(instance);
-    this.integration = new IntegrationService(instance);
-    this.transaction = new TransactionService(instance);
-    this.operatingAccount = new OperatingAccountService(instance);
-    this.payments = new PaymentsService(instance);
-  }
+	constructor(init) {
+		_defineProperty(this, "account", void 0);
+		_defineProperty(this, "activity", void 0);
+		_defineProperty(this, "auth", void 0);
+		_defineProperty(this, "operatingAccount", void 0);
+		_defineProperty(this, "config", void 0);
+		_defineProperty(this, "contacts", void 0);
+		_defineProperty(this, "developer", void 0);
+		_defineProperty(this, "instruction", void 0);
+		_defineProperty(this, "transaction", void 0);
+		_defineProperty(this, "payments", void 0);
+		_defineProperty(this, "integration", void 0);
+		const instance = isInstanceInit(init) ? init.instance : createInstance({
+			...init,
+			baseURL: init?.environment ? getOffchainApiUrl(init.environment) : init?.baseURL
+		});
+		this.account = new AccountService(instance);
+		this.activity = new ActivityService(instance);
+		this.auth = new AuthService(instance);
+		this.config = new ConfigService(instance);
+		this.contacts = new ContactsService(instance);
+		this.developer = new DeveloperService(instance);
+		this.instruction = new InstructionService(instance);
+		this.integration = new IntegrationService(instance);
+		this.transaction = new TransactionService(instance);
+		this.operatingAccount = new OperatingAccountService(instance);
+		this.payments = new PaymentsService(instance);
+	}
 };
-var createAPIClient = (...params) => {
-  return new APIClient(...params);
+const createAPIClient = (...params) => {
+	return new APIClient(...params);
 };
-export {
-  APIClient,
-  AccountService,
-  ActivityService,
-  AuthService,
-  ConfigService,
-  ContactsService,
-  DelegationStatus,
-  DeveloperService,
-  HttpMethod,
-  InstructionService,
-  IntegrationService,
-  IntegrationType,
-  OperatingAccountService,
-  PaymentsService,
-  ServiceError,
-  TransactionService,
-  UniswapTokenListService,
-  actionArgumentsResponseSchema,
-  actionArgumentsSchema,
-  actionNameSchema,
-  activityDataSchema,
-  activityRecordSchema,
-  addressWhitelistCheckRequestSchema,
-  addressWhitelistCheckResponseSchema,
-  apiErrorSchema,
-  attestationSchema,
-  authLoginRequestSchema,
-  authLoginResponseSchema,
-  buildEphemeralInstructionSchema,
-  buildSettlementRequestSchema,
-  buildSettlementResponseSchema,
-  calculateHasMore,
-  chainIdSchema,
-  chainSuccessResponseSchema,
-  contactSchema,
-  createAPIClient,
-  createAbortController,
-  createInstance,
-  delegationCreateRequestSchema,
-  delegationCreateResponseSchema,
-  delegationStatusRequestSchema,
-  delegationStatusResponseSchema,
-  delegationStatusSchema,
-  delegationStatusValues,
-  errorResponseSchema,
-  extractPaginationParams,
-  feeResponseSchema2 as feeResponseSchema,
-  getConfigChainsResponseSchema,
-  getConfigTokensRequestParametersSchema,
-  getConfigTokensResponseSchema,
-  getContactsRequestSchema,
-  getContactsResponseSchema,
-  getCurrentUserResponseSchema,
-  getDefaultPagination,
-  getDelegateAddressResponseSchema,
-  getDelegateAddressSchema,
-  getErrorMessage,
-  getErrorMessageWithCode,
-  getInstructionActivityRequestSchema,
-  getInstructionActivityResponseSchema,
-  getIntegrationRequestSchema,
-  getMaxPriorityFeePerGasEstimateResponseSchema,
-  getMaxPriorityFeePerGasEstimateSchema,
-  getOperatingAccountSubOrgResponseSchema,
-  getPaymentRequestsRequestSchema,
-  getPaymentRequestsResponseSchema,
-  getUserFriendlyErrorMessage,
-  instructionActivateRequestSchema,
-  instructionActivateResponseSchema,
-  instructionBuildRequestSchema,
-  instructionBuildSchema,
-  instructionDeactivateRequestSchema,
-  instructionDeactivateResponseSchema,
-  instructionDetailsRequestSchema,
-  instructionDetailsResponseSchema,
-  instructionGetAllRequestSchema,
-  instructionGetAllResponseSchema,
-  instructionGetRulesRequestSchema,
-  instructionGetRulesResponseSchema,
-  integrationResponseSchema,
-  integrationTypeSchema,
-  integrationTypeValues,
-  isInstanceInit,
-  isTechnicalError,
-  isUserAddressableError,
-  isUserRejectionError,
-  meResponseSchema,
-  newContactRequestSchema,
-  newInstructionRequestSchema,
-  newOperatingAccountSubOrgResponseSchema,
-  paymentRequestBuildRequestSchema,
-  paymentRequestBuildResponseSchema,
-  paymentRequestDetailsRequestSchema,
-  paymentRequestDetailsResponseSchema,
-  paymentRequestNewRequestSchema,
-  paymentRequestSchema,
-  paymentRequestStatusSchema,
-  paymentRequestsDirectionSchema,
-  sessionTokenRequestSchema,
-  sessionTokenResponseSchema,
-  sessionVerifyResponseSchema,
-  setChainIdSchema,
-  transactionGetListRequestSchema,
-  transactionGetListResponseSchema,
-  turnkeyLoginRequestSchema,
-  turnkeyLoginResponseSchema,
-  turnkeyVerificationRequestSchema,
-  turnkeyVerificationResponseSchema,
-  updateIntegrationRequestSchema,
-  whitelistCheckRequestSchema,
-  whitelistCheckResponseSchema
+
+//#endregion
+//#region src/api/result.ts
+function success(data) {
+	return {
+		success: true,
+		data
+	};
+}
+function failure(error, code) {
+	return {
+		success: false,
+		error,
+		code
+	};
+}
+function isSuccess(result) {
+	return result.success === true;
+}
+function isFailure(result) {
+	return result.success === false;
+}
+const ErrorCode = {
+	NetworkError: "NETWORK_ERROR",
+	Unauthorized: "UNAUTHORIZED",
+	AuthenticationFailed: "AUTH_FAILED",
+	MissingParameter: "MISSING_PARAMETER",
+	Forbidden: "FORBIDDEN",
+	SessionExpired: "SESSION_EXPIRED",
+	InvalidInput: "INVALID_INPUT",
+	UnknownError: "UNKNOWN_ERROR"
 };
-//# sourceMappingURL=index.mjs.map
+
+//#endregion
+export { APIClient, AccountService, ActivityService, AuthService, ConfigService, ContactsService, DelegationStatus, DeveloperService, ErrorCode, HttpMethod, InstructionService, IntegrationService, IntegrationType, OperatingAccountService, PaymentsService, ServiceError, TransactionService, actionArgumentsResponseSchema, actionArgumentsSchema, actionNameSchema, activityDataSchema, activityRecordSchema, addressWhitelistCheckRequestSchema, addressWhitelistCheckResponseSchema, apiErrorSchema, attestationSchema, authLoginRequestSchema, authLoginResponseSchema, buildEphemeralInstructionSchema, buildSettlementRequestSchema, buildSettlementResponseSchema, calculateBackoffInterval, calculateHasMore, chainIdSchema, chainSuccessResponseSchema, contactSchema, createAPIClient, createAbortController, createInstance, delegationCreateRequestSchema, delegationCreateResponseSchema, delegationStatusRequestSchema, delegationStatusResponseSchema, delegationStatusSchema, delegationStatusValues, errorResponseSchema, extractPaginationParams, failure, feeResponseSchema, formatActionName, formatPaymentRail, getConfigChainsResponseSchema, getConfigTokensRequestParametersSchema, getConfigTokensResponseSchema, getContactsRequestSchema, getContactsResponseSchema, getDefaultPagination, getDelegateAddressResponseSchema, getDelegateAddressSchema, getErrorMessage, getErrorMessageWithCode, getInstructionActivityRequestSchema, getInstructionActivityResponseSchema, getIntegrationRequestSchema, getMaxPriorityFeePerGasEstimateResponseSchema, getMaxPriorityFeePerGasEstimateSchema, getOperatingAccountSubOrgResponseSchema, getPaymentRequestsRequestSchema, getPaymentRequestsResponseSchema, getUserFriendlyErrorMessage, instructionActivateRequestSchema, instructionActivateResponseSchema, instructionBuildRequestSchema, instructionBuildSchema, instructionDeactivateRequestSchema, instructionDeactivateResponseSchema, instructionDetailsRequestSchema, instructionDetailsResponseSchema, instructionGetAllRequestSchema, instructionGetAllResponseSchema, instructionGetRulesRequestSchema, instructionGetRulesResponseSchema, integrationResponseSchema, integrationTypeSchema, integrationTypeValues, isFailure, isInstanceInit, isSuccess, isTechnicalError, isUserAddressableError, isUserRejectionError, meResponseSchema, newContactRequestSchema, newInstructionRequestSchema, newOperatingAccountSubOrgResponseSchema, orchestrationParamsSchema, orchestrationTypeSchema, paymentRequestBuildRequestSchema, paymentRequestBuildResponseSchema, paymentRequestDetailsRequestSchema, paymentRequestDetailsResponseSchema, paymentRequestNewRequestSchema, paymentRequestSchema, paymentRequestStatusSchema, paymentRequestsDirectionSchema, sessionTokenRequestSchema, sessionTokenResponseSchema, sessionVerifyResponseSchema, setChainIdSchema, settlementParamsSchema, success, transactionGetListRequestSchema, transactionGetListResponseSchema, turnkeyLoginRequestSchema, turnkeyLoginResponseSchema, turnkeyVerificationRequestSchema, turnkeyVerificationResponseSchema, updateIntegrationRequestSchema, vaultWithdrawSettlementParamsSchema, whitelistCheckRequestSchema, whitelistCheckResponseSchema };
+//# sourceMappingURL=index.mjs.map