@helium/blockchain-api 0.2.0 → 0.2.2

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()
@@ -103,6 +92,7 @@ var ErrorResponseSchema = z.object({
 });
 var WalletAddressSchema = z.string().min(32).max(44);
 var PublicKeySchema = z.string().min(32).max(44);
+var HeliumPublicKeySchema = z.string().min(32).max(400);
 var PaginationInputSchema = z.object({
   page: z.coerce.number().int().min(1).default(1),
   limit: z.coerce.number().int().min(1).max(100).default(10)
@@ -112,20 +102,22 @@ 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)
+  walletAddress: WalletAddressSchema
 });
 var TransferInputSchema = z.object({
-  walletAddress: z.string().min(32),
+  walletAddress: WalletAddressSchema,
   mint: z.string().nullable().optional(),
   destination: z.string().min(32),
   amount: z.string(),
   decimals: z.number().optional()
 });
 var CreateHntAccountInputSchema = z.object({
-  walletAddress: z.string().min(32)
+  walletAddress: WalletAddressSchema
 });
 var TokenAccountSchema = z.object({
   mint: z.string(),
@@ -151,35 +143,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",
@@ -209,31 +172,31 @@ var HotspotSchema = z.object({
   ownershipType: z.string()
 });
 var GetHotspotsInputSchema = z.object({
-  walletAddress: z.string().min(32),
+  walletAddress: WalletAddressSchema,
   type: HotspotTypeSchema.optional(),
   page: z.coerce.number().int().min(1).default(1),
   limit: z.coerce.number().int().min(1).max(100).default(10)
 });
 var ClaimRewardsInputSchema = z.object({
-  walletAddress: z.string().min(32)
+  walletAddress: WalletAddressSchema
 });
 var GetPendingRewardsInputSchema = z.object({
-  walletAddress: z.string().min(32)
+  walletAddress: WalletAddressSchema
 });
 var TransferHotspotInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1),
+  walletAddress: WalletAddressSchema,
+  hotspotPubkey: HeliumPublicKeySchema,
   recipient: z.string().min(32)
 });
 var UpdateRewardsDestinationInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1),
+  walletAddress: WalletAddressSchema,
+  hotspotPubkey: HeliumPublicKeySchema,
   destination: z.string().min(32),
   lazyDistributors: z.array(z.string().min(32)).min(1)
 });
 var GetSplitInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1)
+  walletAddress: WalletAddressSchema,
+  hotspotPubkey: HeliumPublicKeySchema
 });
 var RewardSplitInputSchema = z.object({
   address: z.string().min(32),
@@ -248,15 +211,15 @@ var ScheduleInputSchema = z.object({
   dayOfMonth: z.string().optional()
 });
 var CreateSplitInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1),
+  walletAddress: WalletAddressSchema,
+  hotspotPubkey: HeliumPublicKeySchema,
   rewardsSplit: z.array(RewardSplitInputSchema),
   schedule: ScheduleInputSchema,
   lazyDistributor: z.string().min(32)
 });
 var DeleteSplitInputSchema = z.object({
-  walletAddress: z.string().min(32),
-  hotspotPubkey: z.string().min(1)
+  walletAddress: WalletAddressSchema,
+  hotspotPubkey: HeliumPublicKeySchema
 });
 var HotspotsDataSchema = z.object({
   hotspots: z.array(HotspotSchema),
@@ -294,133 +257,18 @@ 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 ReassertLocationRequestSchema = z.object({
+  entityPubKey: HeliumPublicKeySchema,
+  walletAddress: WalletAddressSchema,
+  location: z.object({
+    lat: z.number().min(-90).max(90),
+    lng: z.number().min(-180).max(180)
+  }),
+  azimuth: z.number().min(0).max(360).optional()
+});
+var ReassertLocationResponseSchema = z.object({
+  transactionData: TransactionDataSchema
+});
 var GetTokensInputSchema = z.object({
   limit: z.coerce.number().int().min(1).max(100).default(50)
 });
@@ -498,19 +346,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(),
@@ -543,10 +403,10 @@ var PayerBatchesOutputSchema = z.object({
   })
 });
 var WelcomePackListInputSchema = z.object({
-  walletAddress: z.string().min(32)
+  walletAddress: WalletAddressSchema
 });
 var WelcomePackCreateInputSchema = z.object({
-  walletAddress: z.string().min(32),
+  walletAddress: WalletAddressSchema,
   assetId: z.string(),
   solAmount: z.number(),
   rentRefund: z.string(),
@@ -556,11 +416,11 @@ var WelcomePackCreateInputSchema = z.object({
   lazyDistributor: z.string()
 });
 var WelcomePackGetInputSchema = z.object({
-  walletAddress: z.string().min(32),
+  walletAddress: WalletAddressSchema,
   packId: z.number()
 });
 var WelcomePackDeleteInputSchema = z.object({
-  walletAddress: z.string().min(32),
+  walletAddress: WalletAddressSchema,
   packId: z.number()
 });
 var WelcomePackGetByAddressInputSchema = z.object({
@@ -568,13 +428,13 @@ var WelcomePackGetByAddressInputSchema = z.object({
 });
 var WelcomePackClaimInputSchema = z.object({
   packAddress: z.string().min(32),
-  walletAddress: z.string().min(32),
+  walletAddress: WalletAddressSchema,
   signature: z.string(),
   expirationTs: z.string()
 });
 var WelcomePackInviteInputSchema = z.object({
   packAddress: z.string().min(32),
-  walletAddress: z.string().min(32),
+  walletAddress: WalletAddressSchema,
   expirationDays: z.number().int().positive().max(365).default(7)
 });
 var WelcomePackSchema = z.object({
@@ -609,33 +469,36 @@ 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 INVALID_WALLET_ADDRESS = {
+  status: 400,
+  message: "The provided wallet address is invalid."
+};
+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,192 +524,291 @@ var SIMULATION_FAILED = {
     link: z.string().optional()
   })
 };
-var solanaErrors = {
-  INSUFFICIENT_FUNDS,
-  TRANSACTION_FAILED,
-  SIMULATION_FAILED
-};
-
-// 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" }
-    }
-  }
-};
-
-// 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" }
-    }
-  }
-};
+var healthContract = oc.tag("Health").router({
+  check: oc.route({ method: "GET", path: "/health", summary: "Health check" }).output(HealthResponseSchema)
+});
+var tokensContract = oc.tag("Tokens").router({
+  /** Public: Get token balances for a wallet */
+  getBalances: oc.route({ method: "GET", path: "/tokens/{walletAddress}", summary: "Get token balances for a wallet" }).input(GetBalancesInputSchema).output(TokenBalanceDataSchema).errors({
+    INVALID_WALLET_ADDRESS
+  }),
+  /** Protected: Transfer tokens */
+  transfer: oc.route({ method: "POST", path: "/tokens/transfer", summary: "Transfer tokens" }).input(TransferInputSchema).output(TransferOutputSchema).errors({
+    BAD_REQUEST,
+    INSUFFICIENT_FUNDS
+  }),
+  /** Protected: Create HNT account */
+  createHntAccount: oc.route({ method: "POST", path: "/tokens/hnt-account", summary: "Create HNT account" }).input(CreateHntAccountInputSchema).output(CreateHntAccountOutputSchema).errors({
+    INVALID_WALLET_ADDRESS
+  })
+});
+var hotspotsContract = oc.tag("Hotspot").prefix("/hotspots").router({
+  /** Public: Get hotspots for a wallet */
+  getHotspots: oc.route({ method: "GET", path: "/wallet/{walletAddress}", summary: "Get hotspots for a wallet" }).input(GetHotspotsInputSchema).output(HotspotsDataSchema).errors({
+    INVALID_WALLET_ADDRESS
+  }),
+  /** Protected: Claim rewards for hotspots */
+  claimRewards: oc.route({ method: "POST", path: "/claim-rewards", summary: "Claim all hotspot rewards" }).input(ClaimRewardsInputSchema).output(ClaimRewardsOutputSchema).errors({
+    INSUFFICIENT_FUNDS
+  }),
+  /** Public: Get pending rewards for a wallet */
+  getPendingRewards: oc.route({ method: "GET", path: "/pending-rewards/{walletAddress}", summary: "Get pending rewards" }).input(GetPendingRewardsInputSchema).output(PendingRewardsOutputSchema).errors({
+    BAD_REQUEST: { message: "Invalid wallet address", status: 400 },
+    INVALID_WALLET_ADDRESS
+  }),
+  /** Protected: Transfer hotspot ownership */
+  transferHotspot: oc.route({ method: "POST", path: "/transfer", summary: "Transfer ownership" }).input(TransferHotspotInputSchema).output(TransferHotspotOutputSchema).errors({
+    UNAUTHORIZED,
+    NOT_FOUND,
+    BAD_REQUEST: { message: "Invalid transfer parameters", status: 400 }
+  }),
+  /** Protected: Update rewards destination */
+  updateRewardsDestination: oc.route({ method: "POST", path: "/update-rewards-destination", 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: oc.route({ method: "GET", path: "/split/{walletAddress}/{hotspotPubkey}", summary: "Get reward split" }).input(GetSplitInputSchema).output(SplitResponseSchema).errors({
+    NOT_FOUND: { message: "Split not found", status: 404 },
+    INVALID_WALLET_ADDRESS
+  }),
+  /** Protected: Create a split configuration */
+  createSplit: oc.route({ method: "POST", path: "/split", 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: oc.route({ method: "DELETE", path: "/split", summary: "Delete a reward split" }).input(DeleteSplitInputSchema).output(DeleteSplitOutputSchema).errors({
+    NOT_FOUND
+  })
+});
+var swapContract = oc.tag("Swap").router({
+  getTokens: oc.route({ method: "GET", path: "/swap/tokens" }).input(GetTokensInputSchema).output(TokenListOutputSchema).errors({
+    JUPITER_ERROR: { message: "Failed to fetch tokens from Jupiter" }
+  }),
+  getQuote: oc.route({ method: "GET", path: "/swap/quote" }).input(GetQuoteInputSchema).output(QuoteResponseSchema).errors({
+    BAD_REQUEST: { message: "Invalid quote parameters", status: 400 },
+    JUPITER_ERROR: { message: "Failed to get quote from Jupiter" }
+  }),
+  getInstructions: oc.route({ method: "POST", path: "/swap/instructions" }).input(GetInstructionsInputSchema).output(TransactionDataSchema).errors({
+    BAD_REQUEST: { message: "Invalid instruction parameters", status: 400 },
+    JUPITER_ERROR: { message: "Failed to get swap instructions from Jupiter" }
+  })
+});
+var transactionsContract = oc.tag("Transactions").router({
+  submit: oc.route({ method: "POST", path: "/transactions", summary: "Submit a transaction" }).input(SubmitInputSchema).output(SubmitOutputSchema).errors({
+    BAD_REQUEST,
+    CONFLICT,
+    SIMULATION_FAILED
+  }),
+  get: oc.route({ method: "GET", path: "/transactions/{id}", summary: "Get transaction status" }).input(GetInputSchema).output(BatchStatusOutputSchema).errors({
+    NOT_FOUND
+  }),
+  resubmit: oc.route({ method: "POST", path: "/transactions/{id}/resubmit", summary: "Resubmit a transaction" }).input(ResubmitInputSchema).output(ResubmitOutputSchema).errors({
+    NOT_FOUND,
+    BAD_REQUEST
+  }),
+  getByPayer: oc.route({ method: "GET", path: "/transactions/payer/{payer}", summary: "Get transactions by payer" }).input(GetByPayerInputSchema).output(PayerBatchesOutputSchema).errors({
+    BAD_REQUEST
+  }),
+  getByPayerAndTag: oc.route({ method: "GET", path: "/transactions/payer/{payer}/tag/{tag}", summary: "Get transactions by payer and tag" }).input(GetByPayerAndTagInputSchema).output(PayerBatchesOutputSchema).errors({
+    BAD_REQUEST
+  })
+});
+var welcomePacksContract = oc.tag("Welcome Packs").router({
+  /** Public: List welcome packs for a wallet */
+  list: oc.route({ method: "GET", path: "/welcome-packs/{walletAddress}", summary: "List welcome packs for a wallet" }).input(WelcomePackListInputSchema).output(WelcomePackListOutputSchema).errors({
+    INVALID_WALLET_ADDRESS
+  }),
+  /** Protected: Create a new welcome pack */
+  create: oc.route({ method: "POST", path: "/welcome-packs", summary: "Create a new welcome pack" }).input(WelcomePackCreateInputSchema).output(WelcomePackCreateOutputSchema).errors({
+    BAD_REQUEST
+  }),
+  /** Public: Get a specific welcome pack */
+  get: oc.route({ method: "GET", path: "/welcome-packs/{walletAddress}/{packId}", summary: "Get a specific welcome pack" }).input(WelcomePackGetInputSchema).output(WelcomePackSchema).errors({
+    NOT_FOUND,
+    INVALID_WALLET_ADDRESS
+  }),
+  /** Protected: Delete a welcome pack */
+  delete: oc.route({ method: "DELETE", path: "/welcome-packs/{walletAddress}/{packId}", summary: "Delete a welcome pack" }).input(WelcomePackDeleteInputSchema).output(WelcomePackDeleteOutputSchema).errors({
+    BAD_REQUEST,
+    INVALID_WALLET_ADDRESS
+  }),
+  /** Public: Get welcome pack by pack address */
+  getByAddress: oc.route({ method: "GET", path: "/welcome-packs/address/{packAddress}", 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: oc.route({ method: "POST", path: "/welcome-packs/claim", 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: oc.route({ method: "POST", path: "/welcome-packs/invite", 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;
+var fiatContract = oc.errors({
+  UNAUTHENTICATED,
+  UNAUTHORIZED
+}).tag("Fiat").router({
+  getKycStatus: oc.route({ method: "GET", path: "/fiat/kyc/status" }).output(KycStatusOutputSchema).errors({
+    EMAIL_NOT_LINKED: { status: 401, message: "Email not linked." }
+  }),
+  initKyc: oc.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: oc.route({ method: "GET", path: "/fiat/fees" }).output(FeesOutputSchema).errors({}),
+  listBankAccounts: oc.route({ method: "GET", path: "/fiat/bank-accounts" }).output(BankAccountListOutputSchema).errors({
+    NOT_FOUND: { message: "Bridge customer ID not found", status: 404 }
+  }),
+  createBankAccount: oc.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: oc.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: oc.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: oc.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: oc.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/index.ts
-var apiContract = {
+// src/contracts/webhooks.ts
+var webhooksContract = oc.tag("Webhooks").router({
+  bridge: oc.route({ method: "POST", path: "/webhooks/bridge" }).input(BridgeWebhookInputSchema).output(BridgeWebhookOutputSchema).errors({
+    NOT_FOUND,
+    INVALID_PAYLOAD: { message: "Invalid webhook payload", status: 400 }
+  })
+});
+var apiContract = oc.router({
   health: healthContract,
   tokens: tokensContract,
   hotspots: hotspotsContract,
   swap: swapContract,
   transactions: transactionsContract,
   welcomePacks: welcomePacksContract
-};
-
-// 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;
-}
+});
+var fullApiContract = oc.router({
+  ...apiContract,
+  fiat: fiatContract,
+  webhooks: webhooksContract
+});
 
-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, HeliumPublicKeySchema, HotspotSchema, HotspotSharesSchema, HotspotTypeSchema, HotspotsDataSchema, INSUFFICIENT_FUNDS, INVALID_WALLET_ADDRESS, NOT_FOUND, OwnershipTypeSchema, PaginationInputSchema, PaginationOutputSchema, PayerBatchSummarySchema, PayerBatchesOutputSchema, PendingRewardsOutputSchema, PublicKeySchema, QuoteResponseSchema, RATE_LIMITED, ReassertLocationRequestSchema, ReassertLocationResponseSchema, 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 };