@otim/utils 0.0.2-development.0

package/dist/api/index.js

@@ -0,0 +1,2061 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/api/index.ts
+var api_exports = {};
+__export(api_exports, {
+  APIClient: () => APIClient,
+  AccountService: () => AccountService,
+  ActivityService: () => ActivityService,
+  AuthService: () => AuthService,
+  ConfigService: () => ConfigService,
+  ContactsService: () => ContactsService,
+  DelegationStatus: () => DelegationStatus,
+  DeveloperService: () => DeveloperService,
+  HttpMethod: () => HttpMethod,
+  InstructionService: () => InstructionService,
+  IntegrationService: () => IntegrationService,
+  IntegrationType: () => IntegrationType,
+  OperatingAccountService: () => OperatingAccountService,
+  PaymentsService: () => PaymentsService,
+  ServiceError: () => ServiceError,
+  TransactionService: () => TransactionService,
+  UniswapTokenListService: () => UniswapTokenListService,
+  actionArgumentsResponseSchema: () => actionArgumentsResponseSchema,
+  actionArgumentsSchema: () => actionArgumentsSchema,
+  actionNameSchema: () => actionNameSchema,
+  activityDataSchema: () => activityDataSchema,
+  activityRecordSchema: () => activityRecordSchema,
+  addressWhitelistCheckRequestSchema: () => addressWhitelistCheckRequestSchema,
+  addressWhitelistCheckResponseSchema: () => addressWhitelistCheckResponseSchema,
+  apiErrorSchema: () => apiErrorSchema,
+  attestationSchema: () => attestationSchema,
+  authLoginRequestSchema: () => authLoginRequestSchema,
+  authLoginResponseSchema: () => authLoginResponseSchema,
+  buildEphemeralInstructionSchema: () => buildEphemeralInstructionSchema,
+  calculateHasMore: () => calculateHasMore,
+  chainIdSchema: () => chainIdSchema,
+  chainSuccessResponseSchema: () => chainSuccessResponseSchema,
+  contactSchema: () => contactSchema,
+  createAPIClient: () => createAPIClient,
+  createAbortController: () => createAbortController,
+  createInstance: () => createInstance,
+  delegationCreateRequestSchema: () => delegationCreateRequestSchema,
+  delegationCreateResponseSchema: () => delegationCreateResponseSchema,
+  delegationStatusRequestSchema: () => delegationStatusRequestSchema,
+  delegationStatusResponseSchema: () => delegationStatusResponseSchema,
+  delegationStatusSchema: () => delegationStatusSchema,
+  delegationStatusValues: () => delegationStatusValues,
+  errorResponseSchema: () => errorResponseSchema,
+  extractPaginationParams: () => extractPaginationParams,
+  feeResponseSchema: () => feeResponseSchema2,
+  getConfigChainsResponseSchema: () => getConfigChainsResponseSchema,
+  getConfigTokensRequestParametersSchema: () => getConfigTokensRequestParametersSchema,
+  getConfigTokensResponseSchema: () => getConfigTokensResponseSchema,
+  getContactsRequestSchema: () => getContactsRequestSchema,
+  getContactsResponseSchema: () => getContactsResponseSchema,
+  getCurrentUserResponseSchema: () => getCurrentUserResponseSchema,
+  getDefaultPagination: () => getDefaultPagination,
+  getDelegateAddressResponseSchema: () => getDelegateAddressResponseSchema,
+  getDelegateAddressSchema: () => getDelegateAddressSchema,
+  getErrorMessage: () => getErrorMessage,
+  getErrorMessageWithCode: () => getErrorMessageWithCode,
+  getInstructionActivityRequestSchema: () => getInstructionActivityRequestSchema,
+  getInstructionActivityResponseSchema: () => getInstructionActivityResponseSchema,
+  getIntegrationRequestSchema: () => getIntegrationRequestSchema,
+  getMaxPriorityFeePerGasEstimateResponseSchema: () => getMaxPriorityFeePerGasEstimateResponseSchema,
+  getMaxPriorityFeePerGasEstimateSchema: () => getMaxPriorityFeePerGasEstimateSchema,
+  getOperatingAccountSubOrgResponseSchema: () => getOperatingAccountSubOrgResponseSchema,
+  getPaymentRequestsRequestSchema: () => getPaymentRequestsRequestSchema,
+  getPaymentRequestsResponseSchema: () => getPaymentRequestsResponseSchema,
+  getUserFriendlyErrorMessage: () => getUserFriendlyErrorMessage,
+  instructionActivateRequestSchema: () => instructionActivateRequestSchema,
+  instructionActivateResponseSchema: () => instructionActivateResponseSchema,
+  instructionBuildRequestSchema: () => instructionBuildRequestSchema,
+  instructionBuildSchema: () => instructionBuildSchema,
+  instructionDeactivateRequestSchema: () => instructionDeactivateRequestSchema,
+  instructionDeactivateResponseSchema: () => instructionDeactivateResponseSchema,
+  instructionDetailsRequestSchema: () => instructionDetailsRequestSchema,
+  instructionDetailsResponseSchema: () => instructionDetailsResponseSchema,
+  instructionGetAllRequestSchema: () => instructionGetAllRequestSchema,
+  instructionGetAllResponseSchema: () => instructionGetAllResponseSchema,
+  instructionGetRulesRequestSchema: () => instructionGetRulesRequestSchema,
+  instructionGetRulesResponseSchema: () => instructionGetRulesResponseSchema,
+  integrationResponseSchema: () => integrationResponseSchema,
+  integrationTypeSchema: () => integrationTypeSchema,
+  integrationTypeValues: () => integrationTypeValues,
+  isInstanceInit: () => isInstanceInit,
+  isTechnicalError: () => isTechnicalError,
+  isUserAddressableError: () => isUserAddressableError,
+  isUserRejectionError: () => isUserRejectionError,
+  meResponseSchema: () => meResponseSchema,
+  newContactRequestSchema: () => newContactRequestSchema,
+  newInstructionRequestSchema: () => newInstructionRequestSchema,
+  newOperatingAccountSubOrgResponseSchema: () => newOperatingAccountSubOrgResponseSchema,
+  paymentRequestBuildRequestSchema: () => paymentRequestBuildRequestSchema,
+  paymentRequestBuildResponseSchema: () => paymentRequestBuildResponseSchema,
+  paymentRequestDetailsRequestSchema: () => paymentRequestDetailsRequestSchema,
+  paymentRequestDetailsResponseSchema: () => paymentRequestDetailsResponseSchema,
+  paymentRequestNewRequestSchema: () => paymentRequestNewRequestSchema,
+  paymentRequestSchema: () => paymentRequestSchema,
+  paymentRequestStatusSchema: () => paymentRequestStatusSchema,
+  paymentRequestsDirectionSchema: () => paymentRequestsDirectionSchema,
+  sessionTokenRequestSchema: () => sessionTokenRequestSchema,
+  sessionTokenResponseSchema: () => sessionTokenResponseSchema,
+  sessionVerifyResponseSchema: () => sessionVerifyResponseSchema,
+  setChainIdSchema: () => setChainIdSchema,
+  transactionGetListRequestSchema: () => transactionGetListRequestSchema,
+  transactionGetListResponseSchema: () => transactionGetListResponseSchema,
+  turnkeyLoginRequestSchema: () => turnkeyLoginRequestSchema,
+  turnkeyLoginResponseSchema: () => turnkeyLoginResponseSchema,
+  turnkeyVerificationRequestSchema: () => turnkeyVerificationRequestSchema,
+  turnkeyVerificationResponseSchema: () => turnkeyVerificationResponseSchema,
+  updateIntegrationRequestSchema: () => updateIntegrationRequestSchema,
+  whitelistCheckRequestSchema: () => whitelistCheckRequestSchema,
+  whitelistCheckResponseSchema: () => whitelistCheckResponseSchema
+});
+module.exports = __toCommonJS(api_exports);
+
+// src/api/core/error.ts
+var import_zod = require("zod");
+var apiErrorSchema = import_zod.z.object({
+  code: import_zod.z.string().nullish(),
+  message: import_zod.z.string().nullish(),
+  errorCode: import_zod.z.string().nullish(),
+  errorMessage: import_zod.z.string().nullish(),
+  status: import_zod.z.number().nullish(),
+  context: import_zod.z.object({
+    field_errors: import_zod.z.record(import_zod.z.string(), import_zod.z.string()).nullish()
+  }).nullish()
+});
+var errorResponseSchema = import_zod.z.object({
+  message: import_zod.z.string().nullish(),
+  errorMessage: import_zod.z.string().nullish(),
+  errorCode: import_zod.z.string().nullish(),
+  errors: import_zod.z.array(apiErrorSchema).nullish()
+});
+var defaultErrorCode = "unknown";
+var defaultErrorMessage = "Unexpected error";
+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;
+}
+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;
+}
+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
+  };
+}
+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));
+}
+var isUserAddressableError = (errorCode, errorMessage) => {
+  const isInUserErrorRange = errorCode >= 1e3 && errorCode < 2e3;
+  const hasErrorMessage = Boolean(errorMessage);
+  return isInUserErrorRange && hasErrorMessage;
+};
+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)
+  );
+}
+function getUserFriendlyErrorMessage(error, fallbackMessage) {
+  if (isTechnicalError(error)) {
+    return "Internal server error";
+  }
+  return getErrorMessage(error, fallbackMessage);
+}
+
+// src/api/core/instance.ts
+var import_axios = __toESM(require("axios"));
+var API_INSTANCE_DEFAULT_TIMEOUT = 3e4;
+var createInstance = (config) => {
+  const instance = import_axios.default.create({
+    timeout: API_INSTANCE_DEFAULT_TIMEOUT,
+    ...config
+  });
+  return instance;
+};
+var createAbortController = () => {
+  return new AbortController();
+};
+var isInstanceInit = (init) => {
+  return !!init && typeof init === "object" && "instance" in init;
+};
+
+// src/api/core/service.ts
+var ServiceError = class extends Error {
+  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
+var import_zod2 = require("zod");
+var DelegationStatus = {
+  Undelegated: "Undelegated",
+  Pending: "Pending",
+  Delegated: "Delegated",
+  Expired: "Expired",
+  Errored: "Errored"
+};
+var delegationStatusValues = Object.values(DelegationStatus);
+var delegationStatusSchema = import_zod2.z.enum(delegationStatusValues);
+var delegationStatusRequestSchema = import_zod2.z.object({
+  address: import_zod2.z.string(),
+  chainId: import_zod2.z.number()
+});
+var delegationStatusResponseSchema = import_zod2.z.object({
+  delegationStatus: delegationStatusSchema
+});
+var delegationCreateRequestSchema = import_zod2.z.object({
+  signedAuthorization: import_zod2.z.string(),
+  signerAddress: import_zod2.z.string()
+});
+var delegationCreateResponseSchema = import_zod2.z.object({
+  success: import_zod2.z.boolean(),
+  transactionHash: import_zod2.z.string().optional(),
+  message: import_zod2.z.string().optional()
+});
+
+// src/api/schemas/activity.ts
+var import_zod8 = require("zod");
+
+// src/schemas/instruction.ts
+var import_zod4 = require("zod");
+
+// src/schemas/misc.ts
+var import_zod3 = require("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) => import_zod3.z.string().regex(regex, message);
+var nonEmptyStringSchema = import_zod3.z.string().min(1);
+var numberSchema = import_zod3.z.union([
+  import_zod3.z.number().finite(),
+  import_zod3.z.string().regex(/^-?\d*\.?\d+(?:[eE][-+]?\d+)?$/).transform(Number)
+]);
+var decimalStringSchema = import_zod3.z.string().regex(/^-?\d*\.?\d+$/).refine((val) => !isNaN(parseFloat(val)), {
+  message: "Must be a valid decimal number"
+});
+var bigintSchema = import_zod3.z.union([
+  import_zod3.z.bigint(),
+  import_zod3.z.string().regex(/^-?\d+$/).transform(BigInt)
+]);
+var hexStringSchema = import_zod3.z.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"
+};
+var sortValues = Object.values(Sort);
+var vrsSchema = import_zod3.z.object({
+  v: import_zod3.z.number(),
+  r: import_zod3.z.string(),
+  s: import_zod3.z.string()
+});
+var eip2098SignatureSchema = import_zod3.z.object({
+  yParity: import_zod3.z.number(),
+  r: import_zod3.z.string(),
+  s: import_zod3.z.string()
+});
+
+// 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"
+};
+var instructionStateValues = Object.values(InstructionState);
+var instructionStateSchema = import_zod4.z.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"
+};
+var instructionActionValues = Object.values(InstructionAction);
+var instructionActionSchema = import_zod4.z.enum(instructionActionValues);
+var InstructionScheduleStartType = {
+  Now: "now",
+  DateTime: "datetime"
+};
+var instructionScheduleStartValues = Object.values(
+  InstructionScheduleStartType
+);
+var baseStartSchema = import_zod4.z.object({
+  type: import_zod4.z.enum(instructionScheduleStartValues)
+});
+var nowStartSchema = baseStartSchema.extend({
+  type: import_zod4.z.literal(InstructionScheduleStartType.Now)
+});
+var dateTimeStartSchema = baseStartSchema.extend({
+  type: import_zod4.z.literal(InstructionScheduleStartType.DateTime),
+  startDate: dateStandardSchema,
+  startTime: import_zod4.z.string()
+});
+var instructionScheduleStartSchema = import_zod4.z.discriminatedUnion("type", [
+  nowStartSchema,
+  dateTimeStartSchema
+]);
+var InstructionScheduleRepeatType = {
+  UntilDeactivated: "until-deactivated",
+  MaxExecutions: "max-executions"
+};
+var instructionScheduleRepeatValues = Object.values(
+  InstructionScheduleRepeatType
+);
+var baseRepeatSchema = import_zod4.z.object({});
+var untilDeactivatedRepeatSchema = baseRepeatSchema.extend({
+  type: import_zod4.z.literal(InstructionScheduleRepeatType.UntilDeactivated)
+});
+var maxExecutionsRepeatSchema = baseRepeatSchema.extend({
+  type: import_zod4.z.literal(InstructionScheduleRepeatType.MaxExecutions),
+  maxExecutions: numberSchema
+});
+var instructionScheduleRepeatSchema = import_zod4.z.discriminatedUnion("type", [
+  untilDeactivatedRepeatSchema,
+  maxExecutionsRepeatSchema
+]);
+var InstructionScheduleRetryType = {
+  UntilDeactivated: "until-deactivated",
+  TimeLimited: "time-limited"
+};
+var instructionScheduleRetryValues = Object.values(
+  InstructionScheduleRetryType
+);
+var baseRetrySchema = import_zod4.z.object({});
+var untilDeactivatedRetrySchema = baseRetrySchema.extend({
+  type: import_zod4.z.literal(InstructionScheduleRetryType.UntilDeactivated)
+});
+var timeLimitedRetrySchema = baseRetrySchema.extend({
+  type: import_zod4.z.literal(InstructionScheduleRetryType.TimeLimited),
+  retryCount: numberSchema
+});
+var instructionScheduleRetrySchema = import_zod4.z.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 = import_zod4.z.enum(timeUnitValues);
+var instructionExecutionStateSchema = import_zod4.z.object({
+  executionStatus: instructionStateSchema.optional(),
+  executionCounter: import_zod4.z.number().int().optional(),
+  lastExecuted: import_zod4.z.number().int().optional()
+});
+var instructionSchema = import_zod4.z.object({
+  instructionId: hexStringSchema,
+  createdAt: import_zod4.z.number().optional(),
+  startAt: import_zod4.z.string().nullish(),
+  interval: import_zod4.z.number().nullish(),
+  timeout: import_zod4.z.number().nullish(),
+  maxExecutions: import_zod4.z.number().nullish(),
+  executionState: instructionExecutionStateSchema.optional(),
+  actionName: import_zod4.z.string().optional(),
+  arguments: import_zod4.z.any(),
+  nickname: import_zod4.z.string().nullish(),
+  lastInstructedValue: import_zod4.z.string().optional(),
+  lastErrorCode: import_zod4.z.number().nullish(),
+  lastErrorMessage: import_zod4.z.string().nullish(),
+  totalInstructedValue: import_zod4.z.string().optional(),
+  instructedTokenAddress: hexStringSchema.nullish(),
+  chainId: import_zod4.z.number().nullish(),
+  chain: import_zod4.z.string().optional()
+});
+var instructionsSchema = import_zod4.z.array(instructionSchema);
+var instructionSummarySchema = import_zod4.z.object({
+  instructionId: hexStringSchema,
+  chainId: import_zod4.z.number().int(),
+  executionCount: import_zod4.z.number().int(),
+  onTimeCount: import_zod4.z.number().int(),
+  lateCount: import_zod4.z.number().int(),
+  wasActivatedDuring: import_zod4.z.boolean(),
+  amount: import_zod4.z.number().default(0),
+  instructedValue: import_zod4.z.string().nullish().default("0"),
+  instructedTokenAddress: import_zod4.z.string().nullish().default(null)
+});
+var instructionSummariesSchema = import_zod4.z.array(instructionSummarySchema);
+var instructionSummariesByDateSchema = import_zod4.z.record(
+  import_zod4.z.string(),
+  instructionSummariesSchema
+);
+var InstructionViewTimescale = {
+  Days: "days",
+  Hours: "hours",
+  Minutes: "minutes",
+  Seconds: "seconds"
+};
+var instructionViewTimescaleValues = Object.values(
+  InstructionViewTimescale
+);
+
+// src/schemas/payment.ts
+var import_zod5 = require("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 = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  fromUserId: import_zod5.z.string().nullable().optional(),
+  toUserId: import_zod5.z.string().nullable().optional(),
+  payerAddress: import_zod5.z.string().nullable().optional(),
+  ephemeralWalletAddress: import_zod5.z.string(),
+  ephemeralWalletId: import_zod5.z.string().optional(),
+  instructions: import_zod5.z.object({
+    ids: import_zod5.z.array(import_zod5.z.string()),
+    completionIds: import_zod5.z.array(import_zod5.z.string())
+  }).optional(),
+  metadata: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.unknown()).optional(),
+  // UI-derived fields
+  status: import_zod5.z.union([
+    import_zod5.z.literal(PaymentStatus.Due),
+    import_zod5.z.literal(PaymentStatus.NotDue),
+    import_zod5.z.literal(PaymentStatus.Paid)
+  ]),
+  dueDate: import_zod5.z.string(),
+  amountDue: import_zod5.z.number(),
+  note: import_zod5.z.string().nullable().optional(),
+  address: import_zod5.z.string().nullable().optional(),
+  addedOn: import_zod5.z.string(),
+  source: import_zod5.z.union([
+    import_zod5.z.literal(PaymentSource.Bill),
+    import_zod5.z.literal(PaymentSource.Stripe),
+    import_zod5.z.literal(PaymentSource.Clio),
+    import_zod5.z.literal(PaymentSource.QuickBooks)
+  ]).nullish(),
+  attachmentUrl: import_zod5.z.string().url().nullable().optional(),
+  attachmentName: import_zod5.z.string().nullable().optional(),
+  fromAccountAddress: import_zod5.z.string().nullable().optional()
+});
+var PaymentsSchema = import_zod5.z.array(paymentSchema);
+
+// src/schemas/transaction.ts
+var import_zod6 = require("zod");
+var transactionSchema = import_zod6.z.object({
+  instructionId: instructionIdSchema,
+  transactionHash: hexStringSchema.optional(),
+  blockHash: import_zod6.z.string().nullable(),
+  transactionStatus: import_zod6.z.string(),
+  error: import_zod6.z.string().nullish(),
+  startedAt: import_zod6.z.string(),
+  startedAtBlock: import_zod6.z.number(),
+  finishedAt: import_zod6.z.string().nullable(),
+  finishedAtBlock: import_zod6.z.number().nullable(),
+  amount: import_zod6.z.object({ value: import_zod6.z.number(), token: import_zod6.z.string() }).nullish(),
+  instructedValue: import_zod6.z.string(),
+  instructedTokenAddress: import_zod6.z.string().nullable(),
+  executionNum: import_zod6.z.number(),
+  chainId: import_zod6.z.number().nullish(),
+  chain: import_zod6.z.string().optional()
+});
+var transactionWithValidAmountSchema = transactionSchema.extend({
+  amount: import_zod6.z.object({
+    value: import_zod6.z.number(),
+    token: import_zod6.z.string()
+  })
+});
+var transactionsSchema = import_zod6.z.array(transactionSchema);
+
+// src/schemas/user.ts
+var import_zod7 = require("zod");
+var entityIdSchema = import_zod7.z.string().uuid();
+var addressSchema = import_zod7.z.string().regex(/^0x[a-fA-F0-9]{40}$/).transform((v) => v.toLowerCase());
+var userPreferencesSchema = import_zod7.z.object({
+  chainId: import_zod7.z.number().optional(),
+  tokenSymbol: import_zod7.z.string().optional(),
+  localCurrency: import_zod7.z.string().optional()
+});
+var userSchema = import_zod7.z.object({
+  id: entityIdSchema,
+  address: addressSchema,
+  createdAt: import_zod7.z.string(),
+  updatedAt: import_zod7.z.string(),
+  preferences: userPreferencesSchema.optional(),
+  isDeveloper: import_zod7.z.boolean(),
+  developerPublicKey: import_zod7.z.string().nullable().optional()
+});
+
+// src/api/schemas/activity.ts
+var actionNameSchema = import_zod8.z.enum([
+  "refuel",
+  "transfer",
+  "refuelERC20",
+  "transferERC20",
+  "uniswapV3ExactInput",
+  "deactivateInstruction",
+  "sweepCCTP",
+  "transferCCTP",
+  "sweep",
+  "sweepERC20",
+  "sweepUniswapV3",
+  "depositERC4626",
+  "sweepDepositERC4626",
+  "withdrawERC4626",
+  "sweepWithdrawERC4626",
+  "callOnce"
+]);
+var transferFieldsSchema = import_zod8.z.object({
+  token: hexStringSchema,
+  from: hexStringSchema,
+  to: hexStringSchema,
+  value: hexStringSchema
+});
+var swapFieldsSchema = import_zod8.z.object({
+  poolAddress: hexStringSchema,
+  fromToken: hexStringSchema,
+  toToken: hexStringSchema,
+  from: hexStringSchema,
+  to: hexStringSchema,
+  fromAmount: hexStringSchema,
+  toAmount: hexStringSchema
+});
+var cctpBurnFieldsSchema = import_zod8.z.object({
+  token: hexStringSchema,
+  from: hexStringSchema,
+  mintRecipient: hexStringSchema,
+  destinationDomain: hexStringSchema,
+  value: hexStringSchema
+});
+var erc4626DepositFieldsSchema = import_zod8.z.object({
+  vault: hexStringSchema,
+  token: hexStringSchema,
+  from: hexStringSchema,
+  owner: hexStringSchema,
+  value: hexStringSchema,
+  shares: hexStringSchema
+});
+var erc4626WithdrawFieldsSchema = import_zod8.z.object({
+  vault: hexStringSchema,
+  token: hexStringSchema,
+  from: hexStringSchema,
+  to: hexStringSchema,
+  value: hexStringSchema,
+  shares: hexStringSchema
+});
+var activityDataSchema = import_zod8.z.union([
+  import_zod8.z.object({ transfer: transferFieldsSchema }),
+  import_zod8.z.object({ swap: swapFieldsSchema }),
+  import_zod8.z.object({ cctpBurn: cctpBurnFieldsSchema }),
+  import_zod8.z.object({ erc4626Deposit: erc4626DepositFieldsSchema }),
+  import_zod8.z.object({ erc4626Withdraw: erc4626WithdrawFieldsSchema })
+]);
+var activityRecordSchema = import_zod8.z.object({
+  actionName: actionNameSchema,
+  blockTimestamp: numberSchema,
+  transactionHash: hexStringSchema,
+  activity: activityDataSchema,
+  instructionId: hexStringSchema.nullable(),
+  executionCount: import_zod8.z.number().nullable()
+});
+var getInstructionActivityRequestSchema = import_zod8.z.object({
+  chainId: import_zod8.z.number(),
+  actionNames: import_zod8.z.array(actionNameSchema),
+  page: numberSchema.optional(),
+  perPage: numberSchema.optional()
+});
+var getInstructionActivityResponseSchema = import_zod8.z.array(activityRecordSchema);
+
+// src/api/schemas/auth.ts
+var import_zod9 = require("zod");
+var authLoginRequestSchema = import_zod9.z.object({
+  siwe: import_zod9.z.string(),
+  signature: vrsSchema
+});
+var authLoginResponseSchema = import_zod9.z.object({
+  authorization: import_zod9.z.string(),
+  user: userSchema
+});
+var turnkeyVerificationRequestSchema = import_zod9.z.object({
+  email: import_zod9.z.string().email()
+});
+var turnkeyVerificationResponseSchema = import_zod9.z.object({
+  isLogin: import_zod9.z.boolean()
+});
+var attestationSchema = import_zod9.z.object({
+  credentialId: import_zod9.z.string(),
+  clientDataJson: import_zod9.z.string(),
+  attestationObject: import_zod9.z.string(),
+  transports: import_zod9.z.array(import_zod9.z.string()).optional()
+});
+var turnkeyLoginRequestSchema = import_zod9.z.object({
+  email: import_zod9.z.email(),
+  verificationCode: import_zod9.z.coerce.number().int().min(1e5).max(999999),
+  passkeyChallenge: import_zod9.z.string().optional(),
+  attestation: attestationSchema.optional()
+});
+var turnkeyLoginResponseSchema = import_zod9.z.object({
+  email: import_zod9.z.string(),
+  subOrgId: import_zod9.z.string(),
+  walletAddress: import_zod9.z.string(),
+  isLogin: import_zod9.z.boolean().optional()
+});
+var meResponseSchema = userSchema;
+var sessionTokenRequestSchema = import_zod9.z.object({
+  sessionToken: import_zod9.z.string()
+});
+var sessionTokenResponseSchema = import_zod9.z.object({
+  success: import_zod9.z.boolean()
+});
+var sessionVerifyResponseSchema = import_zod9.z.object({
+  authenticated: import_zod9.z.boolean(),
+  hasSessionToken: import_zod9.z.boolean()
+});
+var whitelistCheckRequestSchema = import_zod9.z.object({
+  email: import_zod9.z.string().email()
+});
+var whitelistCheckResponseSchema = import_zod9.z.object({
+  isAllowed: import_zod9.z.boolean(),
+  message: import_zod9.z.string().optional()
+});
+var addressWhitelistCheckRequestSchema = import_zod9.z.object({
+  address: import_zod9.z.string()
+});
+var addressWhitelistCheckResponseSchema = import_zod9.z.object({
+  isAllowed: import_zod9.z.boolean(),
+  message: import_zod9.z.string().optional()
+});
+var getCurrentUserResponseSchema = import_zod9.z.object({
+  data: userSchema
+});
+
+// src/api/schemas/chain.ts
+var import_zod10 = require("zod");
+var chainIdSchema = import_zod10.z.object({
+  chainId: import_zod10.z.number().nullable()
+});
+var setChainIdSchema = import_zod10.z.object({
+  chainId: import_zod10.z.number().positive()
+});
+var chainSuccessResponseSchema = import_zod10.z.object({
+  success: import_zod10.z.boolean(),
+  chainId: import_zod10.z.number().optional()
+});
+
+// src/api/schemas/config.ts
+var import_zod11 = require("zod");
+var getDelegateAddressSchema = import_zod11.z.object({
+  chainId: import_zod11.z.number()
+});
+var getDelegateAddressResponseSchema = import_zod11.z.object({
+  otimDelegateAddress: import_zod11.z.string()
+});
+var getConfigTokensRequestParametersSchema = import_zod11.z.object({
+  chainId: import_zod11.z.number()
+});
+var getConfigTokensResponseSchema = import_zod11.z.object({
+  tokens: import_zod11.z.array(
+    import_zod11.z.object({
+      symbol: import_zod11.z.any(),
+      address: hexStringSchema
+    })
+  )
+});
+var getConfigChainsResponseSchema = import_zod11.z.unknown();
+var getMaxPriorityFeePerGasEstimateSchema = import_zod11.z.object({
+  chainId: import_zod11.z.number()
+});
+var getMaxPriorityFeePerGasEstimateResponseSchema = import_zod11.z.object({
+  slowMaxPriorityFeeEstimate: import_zod11.z.number(),
+  normalMaxPriorityFeeEstimate: import_zod11.z.number(),
+  fastMaxPriorityFeeEstimate: import_zod11.z.number()
+});
+
+// src/api/schemas/contacts.ts
+var import_zod12 = require("zod");
+var newContactRequestSchema = import_zod12.z.object({
+  address: hexStringSchema,
+  name: import_zod12.z.string()
+});
+var getContactsRequestSchema = import_zod12.z.object({
+  perPage: numberSchema.optional(),
+  page: numberSchema.optional()
+});
+var contactSchema = import_zod12.z.object({
+  userId: import_zod12.z.string(),
+  address: hexStringSchema,
+  name: import_zod12.z.string(),
+  createdAt: import_zod12.z.string(),
+  updatedAt: import_zod12.z.string()
+});
+var getContactsResponseSchema = import_zod12.z.array(contactSchema);
+
+// src/api/schemas/instruction.ts
+var import_zod13 = require("zod");
+var feeSchema = import_zod13.z.object({
+  executionFee: hexStringSchema,
+  maxBaseFeePerGas: hexStringSchema,
+  maxPriorityFeePerGas: hexStringSchema,
+  token: hexStringSchema
+});
+var scheduleSchema = import_zod13.z.object({
+  startAt: numberSchema,
+  startBy: numberSchema,
+  interval: numberSchema,
+  timeout: numberSchema
+});
+var baseActionArgumentsSchema = import_zod13.z.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 = import_zod13.z.object({
+  tokenIn: hexStringSchema,
+  tokenOut: hexStringSchema,
+  amountIn: numberSchema,
+  floorAmountOut: numberSchema,
+  feeTier: import_zod13.z.string(),
+  recipient: hexStringSchema,
+  meanPriceLookBack: numberSchema,
+  maxPriceDeviationBps: numberSchema,
+  fee: feeSchema,
+  schedule: scheduleSchema
+});
+var deactivateInstructionActionArgumentsSchema = import_zod13.z.object({
+  instructionId: hexStringSchema,
+  fee: feeSchema
+});
+var actionArgumentsSchema = import_zod13.z.union([
+  refuelActionArgumentsSchema,
+  refuelERC20ActionArgumentsSchema,
+  transferActionArgumentsSchema,
+  transferERC20ActionArgumentsSchema,
+  sweepDepositAccountActionArgumentsSchema,
+  sweepDepositAccountERC20ActionArgumentsSchema,
+  uniswapV3ExactInputActionArgumentsSchema,
+  deactivateInstructionActionArgumentsSchema
+]);
+var feeResponseSchema = import_zod13.z.object({
+  token: hexStringSchema,
+  executionFee: hexStringSchema,
+  maxBaseFeePerGas: hexStringSchema,
+  maxPriorityFeePerGas: hexStringSchema
+});
+var scheduleResponseSchema = import_zod13.z.object({
+  startAt: hexStringSchema,
+  startBy: hexStringSchema,
+  interval: hexStringSchema,
+  timeout: hexStringSchema
+});
+var refuelActionResponseSchema = import_zod13.z.object({
+  target: hexStringSchema,
+  threshold: hexStringSchema,
+  endBalance: hexStringSchema,
+  gasLimit: hexStringSchema,
+  fee: feeResponseSchema
+});
+var transferActionResponseSchema = import_zod13.z.object({
+  target: hexStringSchema,
+  value: hexStringSchema,
+  gasLimit: hexStringSchema,
+  schedule: scheduleResponseSchema,
+  fee: feeResponseSchema
+});
+var refuelERC20ActionResponseSchema = import_zod13.z.object({
+  token: hexStringSchema,
+  target: hexStringSchema,
+  threshold: hexStringSchema,
+  endBalance: hexStringSchema,
+  fee: feeResponseSchema
+});
+var transferERC20ActionResponseSchema = import_zod13.z.object({
+  token: hexStringSchema,
+  target: hexStringSchema,
+  value: hexStringSchema,
+  schedule: scheduleResponseSchema,
+  fee: feeResponseSchema
+});
+var actionArgumentsResponseSchema = import_zod13.z.union([
+  refuelActionResponseSchema,
+  transferActionResponseSchema,
+  refuelERC20ActionResponseSchema,
+  transferERC20ActionResponseSchema
+]);
+var instructionBuildSchema = import_zod13.z.object({
+  action: hexStringSchema,
+  arguments: hexStringSchema,
+  maxExecutions: hexStringSchema,
+  salt: hexStringSchema,
+  nickname: import_zod13.z.string().nullish()
+});
+var instructionGetAllRequestSchema = import_zod13.z.object({
+  address: hexStringSchema,
+  chainId: import_zod13.z.number(),
+  page: import_zod13.z.number().optional(),
+  perPage: import_zod13.z.number().optional()
+});
+var instructionGetAllResponseSchema = import_zod13.z.array(instructionSchema);
+var instructionBuildRequestSchema = import_zod13.z.object({
+  address: hexStringSchema,
+  chainId: import_zod13.z.number(),
+  salt: import_zod13.z.number(),
+  maxExecutions: import_zod13.z.number(),
+  actionArguments: import_zod13.z.record(import_zod13.z.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 = import_zod13.z.object({
+  nickname: import_zod13.z.string().optional(),
+  address: hexStringSchema,
+  chainId: import_zod13.z.number(),
+  salt: hexStringSchema,
+  maxExecutions: hexStringSchema,
+  action: hexStringSchema,
+  arguments: hexStringSchema,
+  activationSignature: eip2098SignatureSchema
+});
+var instructionActivateResponseSchema = import_zod13.z.object({
+  instructionId: hexStringSchema
+});
+var instructionDeactivateRequestSchema = import_zod13.z.object({
+  address: hexStringSchema,
+  chainId: import_zod13.z.number(),
+  deactivation: import_zod13.z.object({
+    instructionId: hexStringSchema
+  }),
+  deactivationSignature: eip2098SignatureSchema
+});
+var instructionDeactivateResponseSchema = import_zod13.z.unknown();
+var instructionDetailsRequestSchema = import_zod13.z.object({
+  address: hexStringSchema,
+  instructionId: hexStringSchema,
+  chainId: import_zod13.z.number()
+});
+var instructionDetailsResponseSchema = import_zod13.z.object({
+  action: hexStringSchema,
+  actionArguments: import_zod13.z.any(),
+  actionName: import_zod13.z.string().nullish(),
+  salt: hexStringSchema,
+  maxExecutions: hexStringSchema,
+  nickname: import_zod13.z.string().nullish(),
+  lastErrorCode: import_zod13.z.number().int(),
+  lastErrorMessage: import_zod13.z.string().nullish()
+});
+var instructionGetRulesRequestSchema = import_zod13.z.object({
+  chainId: import_zod13.z.number(),
+  page: import_zod13.z.number().optional(),
+  perPage: import_zod13.z.number().optional()
+});
+var instructionGetRulesResponseSchema = import_zod13.z.array(
+  instructionSchema
+);
+
+// src/api/schemas/integration.ts
+var import_zod14 = require("zod");
+var 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
+];
+var quickBooksDetailsSchema = import_zod14.z.object({
+  accessToken: import_zod14.z.string().optional(),
+  refreshToken: import_zod14.z.string().optional(),
+  realmId: import_zod14.z.string().optional(),
+  tokenType: import_zod14.z.string().optional(),
+  expiresIn: import_zod14.z.number().optional(),
+  xRefreshTokenExpiresIn: import_zod14.z.number().optional()
+});
+var stripeTokensSchema = import_zod14.z.object({
+  accessToken: import_zod14.z.string(),
+  refreshToken: import_zod14.z.string().optional()
+});
+var stripeDetailsSchema = import_zod14.z.object({
+  clientId: import_zod14.z.string().optional(),
+  clientSecret: import_zod14.z.string().optional(),
+  tokens: stripeTokensSchema.optional()
+});
+var billcomDetailsSchema = import_zod14.z.object({
+  devKey: import_zod14.z.string().optional(),
+  sessionId: import_zod14.z.string().optional(),
+  orgId: import_zod14.z.string().optional(),
+  rememberMeId: import_zod14.z.string().optional()
+});
+var liquidationAddressSchema = import_zod14.z.object({
+  liquidationAddressId: import_zod14.z.string(),
+  address: import_zod14.z.string(),
+  chain: import_zod14.z.string(),
+  currency: import_zod14.z.string(),
+  blockchainMemo: import_zod14.z.string().optional()
+});
+var plaidAccountSchema = import_zod14.z.object({
+  accountId: import_zod14.z.string(),
+  name: import_zod14.z.string().optional(),
+  mask: import_zod14.z.string().optional(),
+  subtype: import_zod14.z.string().optional(),
+  externalAccountId: import_zod14.z.string().optional(),
+  liquidationAddress: liquidationAddressSchema.optional()
+});
+var plaidConnectionSchema = import_zod14.z.object({
+  accessToken: import_zod14.z.string(),
+  itemId: import_zod14.z.string(),
+  institutionId: import_zod14.z.string().optional(),
+  institutionName: import_zod14.z.string().optional(),
+  accounts: import_zod14.z.array(plaidAccountSchema)
+});
+var bridgeConnectionSchema = import_zod14.z.object({
+  customerId: import_zod14.z.string(),
+  kycLinkId: import_zod14.z.string().optional(),
+  kycLink: import_zod14.z.string().optional(),
+  tosLink: import_zod14.z.string().optional(),
+  completedSteps: import_zod14.z.array(import_zod14.z.string()).optional()
+});
+var bankDetailsSchema = import_zod14.z.object({
+  plaid: import_zod14.z.array(plaidConnectionSchema).optional(),
+  bridge: import_zod14.z.array(bridgeConnectionSchema).optional()
+});
+var integrationTypeSchema = import_zod14.z.enum(integrationTypeValues);
+var updateIntegrationRequestSchema = import_zod14.z.discriminatedUnion(
+  "integrationType",
+  [
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.QuickBooks),
+      details: quickBooksDetailsSchema
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Bank),
+      details: bankDetailsSchema
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Clio),
+      details: import_zod14.z.unknown()
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Stripe),
+      details: stripeDetailsSchema
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Bill),
+      details: billcomDetailsSchema
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Zoho),
+      details: import_zod14.z.unknown()
+    })
+  ]
+);
+var getIntegrationRequestSchema = import_zod14.z.object({
+  integrationType: integrationTypeSchema
+});
+var integrationResponseSchema = import_zod14.z.discriminatedUnion(
+  "integrationType",
+  [
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.QuickBooks),
+      details: quickBooksDetailsSchema
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Bank),
+      details: bankDetailsSchema
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Clio),
+      details: import_zod14.z.unknown()
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Stripe),
+      details: stripeDetailsSchema
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Bill),
+      details: billcomDetailsSchema
+    }),
+    import_zod14.z.object({
+      integrationType: import_zod14.z.literal(IntegrationType.Zoho),
+      details: import_zod14.z.unknown()
+    })
+  ]
+);
+
+// src/api/schemas/operating-account.ts
+var import_zod15 = require("zod");
+var newOperatingAccountSubOrgResponseSchema = import_zod15.z.object({
+  subOrganizationId: import_zod15.z.string(),
+  endUserId: import_zod15.z.string()
+});
+var getOperatingAccountSubOrgResponseSchema = import_zod15.z.object({
+  subOrganizationId: import_zod15.z.string()
+});
+
+// src/api/schemas/payments.ts
+var import_zod16 = require("zod");
+var paymentRequestsDirectionSchema = import_zod16.z.enum(["from", "to"]);
+var getPaymentRequestsRequestSchema = import_zod16.z.object({
+  direction: paymentRequestsDirectionSchema,
+  statuses: import_zod16.z.array(import_zod16.z.enum(["pending", "inProgress", "paid", "cancelled", "draft"])).optional(),
+  perPage: numberSchema.optional(),
+  page: numberSchema.optional()
+});
+var paymentRequestStatusSchema = import_zod16.z.enum([
+  "pending",
+  "inProgress",
+  "paid",
+  "cancelled",
+  "draft"
+]);
+var paymentRequestSchema = import_zod16.z.object({
+  id: import_zod16.z.string(),
+  fromUserId: import_zod16.z.string(),
+  toUserId: import_zod16.z.string().nullable(),
+  payerAddress: hexStringSchema.nullable(),
+  ephemeralWalletAddress: hexStringSchema,
+  instructions: import_zod16.z.object({
+    ids: import_zod16.z.array(import_zod16.z.string()),
+    completionIds: import_zod16.z.array(import_zod16.z.string())
+  }),
+  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()),
+  status: paymentRequestStatusSchema,
+  createdAt: import_zod16.z.string(),
+  updatedAt: import_zod16.z.string()
+});
+var getPaymentRequestsResponseSchema = import_zod16.z.array(paymentRequestSchema);
+var buildEphemeralInstructionSchema = import_zod16.z.object({
+  chainId: import_zod16.z.number(),
+  salt: numberSchema,
+  maxExecutions: numberSchema,
+  actionArguments: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()),
+  setEphemeralTarget: import_zod16.z.boolean().optional()
+});
+var paymentRequestBuildRequestSchema = import_zod16.z.object({
+  payerAddress: hexStringSchema.nullish(),
+  completionInstructions: import_zod16.z.array(buildEphemeralInstructionSchema),
+  instructions: import_zod16.z.array(buildEphemeralInstructionSchema),
+  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown()).optional().default({})
+});
+var feeResponseSchema2 = import_zod16.z.object({
+  token: hexStringSchema,
+  executionFee: hexStringSchema,
+  maxBaseFeePerGas: hexStringSchema,
+  maxPriorityFeePerGas: hexStringSchema
+});
+var buildInstructionResponseSchema = import_zod16.z.object({
+  address: hexStringSchema,
+  chainId: import_zod16.z.number(),
+  salt: hexStringSchema,
+  maxExecutions: hexStringSchema,
+  action: hexStringSchema,
+  arguments: hexStringSchema
+});
+var paymentRequestBuildResponseSchema = import_zod16.z.object({
+  requestId: import_zod16.z.string(),
+  subOrgId: import_zod16.z.string(),
+  walletId: import_zod16.z.string(),
+  ephemeralWalletAddress: hexStringSchema,
+  completionInstructions: import_zod16.z.array(buildInstructionResponseSchema),
+  instructions: import_zod16.z.array(buildInstructionResponseSchema)
+});
+var newInstructionRequestSchema = import_zod16.z.object({
+  nickname: import_zod16.z.string().optional(),
+  address: hexStringSchema,
+  chainId: import_zod16.z.number(),
+  salt: hexStringSchema,
+  maxExecutions: hexStringSchema,
+  action: hexStringSchema,
+  arguments: hexStringSchema,
+  activationSignature: eip2098SignatureSchema
+});
+var paymentRequestNewRequestSchema = import_zod16.z.object({
+  requestId: import_zod16.z.string(),
+  signedAuthorization: import_zod16.z.string(),
+  completionInstructions: import_zod16.z.array(newInstructionRequestSchema),
+  instructions: import_zod16.z.array(newInstructionRequestSchema)
+});
+var paymentRequestDetailsRequestSchema = import_zod16.z.object({
+  requestId: import_zod16.z.string()
+});
+var paymentRequestDetailsResponseSchema = import_zod16.z.object({
+  requestId: import_zod16.z.string(),
+  ephemeralWalletAddress: hexStringSchema,
+  ephemeralWalletId: import_zod16.z.string().optional(),
+  status: import_zod16.z.enum(["pending", "inProgress", "paid", "cancelled", "draft"]),
+  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.unknown())
+});
+
+// src/api/schemas/transaction.ts
+var import_zod17 = require("zod");
+var transactionGetListRequestSchema = import_zod17.z.object({
+  address: hexStringSchema,
+  chainId: import_zod17.z.number(),
+  instructionIds: import_zod17.z.array(import_zod17.z.string()).optional(),
+  from: import_zod17.z.string().optional(),
+  to: import_zod17.z.string().optional(),
+  page: import_zod17.z.number().optional(),
+  perPage: import_zod17.z.number().optional(),
+  sort: import_zod17.z.enum(sortValues).optional()
+});
+var transactionGetListResponseSchema = import_zod17.z.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
+var import_zod18 = require("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;
+};
+
+// src/api/utils/pagination.ts
+function calculateHasMore(items, requestedPageSize) {
+  return items.length >= requestedPageSize;
+}
+function extractPaginationParams(request) {
+  const { page, perPage, ...restParams } = request;
+  return {
+    paginationParams: { page, perPage },
+    restParams
+  };
+}
+function getDefaultPagination() {
+  return {
+    page: 0,
+    perPage: 100
+  };
+}
+
+// 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
+    };
+  }
+};
+
+// 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" }
+    };
+  }
+};
+
+// src/api/services/activity.ts
+var import_zod19 = require("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;
+};
+var safeActivityArraySchema = import_zod19.z.unknown().transform(safeParseActivityArray);
+var ActivityService = class extends BaseService {
+  async getInstructionActivity(requestBody) {
+    return this.makePaginatedRequest({
+      url: "/instructions/activity",
+      method: HttpMethod.Get,
+      data: requestBody,
+      schema: safeActivityArraySchema
+    });
+  }
+};
+
+// 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;
+  }
+};
+
+// 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;
+  }
+};
+
+// 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
+    });
+  }
+};
+
+// 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
+    });
+  }
+};
+
+// 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
+    });
+  }
+};
+
+// 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
+    });
+  }
+};
+
+// 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: "/payment/request/build",
+      method: HttpMethod.Post,
+      data: requestBody,
+      schema: paymentRequestBuildResponseSchema
+    });
+  }
+  async newPaymentRequest(requestBody) {
+    return this.makeRequest({
+      url: "/payment/request/new",
+      method: HttpMethod.Post,
+      data: requestBody,
+      validateResponse: () => true
+    });
+  }
+  async getPaymentRequestDetails(requestBody) {
+    return this.makeRequest({
+      url: "/payment/request/details",
+      method: HttpMethod.Get,
+      data: requestBody,
+      schema: paymentRequestDetailsResponseSchema
+    });
+  }
+  async getPaymentRequests(request) {
+    return this.makePaginatedRequest({
+      url: "/payment/requests",
+      method: HttpMethod.Get,
+      data: request,
+      schema: getPaymentRequestsResponseSchema
+    });
+  }
+};
+
+// src/api/services/integration.ts
+var import_axios2 = __toESM(require("axios"));
+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: {} };
+  }
+}
+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 (import_axios2.default.isAxiosError(error) && error.response?.status === 404) {
+        const defaultResponse = createEmptyIntegrationResponse(
+          request.integrationType
+        );
+        return { data: defaultResponse };
+      }
+      throw error;
+    }
+  }
+};
+
+// 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;
+  }
+};
+
+// 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
+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);
+  }
+};
+var createAPIClient = (...params) => {
+  return new APIClient(...params);
+};
+//# sourceMappingURL=index.js.map