@otim/utils 0.0.2-development.0

package/dist/api/index.mjs

@@ -0,0 +1,2030 @@
+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);
+
+// 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";
+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
+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;
+};
+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
+import { z as z2 } from "zod";
+var DelegationStatus = {
+  Undelegated: "Undelegated",
+  Pending: "Pending",
+  Delegated: "Delegated",
+  Expired: "Expired",
+  Errored: "Errored"
+};
+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"
+};
+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()
+});
+
+// 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 = 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"
+};
+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"
+};
+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 })
+]);
+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);
+
+// 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
+});
+
+// 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()
+});
+
+// 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()
+});
+
+// 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);
+
+// 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
+]);
+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
+]);
+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
+);
+
+// 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"
+};
+var 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()
+    })
+  ]
+);
+
+// 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()
+});
+
+// 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"
+]);
+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({})
+});
+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,
+  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(),
+  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())
+});
+
+// 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);
+
+// 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;
+};
+
+// 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
+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;
+};
+var safeActivityArraySchema = z19.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
+import axios2 from "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 (axios2.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);
+};
+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,
+  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
+};
+//# sourceMappingURL=index.mjs.map