@helium/blockchain-api 0.2.0 → 0.2.1

package/dist/index.js

@@ -1,6 +1,7 @@
 import { createORPCClient } from '@orpc/client';
 import { RPCLink } from '@orpc/client/fetch';
 import { z } from 'zod';
+import { oc } from '@orpc/contract';
 
 // src/client.ts
 function createClient(options) {
@@ -63,18 +64,6 @@ function createMockClient(mocks = {}) {
   };
   return createProxy();
 }
-var HealthResponseSchema = z.object({
-  ok: z.boolean(),
-  error: z.string().optional()
-});
-
-// src/contracts/health.ts
-var healthContract = {
-  check: {
-    route: { method: "GET", path: "/health" },
-    output: HealthResponseSchema
-  }
-};
 var TransactionMetadataSchema = z.object({
   type: z.string(),
   description: z.string()
@@ -112,8 +101,10 @@ var PaginationOutputSchema = z.object({
   page: z.number(),
   totalPages: z.number()
 });
-
-// src/schemas/tokens.ts
+var HealthResponseSchema = z.object({
+  ok: z.boolean(),
+  error: z.string().optional()
+});
 var GetBalancesInputSchema = z.object({
   walletAddress: z.string().min(32)
 });
@@ -151,35 +142,6 @@ var TransferOutputSchema = z.object({
 var CreateHntAccountOutputSchema = z.object({
   transactionData: TransactionDataSchema
 });
-
-// src/contracts/tokens.ts
-var tokensContract = {
-  getBalances: {
-    route: { method: "GET", path: "/tokens/{walletAddress}" },
-    input: GetBalancesInputSchema,
-    output: TokenBalanceDataSchema,
-    errors: {
-      BAD_REQUEST: { message: "Wallet address is required" }
-    }
-  },
-  transfer: {
-    route: { method: "POST", path: "/tokens/transfer" },
-    input: TransferInputSchema,
-    output: TransferOutputSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid transfer parameters" },
-      INSUFFICIENT_FUNDS: { message: "Insufficient balance for transfer" }
-    }
-  },
-  createHntAccount: {
-    route: { method: "POST", path: "/tokens/hnt-account" },
-    input: CreateHntAccountInputSchema,
-    output: CreateHntAccountOutputSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid wallet address" }
-    }
-  }
-};
 var HotspotTypeSchema = z.enum(["iot", "mobile", "all"]);
 var DeviceTypeSchema = z.enum([
   "iot-gateway",
@@ -294,133 +256,6 @@ var DeleteSplitOutputSchema = z.object({
 var PendingRewardsOutputSchema = z.object({
   pending: z.string()
 });
-var UNAUTHORIZED = {
-  status: 401,
-  message: "Authentication required. Please sign in to continue."
-};
-var FORBIDDEN = {
-  status: 403,
-  message: "You do not have permission to access this resource."
-};
-var NOT_FOUND = {
-  status: 404,
-  message: "The requested resource was not found."
-};
-var VALIDATION_ERROR = {
-  status: 400,
-  message: "Invalid input data provided.",
-  data: z.object({
-    fields: z.array(z.string()).optional()
-  })
-};
-var RATE_LIMITED = {
-  status: 429,
-  message: "Too many requests. Please try again later."
-};
-var CONFLICT = {
-  status: 409,
-  message: "A resource with this identifier already exists.",
-  data: z.object({
-    existingId: z.string().optional()
-  })
-};
-var commonErrors = {
-  UNAUTHORIZED,
-  FORBIDDEN,
-  NOT_FOUND,
-  VALIDATION_ERROR
-};
-
-// src/errors/hotspot.ts
-var NOT_OWNER = {
-  status: 403,
-  message: "You do not own this asset.",
-  data: z.object({
-    owner: z.string(),
-    wallet: z.string()
-  })
-};
-var INVALID_HOTSPOT = {
-  status: 400,
-  message: "The specified asset is not a valid Helium hotspot."
-};
-var hotspotErrors = {
-  NOT_OWNER,
-  INVALID_HOTSPOT,
-  NOT_FOUND
-};
-
-// src/contracts/hotspots.ts
-var hotspotsContract = {
-  getHotspots: {
-    route: { method: "GET", path: "/hotspots/wallet/{walletAddress}" },
-    input: GetHotspotsInputSchema,
-    output: HotspotsDataSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid wallet address" }
-    }
-  },
-  claimRewards: {
-    route: { method: "POST", path: "/hotspots/claim-rewards" },
-    input: ClaimRewardsInputSchema,
-    output: ClaimRewardsOutputSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid wallet address" },
-      NO_REWARDS: { message: "No rewards to claim" }
-    }
-  },
-  getPendingRewards: {
-    route: { method: "GET", path: "/hotspots/pending-rewards/{walletAddress}" },
-    input: GetPendingRewardsInputSchema,
-    output: PendingRewardsOutputSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid wallet address" }
-    }
-  },
-  transferHotspot: {
-    route: { method: "POST", path: "/hotspots/transfer" },
-    input: TransferHotspotInputSchema,
-    output: TransferHotspotOutputSchema,
-    errors: {
-      ...hotspotErrors,
-      BAD_REQUEST: { message: "Invalid transfer parameters" }
-    }
-  },
-  updateRewardsDestination: {
-    route: { method: "POST", path: "/hotspots/update-rewards-destination" },
-    input: UpdateRewardsDestinationInputSchema,
-    output: UpdateRewardsDestinationOutputSchema,
-    errors: {
-      ...hotspotErrors,
-      BAD_REQUEST: { message: "Invalid parameters" }
-    }
-  },
-  getSplit: {
-    route: { method: "GET", path: "/hotspots/split/{walletAddress}/{hotspotPubkey}" },
-    input: GetSplitInputSchema,
-    output: SplitResponseSchema,
-    errors: {
-      NOT_FOUND: { message: "Split not found" }
-    }
-  },
-  createSplit: {
-    route: { method: "POST", path: "/hotspots/split" },
-    input: CreateSplitInputSchema,
-    output: CreateSplitOutputSchema,
-    errors: {
-      ...hotspotErrors,
-      BAD_REQUEST: { message: "Invalid split configuration" }
-    }
-  },
-  deleteSplit: {
-    route: { method: "DELETE", path: "/hotspots/split" },
-    input: DeleteSplitInputSchema,
-    output: DeleteSplitOutputSchema,
-    errors: {
-      ...hotspotErrors
-    }
-  }
-};
 var GetTokensInputSchema = z.object({
   limit: z.coerce.number().int().min(1).max(100).default(50)
 });
@@ -498,19 +333,31 @@ var SubmitOutputSchema = z.object({
   batchId: z.string(),
   message: z.string().optional()
 });
+var TransactionStateSchema = z.union([
+  z.literal("pending"),
+  z.literal("confirmed"),
+  z.literal("failed"),
+  z.literal("expired"),
+  z.literal("partial")
+]);
 var TransactionStatusSchema = z.object({
   signature: z.string(),
-  status: z.string(),
+  status: TransactionStateSchema,
   transaction: z.unknown().optional()
 });
 var BatchStatusOutputSchema = z.object({
   batchId: z.string(),
-  status: z.string(),
-  submissionType: z.string(),
+  status: TransactionStateSchema,
+  submissionType: z.union([
+    z.literal("single"),
+    z.literal("parallel"),
+    z.literal("sequential"),
+    z.literal("jito_bundle")
+  ]),
   parallel: z.boolean(),
   transactions: z.array(TransactionStatusSchema),
-  jitoBundleId: z.string().optional(),
-  jitoBundleStatus: z.unknown().optional()
+  jitoBundleId: z.string().optional().nullable(),
+  jitoBundleStatus: z.unknown().optional().nullable()
 });
 var ResubmitOutputSchema = z.object({
   success: z.boolean(),
@@ -609,33 +456,32 @@ var WelcomePackInviteOutputSchema = z.object({
   message: z.string(),
   expirationTs: z.number()
 });
-
-// src/contracts/swap.ts
-var swapContract = {
-  getTokens: {
-    route: { method: "GET", path: "/swap/tokens" },
-    input: GetTokensInputSchema,
-    output: TokenListOutputSchema,
-    errors: {}
-  },
-  getQuote: {
-    route: { method: "GET", path: "/swap/quote" },
-    input: GetQuoteInputSchema,
-    output: QuoteResponseSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid quote parameters" },
-      EXTERNAL_API_ERROR: { message: "Jupiter API request failed" }
-    }
-  },
-  getInstructions: {
-    route: { method: "POST", path: "/swap/instructions" },
-    input: GetInstructionsInputSchema,
-    output: TransactionDataSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid instruction parameters" },
-      EXTERNAL_API_ERROR: { message: "Jupiter API request failed" }
-    }
-  }
+var UNAUTHENTICATED = {
+  status: 401,
+  message: "Authentication required. Please sign in to continue."
+};
+var UNAUTHORIZED = {
+  status: 403,
+  message: "You do not have permission to access this resource."
+};
+var NOT_FOUND = {
+  status: 404,
+  message: "The requested resource was not found."
+};
+var BAD_REQUEST = {
+  status: 400,
+  message: "Invalid input data provided.",
+  data: z.object({
+    fields: z.array(z.string()).optional()
+  }).optional()
+};
+var RATE_LIMITED = {
+  status: 429,
+  message: "Too many requests. Please try again later."
+};
+var CONFLICT = {
+  status: 409,
+  message: "A resource with this identifier already exists."
 };
 var INSUFFICIENT_FUNDS = {
   status: 400,
@@ -661,121 +507,284 @@ var SIMULATION_FAILED = {
     link: z.string().optional()
   })
 };
-var solanaErrors = {
-  INSUFFICIENT_FUNDS,
-  TRANSACTION_FAILED,
-  SIMULATION_FAILED
+var protectedOc = oc.errors({
+  UNAUTHENTICATED,
+  UNAUTHORIZED
+});
+var publicOc = oc.errors({
+  INVALID_WALLET_ADDRESS: { message: "Invalid wallet address", status: 400 }
+});
+
+// src/contracts/health.ts
+var healthContract = {
+  check: publicOc.route({ method: "GET", path: "/health", tags: ["Health"], summary: "Health check" }).output(HealthResponseSchema)
+};
+
+// src/contracts/tokens.ts
+var tokensContract = {
+  /** Public: Get token balances for a wallet */
+  getBalances: publicOc.route({ method: "GET", path: "/tokens/{walletAddress}", tags: ["Tokens"], summary: "Get token balances for a wallet" }).input(GetBalancesInputSchema).output(TokenBalanceDataSchema).errors({}),
+  /** Protected: Transfer tokens */
+  transfer: publicOc.route({ method: "POST", path: "/tokens/transfer", tags: ["Tokens"], summary: "Transfer tokens" }).input(TransferInputSchema).output(TransferOutputSchema).errors({
+    BAD_REQUEST,
+    INSUFFICIENT_FUNDS
+  }),
+  /** Protected: Create HNT account */
+  createHntAccount: publicOc.route({ method: "POST", path: "/tokens/hnt-account", tags: ["Tokens"], summary: "Create HNT account" }).input(CreateHntAccountInputSchema).output(CreateHntAccountOutputSchema).errors({})
+};
+
+// src/contracts/hotspots.ts
+var hotspotsContract = {
+  /** Public: Get hotspots for a wallet */
+  getHotspots: publicOc.route({ method: "GET", path: "/hotspots/wallet/{walletAddress}", tags: ["Hotspots"], summary: "Get hotspots for a wallet" }).input(GetHotspotsInputSchema).output(HotspotsDataSchema).errors({}),
+  /** Protected: Claim rewards for hotspots */
+  claimRewards: publicOc.route({ method: "POST", path: "/hotspots/claim-rewards", tags: ["Hotspots"], summary: "Claim all hotspot rewards" }).input(ClaimRewardsInputSchema).output(ClaimRewardsOutputSchema).errors({
+    INSUFFICIENT_FUNDS
+  }),
+  /** Public: Get pending rewards for a wallet */
+  getPendingRewards: publicOc.route({ method: "GET", path: "/hotspots/pending-rewards/{walletAddress}", tags: ["Hotspots"], summary: "Get pending rewards" }).input(GetPendingRewardsInputSchema).output(PendingRewardsOutputSchema).errors({
+    BAD_REQUEST: { message: "Invalid wallet address", status: 400 }
+  }),
+  /** Protected: Transfer hotspot ownership */
+  transferHotspot: publicOc.route({ method: "POST", path: "/hotspots/transfer", tags: ["Hotspots"], summary: "Transfer ownership" }).input(TransferHotspotInputSchema).output(TransferHotspotOutputSchema).errors({
+    UNAUTHORIZED,
+    NOT_FOUND,
+    BAD_REQUEST: { message: "Invalid transfer parameters", status: 400 }
+  }),
+  /** Protected: Update rewards destination */
+  updateRewardsDestination: publicOc.route({ method: "POST", path: "/hotspots/update-rewards-destination", tags: ["Hotspots"], summary: "Update rewards destination" }).input(UpdateRewardsDestinationInputSchema).output(UpdateRewardsDestinationOutputSchema).errors({
+    BAD_REQUEST: { message: "Invalid parameters", status: 400 },
+    NOT_FOUND
+  }),
+  /** Public: Get split configuration for a hotspot */
+  getSplit: publicOc.route({ method: "GET", path: "/hotspots/split/{walletAddress}/{hotspotPubkey}", tags: ["Hotspots"], summary: "Get reward split" }).input(GetSplitInputSchema).output(SplitResponseSchema).errors({
+    NOT_FOUND: { message: "Split not found", status: 404 }
+  }),
+  /** Protected: Create a split configuration */
+  createSplit: publicOc.route({ method: "POST", path: "/hotspots/split", tags: ["Hotspots"], summary: "Create a reward split" }).input(CreateSplitInputSchema).output(CreateSplitOutputSchema).errors({
+    NOT_FOUND,
+    BAD_REQUEST: { message: "Invalid split configuration", status: 400 },
+    INSUFFICIENT_FUNDS
+  }),
+  /** Protected: Delete a split configuration */
+  deleteSplit: publicOc.route({ method: "DELETE", path: "/hotspots/split", tags: ["Hotspots"], summary: "Delete a reward split" }).input(DeleteSplitInputSchema).output(DeleteSplitOutputSchema).errors({
+    NOT_FOUND
+  })
+};
+
+// src/contracts/swap.ts
+var swapContract = {
+  getTokens: publicOc.route({ method: "GET", path: "/swap/tokens", tags: ["Swap"] }).input(GetTokensInputSchema).output(TokenListOutputSchema).errors({
+    JUPITER_ERROR: { message: "Failed to fetch tokens from Jupiter" }
+  }),
+  getQuote: publicOc.route({ method: "GET", path: "/swap/quote", tags: ["Swap"] }).input(GetQuoteInputSchema).output(QuoteResponseSchema).errors({
+    BAD_REQUEST: { message: "Invalid quote parameters", status: 400 },
+    JUPITER_ERROR: { message: "Failed to get quote from Jupiter" }
+  }),
+  getInstructions: publicOc.route({ method: "POST", path: "/swap/instructions", tags: ["Swap"] }).input(GetInstructionsInputSchema).output(TransactionDataSchema).errors({
+    BAD_REQUEST: { message: "Invalid instruction parameters", status: 400 },
+    JUPITER_ERROR: { message: "Failed to get swap instructions from Jupiter" }
+  })
 };
 
 // src/contracts/transactions.ts
 var transactionsContract = {
-  submit: {
-    route: { method: "POST", path: "/transactions" },
-    input: SubmitInputSchema,
-    output: SubmitOutputSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid transaction data" },
-      ...solanaErrors
-    }
-  },
-  get: {
-    route: { method: "GET", path: "/transactions/{id}" },
-    input: GetInputSchema,
-    output: BatchStatusOutputSchema,
-    errors: {
-      NOT_FOUND: { message: "Transaction batch not found" }
-    }
-  },
-  resubmit: {
-    route: { method: "POST", path: "/transactions/{id}/resubmit" },
-    input: ResubmitInputSchema,
-    output: ResubmitOutputSchema,
-    errors: {
-      NOT_FOUND: { message: "Transaction batch not found" },
-      BAD_REQUEST: { message: "Cannot resubmit this transaction" }
-    }
-  },
-  getByPayer: {
-    route: { method: "GET", path: "/transactions/payer/{payer}" },
-    input: GetByPayerInputSchema,
-    output: PayerBatchesOutputSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid payer address" }
-    }
-  },
-  getByPayerAndTag: {
-    route: { method: "GET", path: "/transactions/payer/{payer}/tag/{tag}" },
-    input: GetByPayerAndTagInputSchema,
-    output: PayerBatchesOutputSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid parameters" }
-    }
-  }
+  submit: publicOc.route({ method: "POST", path: "/transactions", tags: ["Transactions"], summary: "Submit a transaction" }).input(SubmitInputSchema).output(SubmitOutputSchema).errors({
+    BAD_REQUEST,
+    CONFLICT,
+    SIMULATION_FAILED
+  }),
+  get: publicOc.route({ method: "GET", path: "/transactions/{id}", tags: ["Transactions"], summary: "Get transaction status" }).input(GetInputSchema).output(BatchStatusOutputSchema).errors({
+    NOT_FOUND
+  }),
+  resubmit: publicOc.route({ method: "POST", path: "/transactions/{id}/resubmit", tags: ["Transactions"], summary: "Resubmit a transaction" }).input(ResubmitInputSchema).output(ResubmitOutputSchema).errors({
+    NOT_FOUND,
+    BAD_REQUEST
+  }),
+  getByPayer: publicOc.route({ method: "GET", path: "/transactions/payer/{payer}", tags: ["Transactions"], summary: "Get transactions by payer" }).input(GetByPayerInputSchema).output(PayerBatchesOutputSchema).errors({
+    BAD_REQUEST
+  }),
+  getByPayerAndTag: publicOc.route({ method: "GET", path: "/transactions/payer/{payer}/tag/{tag}", tags: ["Transactions"], summary: "Get transactions by payer and tag" }).input(GetByPayerAndTagInputSchema).output(PayerBatchesOutputSchema).errors({
+    BAD_REQUEST
+  })
 };
 
 // src/contracts/welcome-packs.ts
 var welcomePacksContract = {
-  list: {
-    route: { method: "GET", path: "/welcome-packs/{walletAddress}" },
-    input: WelcomePackListInputSchema,
-    output: WelcomePackListOutputSchema,
-    errors: {
-      BAD_REQUEST: { message: "Invalid wallet address" }
-    }
-  },
-  create: {
-    route: { method: "POST", path: "/welcome-packs" },
-    input: WelcomePackCreateInputSchema,
-    output: WelcomePackCreateOutputSchema,
-    errors: {
-      ...commonErrors,
-      BAD_REQUEST: { message: "Invalid welcome pack configuration" }
-    }
-  },
-  get: {
-    route: { method: "GET", path: "/welcome-packs/{walletAddress}/{packId}" },
-    input: WelcomePackGetInputSchema,
-    output: WelcomePackSchema,
-    errors: {
-      NOT_FOUND: { message: "Welcome pack not found" }
-    }
-  },
-  delete: {
-    route: { method: "DELETE", path: "/welcome-packs/{walletAddress}/{packId}" },
-    input: WelcomePackDeleteInputSchema,
-    output: WelcomePackDeleteOutputSchema,
-    errors: {
-      ...commonErrors,
-      NOT_FOUND: { message: "Welcome pack not found" }
-    }
-  },
-  getByAddress: {
-    route: { method: "GET", path: "/welcome-packs/address/{packAddress}" },
-    input: WelcomePackGetByAddressInputSchema,
-    output: WelcomePackSchema,
-    errors: {
-      NOT_FOUND: { message: "Welcome pack not found" }
-    }
-  },
-  claim: {
-    route: { method: "POST", path: "/welcome-packs/claim" },
-    input: WelcomePackClaimInputSchema,
-    output: WelcomePackClaimOutputSchema,
-    errors: {
-      ...commonErrors,
-      BAD_REQUEST: { message: "Invalid claim parameters" },
-      EXPIRED: { message: "Claim link has expired" }
-    }
-  },
-  invite: {
-    route: { method: "POST", path: "/welcome-packs/invite" },
-    input: WelcomePackInviteInputSchema,
-    output: WelcomePackInviteOutputSchema,
-    errors: {
-      ...commonErrors,
-      NOT_FOUND: { message: "Welcome pack not found" }
-    }
-  }
+  /** Public: List welcome packs for a wallet */
+  list: publicOc.route({ method: "GET", path: "/welcome-packs/{walletAddress}", tags: ["Welcome Packs"], summary: "List welcome packs for a wallet" }).input(WelcomePackListInputSchema).output(WelcomePackListOutputSchema).errors({}),
+  /** Protected: Create a new welcome pack */
+  create: publicOc.route({ method: "POST", path: "/welcome-packs", tags: ["Welcome Packs"], summary: "Create a new welcome pack" }).input(WelcomePackCreateInputSchema).output(WelcomePackCreateOutputSchema).errors({
+    BAD_REQUEST
+  }),
+  /** Public: Get a specific welcome pack */
+  get: publicOc.route({ method: "GET", path: "/welcome-packs/{walletAddress}/{packId}", tags: ["Welcome Packs"], summary: "Get a specific welcome pack" }).input(WelcomePackGetInputSchema).output(WelcomePackSchema).errors({
+    NOT_FOUND
+  }),
+  /** Protected: Delete a welcome pack */
+  delete: publicOc.route({ method: "DELETE", path: "/welcome-packs/{walletAddress}/{packId}", tags: ["Welcome Packs"], summary: "Delete a welcome pack" }).input(WelcomePackDeleteInputSchema).output(WelcomePackDeleteOutputSchema).errors({
+    BAD_REQUEST
+  }),
+  /** Public: Get welcome pack by pack address */
+  getByAddress: publicOc.route({ method: "GET", path: "/welcome-packs/address/{packAddress}", tags: ["Welcome Packs"], summary: "Get welcome pack by pack address" }).input(WelcomePackGetByAddressInputSchema).output(WelcomePackSchema).errors({
+    NOT_FOUND
+  }),
+  /** Public: Claim a welcome pack (no auth needed, uses claim token) */
+  claim: publicOc.route({ method: "POST", path: "/welcome-packs/claim", tags: ["Welcome Packs"], summary: "Claim a welcome pack" }).input(WelcomePackClaimInputSchema).output(WelcomePackClaimOutputSchema).errors({
+    BAD_REQUEST,
+    EXPIRED: { message: "Claim link has expired", status: 410 }
+  }),
+  /** Protected: Send an invite for a welcome pack */
+  invite: publicOc.route({ method: "POST", path: "/welcome-packs/invite", tags: ["Welcome Packs"], summary: "Send an invite for a welcome pack" }).input(WelcomePackInviteInputSchema).output(WelcomePackInviteOutputSchema).errors({
+    BAD_REQUEST,
+    NOT_FOUND
+  })
+};
+var InitKycInputSchema = z.object({
+  type: z.enum(["individual", "business"]).optional()
+});
+var CreateBankAccountInputSchema = z.object({
+  currency: z.string(),
+  account_type: z.string(),
+  bank_name: z.string(),
+  account_name: z.string(),
+  first_name: z.string().optional(),
+  last_name: z.string().optional(),
+  account_owner_name: z.string().optional(),
+  business_name: z.string().optional(),
+  account: z.object({
+    account_number: z.string(),
+    routing_number: z.string(),
+    checking_or_savings: z.string()
+  }),
+  address: z.object({
+    street_line_1: z.string(),
+    line2: z.string().optional(),
+    city: z.string(),
+    state: z.string(),
+    postal_code: z.string(),
+    country: z.string()
+  })
+});
+z.object({
+  id: z.string()
+});
+var DeleteBankAccountInputSchema = z.object({
+  id: z.number()
+});
+var GetSendQuoteInputSchema = z.object({
+  id: z.string(),
+  usdAmount: z.string()
+});
+var SendFundsInputSchema = z.object({
+  id: z.string(),
+  userAddress: z.string(),
+  quoteResponse: QuoteResponseSchema
+});
+z.object({
+  id: z.string()
+});
+var UpdateTransferInputSchema = z.object({
+  id: z.string(),
+  solanaSignature: z.string()
+});
+var KycStatusOutputSchema = z.object({
+  kycStatus: z.string(),
+  tosStatus: z.string(),
+  tosLink: z.string().nullable(),
+  kycLink: z.string().nullable(),
+  kycLinkId: z.string().nullable(),
+  accountType: z.string().optional(),
+  rejectionReasons: z.array(z.string()).optional()
+});
+var FeesOutputSchema = z.object({
+  developer_fee: z.string(),
+  developer_fee_percent: z.number()
+});
+var BankAccountSchema = z.object({
+  id: z.number().optional(),
+  bridgeUserId: z.number().optional(),
+  bridgeExternalAccountId: z.string().optional(),
+  accountName: z.string().optional(),
+  bankName: z.string().optional(),
+  lastFourDigits: z.string().optional(),
+  routingNumber: z.string().optional(),
+  accountType: z.string().optional(),
+  createdAt: z.union([z.string(), z.date()]).optional(),
+  updatedAt: z.union([z.string(), z.date()]).optional()
+}).passthrough();
+var BankAccountListOutputSchema = z.array(BankAccountSchema);
+var DeleteBankAccountOutputSchema = z.object({
+  success: z.boolean()
+});
+var BridgeTransferSchema = z.object({
+  id: z.string(),
+  state: z.string(),
+  source_deposit_instructions: z.object({
+    to_address: z.string()
+  })
+}).passthrough();
+var SendFundsOutputSchema = z.object({
+  bridgeTransfer: BridgeTransferSchema,
+  transactionData: TransactionDataSchema
+});
+var UpdateTransferOutputSchema = z.object({
+  success: z.boolean()
+});
+var QuoteOutputSchema = QuoteResponseSchema;
+
+// src/contracts/fiat.ts
+var fiatContract = {
+  getKycStatus: protectedOc.route({ method: "GET", path: "/fiat/kyc/status" }).output(KycStatusOutputSchema).errors({
+    EMAIL_NOT_LINKED: { status: 401, message: "Email not linked." }
+  }),
+  initKyc: protectedOc.route({ method: "POST", path: "/fiat/kyc/init" }).input(InitKycInputSchema).output(KycStatusOutputSchema).errors({
+    EMAIL_NOT_LINKED: { status: 401, message: "Email not linked." },
+    BRIDGE_ERROR: { message: "Failed to create Bridge KYC link", status: 500 }
+  }),
+  getFees: protectedOc.route({ method: "GET", path: "/fiat/fees" }).output(FeesOutputSchema).errors({}),
+  listBankAccounts: protectedOc.route({ method: "GET", path: "/fiat/bank-accounts" }).output(BankAccountListOutputSchema).errors({
+    NOT_FOUND: { message: "Bridge customer ID not found", status: 404 }
+  }),
+  createBankAccount: protectedOc.route({ method: "POST", path: "/fiat/bank-accounts" }).input(CreateBankAccountInputSchema).output(BankAccountSchema).errors({
+    NO_CUSTOMER: { message: "Bridge customer ID not found", status: 404 },
+    BRIDGE_ERROR: { message: "Failed to create Bridge KYC link", status: 500 }
+  }),
+  deleteBankAccount: protectedOc.route({ method: "DELETE", path: "/fiat/bank-accounts/{id}" }).input(DeleteBankAccountInputSchema).output(DeleteBankAccountOutputSchema).errors({
+    NO_CUSTOMER: { message: "Bridge customer ID not found", status: 404 },
+    BRIDGE_ERROR: { message: "Failed to delete bank account", status: 500 }
+  }),
+  getSendQuote: protectedOc.route({ method: "GET", path: "/fiat/quote/{id}" }).input(GetSendQuoteInputSchema).output(QuoteOutputSchema).errors({
+    BAD_REQUEST,
+    JUPITER_ERROR: { message: "Failed to get quote from Jupiter", status: 500 }
+  }),
+  sendFunds: protectedOc.route({ method: "POST", path: "/fiat/send" }).input(SendFundsInputSchema).output(SendFundsOutputSchema).errors({
+    NOT_FOUND,
+    BRIDGE_ERROR: { message: "Failed to create Bridge transfer", status: 500 },
+    JUPITER_ERROR: { message: "Failed to get quote from Jupiter", status: 500 }
+  }),
+  updateTransfer: protectedOc.route({ method: "PUT", path: "/fiat/transfer/{id}" }).input(UpdateTransferInputSchema).output(UpdateTransferOutputSchema).errors({
+    NOT_FOUND: { message: "Transfer not found", status: 404 }
+  })
+};
+var BridgeWebhookInputSchema = z.object({
+  type: z.string(),
+  kyc_link_id: z.string().optional(),
+  kyc_status: z.string().optional(),
+  tos_status: z.string().optional(),
+  customer_id: z.string().optional()
+});
+var BridgeWebhookOutputSchema = z.object({
+  success: z.boolean(),
+  error: z.string().optional()
+});
+
+// src/contracts/webhooks.ts
+var webhooksContract = {
+  bridge: publicOc.route({ method: "POST", path: "/webhooks/bridge" }).input(BridgeWebhookInputSchema).output(BridgeWebhookOutputSchema).errors({
+    NOT_FOUND,
+    INVALID_PAYLOAD: { message: "Invalid webhook payload", status: 400 }
+  })
 };
 
 // src/contracts/index.ts
@@ -787,66 +796,10 @@ var apiContract = {
   transactions: transactionsContract,
   welcomePacks: welcomePacksContract
 };
+var fullApiContract = {
+  ...apiContract,
+  fiat: fiatContract,
+  webhooks: webhooksContract
+};
 
-// src/openapi.ts
-function generateOpenAPISpec(options) {
-  const { info = {}, servers = [] } = options;
-  const paths = {};
-  const schemas = {};
-  for (const [routerName, router] of Object.entries(apiContract)) {
-    for (const [procedureName, procedure] of Object.entries(
-      router
-    )) {
-      if (!procedure.route) continue;
-      const { method, path } = procedure.route;
-      const operationId = `${routerName}_${procedureName}`;
-      const openApiPath = path.replace(/\{(\w+)\}/g, "{$1}");
-      if (!paths[openApiPath]) {
-        paths[openApiPath] = {};
-      }
-      paths[openApiPath][method.toLowerCase()] = {
-        operationId,
-        tags: [routerName],
-        summary: `${routerName}.${procedureName}`,
-        responses: {
-          "200": {
-            description: "Successful response"
-          },
-          "400": {
-            description: "Bad request"
-          },
-          "401": {
-            description: "Unauthorized"
-          },
-          "403": {
-            description: "Forbidden"
-          },
-          "404": {
-            description: "Not found"
-          },
-          "500": {
-            description: "Internal server error"
-          }
-        }
-      };
-    }
-  }
-  return {
-    openapi: "3.0.3",
-    info: {
-      title: info.title ?? "Helium Blockchain API",
-      version: info.version ?? "1.0.0",
-      description: info.description ?? "API for interacting with the Helium blockchain, including hotspots, tokens, and transactions."
-    },
-    servers,
-    paths,
-    components: {
-      schemas
-    }
-  };
-}
-function getAPIContract() {
-  return apiContract;
-}
-
-export { BatchStatusOutputSchema, CONFLICT, ClaimRewardsInputSchema, ClaimRewardsOutputSchema, CreateHntAccountInputSchema, CreateHntAccountOutputSchema, CreateSplitInputSchema, CreateSplitOutputSchema, DeleteSplitInputSchema, DeleteSplitOutputSchema, DeviceTypeSchema, ErrorResponseSchema, FORBIDDEN, GetBalancesInputSchema, GetByPayerAndTagInputSchema, GetByPayerInputSchema, GetHotspotsInputSchema, GetInputSchema, GetInstructionsInputSchema, GetPendingRewardsInputSchema, GetQuoteInputSchema, GetSplitInputSchema, GetTokensInputSchema, HealthResponseSchema, HotspotSchema, HotspotSharesSchema, HotspotTypeSchema, HotspotsDataSchema, INSUFFICIENT_FUNDS, INVALID_HOTSPOT, NOT_FOUND, NOT_OWNER, OwnershipTypeSchema, PaginationInputSchema, PaginationOutputSchema, PayerBatchSummarySchema, PayerBatchesOutputSchema, PendingRewardsOutputSchema, PublicKeySchema, QuoteResponseSchema, RATE_LIMITED, ResubmitInputSchema, ResubmitOutputSchema, RewardSplitInputSchema, SIMULATION_FAILED, ScheduleInputSchema, SplitResponseSchema, SplitShareSchema, SubmitInputSchema, SubmitOutputSchema, SwapTransactionDataSchema, TRANSACTION_FAILED, TokenAccountSchema, TokenBalanceDataSchema, TokenListOutputSchema, TokenSchema, TransactionBatchRequestSchema, TransactionBatchResponseSchema, TransactionDataSchema, TransactionItemSchema, TransactionMetadataSchema, TransactionStatusSchema, TransferHotspotInputSchema, TransferHotspotOutputSchema, TransferInputSchema, TransferOutputSchema, UNAUTHORIZED, UpdateRewardsDestinationInputSchema, UpdateRewardsDestinationOutputSchema, VALIDATION_ERROR, WalletAddressSchema, WelcomePackClaimInputSchema, WelcomePackClaimOutputSchema, WelcomePackCreateInputSchema, WelcomePackCreateOutputSchema, WelcomePackDeleteInputSchema, WelcomePackDeleteOutputSchema, WelcomePackGetByAddressInputSchema, WelcomePackGetInputSchema, WelcomePackInviteInputSchema, WelcomePackInviteOutputSchema, WelcomePackListInputSchema, WelcomePackListOutputSchema, WelcomePackSchema, apiContract, commonErrors, createClient, createMockClient, generateOpenAPISpec, getAPIContract, hotspotErrors, solanaErrors };
+export { BAD_REQUEST, BatchStatusOutputSchema, CONFLICT, ClaimRewardsInputSchema, ClaimRewardsOutputSchema, CreateHntAccountInputSchema, CreateHntAccountOutputSchema, CreateSplitInputSchema, CreateSplitOutputSchema, DeleteSplitInputSchema, DeleteSplitOutputSchema, DeviceTypeSchema, ErrorResponseSchema, GetBalancesInputSchema, GetByPayerAndTagInputSchema, GetByPayerInputSchema, GetHotspotsInputSchema, GetInputSchema, GetInstructionsInputSchema, GetPendingRewardsInputSchema, GetQuoteInputSchema, GetSplitInputSchema, GetTokensInputSchema, HealthResponseSchema, HotspotSchema, HotspotSharesSchema, HotspotTypeSchema, HotspotsDataSchema, INSUFFICIENT_FUNDS, NOT_FOUND, OwnershipTypeSchema, PaginationInputSchema, PaginationOutputSchema, PayerBatchSummarySchema, PayerBatchesOutputSchema, PendingRewardsOutputSchema, PublicKeySchema, QuoteResponseSchema, RATE_LIMITED, ResubmitInputSchema, ResubmitOutputSchema, RewardSplitInputSchema, SIMULATION_FAILED, ScheduleInputSchema, SplitResponseSchema, SplitShareSchema, SubmitInputSchema, SubmitOutputSchema, SwapTransactionDataSchema, TRANSACTION_FAILED, TokenAccountSchema, TokenBalanceDataSchema, TokenListOutputSchema, TokenSchema, TransactionBatchRequestSchema, TransactionBatchResponseSchema, TransactionDataSchema, TransactionItemSchema, TransactionMetadataSchema, TransactionStatusSchema, TransferHotspotInputSchema, TransferHotspotOutputSchema, TransferInputSchema, TransferOutputSchema, UNAUTHENTICATED, UNAUTHORIZED, UpdateRewardsDestinationInputSchema, UpdateRewardsDestinationOutputSchema, WalletAddressSchema, WelcomePackClaimInputSchema, WelcomePackClaimOutputSchema, WelcomePackCreateInputSchema, WelcomePackCreateOutputSchema, WelcomePackDeleteInputSchema, WelcomePackDeleteOutputSchema, WelcomePackGetByAddressInputSchema, WelcomePackGetInputSchema, WelcomePackInviteInputSchema, WelcomePackInviteOutputSchema, WelcomePackListInputSchema, WelcomePackListOutputSchema, WelcomePackSchema, apiContract, createClient, createMockClient, fullApiContract };