@helium/blockchain-api 0.1.3 → 0.2.1

package/dist/index.js

@@ -0,0 +1,805 @@
+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) {
+  const { url, transport = "rpc" } = options;
+  const endpoint = transport === "rpc" ? `${url}/rpc` : `${url}/api/v1`;
+  const link = new RPCLink({
+    url: endpoint,
+    fetch: (input, init) => {
+      return fetch(input, {
+        ...init,
+        credentials: "include"
+      });
+    }
+  });
+  return createORPCClient(link);
+}
+
+// src/mock-client.ts
+function createMockClient(mocks = {}) {
+  const createProxy = (path = []) => {
+    return new Proxy(() => {
+    }, {
+      get(_, prop) {
+        const newPath = [...path, prop];
+        let mockValue = mocks;
+        for (const key of newPath) {
+          if (mockValue && typeof mockValue === "object" && key in mockValue) {
+            mockValue = mockValue[key];
+          } else {
+            mockValue = void 0;
+            break;
+          }
+        }
+        if (typeof mockValue === "function") {
+          return mockValue;
+        }
+        if (mockValue && typeof mockValue === "object") {
+          return createProxy(newPath);
+        }
+        return createProxy(newPath);
+      },
+      apply(_, __, args) {
+        let mockValue = mocks;
+        for (const key of path) {
+          if (mockValue && typeof mockValue === "object" && key in mockValue) {
+            mockValue = mockValue[key];
+          } else {
+            mockValue = void 0;
+            break;
+          }
+        }
+        if (typeof mockValue === "function") {
+          return mockValue(...args);
+        }
+        throw new Error(
+          `Mock not implemented for: ${path.join(".")}. Provide a mock implementation in createMockClient().`
+        );
+      }
+    });
+  };
+  return createProxy();
+}
+var TransactionMetadataSchema = z.object({
+  type: z.string(),
+  description: z.string()
+}).catchall(z.unknown());
+var TransactionItemSchema = z.object({
+  serializedTransaction: z.string(),
+  metadata: TransactionMetadataSchema.optional()
+});
+var TransactionDataSchema = z.object({
+  transactions: z.array(TransactionItemSchema),
+  parallel: z.boolean(),
+  tag: z.string().optional()
+});
+var TransactionBatchRequestSchema = z.object({
+  transactions: z.array(TransactionItemSchema),
+  parallel: z.boolean(),
+  tag: z.string().optional()
+});
+var TransactionBatchResponseSchema = z.object({
+  batchId: z.string(),
+  message: z.string().optional()
+});
+var ErrorResponseSchema = z.object({
+  error: z.string(),
+  details: z.array(z.string()).optional()
+});
+var WalletAddressSchema = z.string().min(32).max(44);
+var PublicKeySchema = z.string().min(32).max(44);
+var PaginationInputSchema = z.object({
+  page: z.coerce.number().int().min(1).default(1),
+  limit: z.coerce.number().int().min(1).max(100).default(10)
+});
+var PaginationOutputSchema = z.object({
+  total: z.number(),
+  page: z.number(),
+  totalPages: z.number()
+});
+var HealthResponseSchema = z.object({
+  ok: z.boolean(),
+  error: z.string().optional()
+});
+var GetBalancesInputSchema = z.object({
+  walletAddress: z.string().min(32)
+});
+var TransferInputSchema = z.object({
+  walletAddress: z.string().min(32),
+  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)
+});
+var TokenAccountSchema = z.object({
+  mint: z.string(),
+  address: z.string(),
+  balance: z.string(),
+  decimals: z.number(),
+  uiAmount: z.number(),
+  symbol: z.string().optional(),
+  name: z.string().optional(),
+  logoURI: z.string().optional(),
+  priceUsd: z.number().optional(),
+  balanceUsd: z.number().optional()
+});
+var TokenBalanceDataSchema = z.object({
+  totalBalanceUsd: z.number(),
+  solBalance: z.number(),
+  solBalanceUsd: z.number(),
+  tokens: z.array(TokenAccountSchema)
+});
+var TransferOutputSchema = z.object({
+  transactionData: TransactionDataSchema
+});
+var CreateHntAccountOutputSchema = z.object({
+  transactionData: TransactionDataSchema
+});
+var HotspotTypeSchema = z.enum(["iot", "mobile", "all"]);
+var DeviceTypeSchema = z.enum([
+  "iot-gateway",
+  "wifiIndoor",
+  "wifiOutdoor",
+  "wifiDataOnly",
+  "cbrs"
+]);
+var OwnershipTypeSchema = z.enum(["owner", "direct", "fanout", "all"]);
+var HotspotSharesSchema = z.object({
+  fixed: z.string().optional(),
+  percentage: z.number().optional()
+});
+var HotspotSchema = z.object({
+  address: z.string(),
+  entityKey: z.string(),
+  name: z.string(),
+  type: HotspotTypeSchema,
+  deviceType: DeviceTypeSchema,
+  city: z.string().optional(),
+  state: z.string().optional(),
+  country: z.string().optional(),
+  asset: z.string(),
+  isOnline: z.boolean().optional(),
+  owner: z.string().optional(),
+  shares: HotspotSharesSchema.optional(),
+  ownershipType: z.string()
+});
+var GetHotspotsInputSchema = z.object({
+  walletAddress: z.string().min(32),
+  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)
+});
+var GetPendingRewardsInputSchema = z.object({
+  walletAddress: z.string().min(32)
+});
+var TransferHotspotInputSchema = z.object({
+  walletAddress: z.string().min(32),
+  hotspotPubkey: z.string().min(1),
+  recipient: z.string().min(32)
+});
+var UpdateRewardsDestinationInputSchema = z.object({
+  walletAddress: z.string().min(32),
+  hotspotPubkey: z.string().min(1),
+  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)
+});
+var RewardSplitInputSchema = z.object({
+  address: z.string().min(32),
+  type: z.enum(["percentage", "fixed"]),
+  amount: z.number()
+});
+var ScheduleInputSchema = z.object({
+  frequency: z.enum(["daily", "weekly", "monthly"]),
+  time: z.string(),
+  timezone: z.string(),
+  dayOfWeek: z.string().optional(),
+  dayOfMonth: z.string().optional()
+});
+var CreateSplitInputSchema = z.object({
+  walletAddress: z.string().min(32),
+  hotspotPubkey: z.string().min(1),
+  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)
+});
+var HotspotsDataSchema = z.object({
+  hotspots: z.array(HotspotSchema),
+  total: z.number(),
+  page: z.number(),
+  totalPages: z.number()
+});
+var ClaimRewardsOutputSchema = z.object({
+  transactionData: TransactionDataSchema
+});
+var TransferHotspotOutputSchema = z.object({
+  transactionData: TransactionDataSchema
+});
+var UpdateRewardsDestinationOutputSchema = z.object({
+  transactionData: TransactionDataSchema
+});
+var SplitShareSchema = z.object({
+  wallet: z.string(),
+  delegate: z.string(),
+  fixed: z.number(),
+  shares: z.number()
+});
+var SplitResponseSchema = z.object({
+  walletAddress: z.string(),
+  hotspotPubkey: z.string(),
+  splitAddress: z.string(),
+  shares: z.array(SplitShareSchema)
+});
+var CreateSplitOutputSchema = z.object({
+  transactionData: TransactionDataSchema
+});
+var DeleteSplitOutputSchema = z.object({
+  transactionData: TransactionDataSchema
+});
+var PendingRewardsOutputSchema = z.object({
+  pending: z.string()
+});
+var GetTokensInputSchema = z.object({
+  limit: z.coerce.number().int().min(1).max(100).default(50)
+});
+var GetQuoteInputSchema = z.object({
+  inputMint: z.string().min(1),
+  outputMint: z.string().min(1),
+  amount: z.string().min(1),
+  swapMode: z.enum(["ExactIn", "ExactOut"]).default("ExactIn"),
+  slippageBps: z.coerce.number().min(0).max(1e4).default(50)
+});
+var QuoteResponseSchema = z.object({
+  inputMint: z.string(),
+  inAmount: z.string(),
+  outputMint: z.string(),
+  outAmount: z.string(),
+  otherAmountThreshold: z.string(),
+  swapMode: z.string(),
+  slippageBps: z.number(),
+  platformFee: z.unknown().optional(),
+  priceImpactPct: z.string(),
+  routePlan: z.array(z.unknown()),
+  contextSlot: z.number().optional(),
+  timeTaken: z.number().optional()
+}).passthrough();
+var GetInstructionsInputSchema = z.object({
+  quoteResponse: QuoteResponseSchema,
+  userPublicKey: z.string().min(1),
+  destinationTokenAccount: z.string().optional(),
+  dynamicComputeUnitLimit: z.boolean().default(true),
+  prioritizationFeeLamports: z.object({
+    priorityLevelWithMaxLamports: z.object({
+      maxLamports: z.number().default(1e6),
+      priorityLevel: z.enum(["low", "medium", "high"]).default("medium")
+    })
+  }).optional()
+});
+var TokenSchema = z.object({
+  address: z.string(),
+  symbol: z.string(),
+  name: z.string(),
+  decimals: z.number(),
+  logoURI: z.string().optional(),
+  tags: z.array(z.string()).optional()
+});
+var TokenListOutputSchema = z.object({
+  tokens: z.array(TokenSchema)
+});
+var SwapTransactionDataSchema = TransactionDataSchema;
+var SubmitInputSchema = z.object({
+  transactions: z.array(TransactionItemSchema),
+  parallel: z.boolean(),
+  tag: z.string().optional()
+});
+var GetInputSchema = z.object({
+  id: z.string(),
+  commitment: z.enum(["confirmed", "finalized"])
+});
+var ResubmitInputSchema = z.object({
+  id: z.string()
+});
+var GetByPayerInputSchema = z.object({
+  payer: z.string().min(32),
+  page: z.coerce.number().int().min(1).default(1),
+  limit: z.coerce.number().int().min(1).max(100).default(20),
+  status: z.string().optional().default("pending")
+});
+var GetByPayerAndTagInputSchema = z.object({
+  payer: z.string().min(32),
+  tag: z.string(),
+  page: z.coerce.number().int().min(1).default(1),
+  limit: z.coerce.number().int().min(1).max(100).default(20),
+  status: z.string().optional().default("pending")
+});
+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: TransactionStateSchema,
+  transaction: z.unknown().optional()
+});
+var BatchStatusOutputSchema = z.object({
+  batchId: 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().nullable(),
+  jitoBundleStatus: z.unknown().optional().nullable()
+});
+var ResubmitOutputSchema = z.object({
+  success: z.boolean(),
+  message: z.string(),
+  error: z.string().optional(),
+  newSignatures: z.array(z.string()).optional()
+});
+var PayerBatchSummarySchema = z.object({
+  batchId: z.string(),
+  tag: z.string().optional(),
+  status: z.string(),
+  submissionType: z.string(),
+  parallel: z.boolean(),
+  createdAt: z.string(),
+  updatedAt: z.string(),
+  transactions: z.array(
+    z.object({
+      metadata: TransactionMetadataSchema.optional()
+    })
+  )
+});
+var PayerBatchesOutputSchema = z.object({
+  payer: z.string(),
+  batches: z.array(PayerBatchSummarySchema),
+  pagination: z.object({
+    page: z.number(),
+    limit: z.number(),
+    total: z.number(),
+    totalPages: z.number()
+  })
+});
+var WelcomePackListInputSchema = z.object({
+  walletAddress: z.string().min(32)
+});
+var WelcomePackCreateInputSchema = z.object({
+  walletAddress: z.string().min(32),
+  assetId: z.string(),
+  solAmount: z.number(),
+  rentRefund: z.string(),
+  assetReturnAddress: z.string(),
+  rewardsSplit: z.array(RewardSplitInputSchema),
+  schedule: ScheduleInputSchema,
+  lazyDistributor: z.string()
+});
+var WelcomePackGetInputSchema = z.object({
+  walletAddress: z.string().min(32),
+  packId: z.number()
+});
+var WelcomePackDeleteInputSchema = z.object({
+  walletAddress: z.string().min(32),
+  packId: z.number()
+});
+var WelcomePackGetByAddressInputSchema = z.object({
+  packAddress: z.string().min(32)
+});
+var WelcomePackClaimInputSchema = z.object({
+  packAddress: z.string().min(32),
+  walletAddress: z.string().min(32),
+  signature: z.string(),
+  expirationTs: z.string()
+});
+var WelcomePackInviteInputSchema = z.object({
+  packAddress: z.string().min(32),
+  walletAddress: z.string().min(32),
+  expirationDays: z.number().int().positive().max(365).default(7)
+});
+var WelcomePackSchema = z.object({
+  address: z.string(),
+  id: z.number(),
+  owner: z.string(),
+  asset: z.string(),
+  lazyDistributor: z.string(),
+  rewardsMint: z.string(),
+  rentRefund: z.string(),
+  solAmount: z.string(),
+  rewardsSplit: z.array(RewardSplitInputSchema),
+  rewardsSchedule: z.string(),
+  assetReturnAddress: z.string(),
+  bumpSeed: z.number(),
+  uniqueId: z.string(),
+  loading: z.boolean().optional(),
+  hotspot: HotspotSchema.nullable()
+});
+var WelcomePackListOutputSchema = z.array(WelcomePackSchema);
+var WelcomePackCreateOutputSchema = z.object({
+  welcomePack: WelcomePackSchema,
+  transactionData: TransactionDataSchema
+});
+var WelcomePackDeleteOutputSchema = z.object({
+  transactionData: TransactionDataSchema
+});
+var WelcomePackClaimOutputSchema = z.object({
+  transactionData: TransactionDataSchema
+});
+var WelcomePackInviteOutputSchema = z.object({
+  message: z.string(),
+  expirationTs: z.number()
+});
+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,
+  message: "Insufficient SOL balance to complete this transaction.",
+  data: z.object({
+    required: z.number(),
+    available: z.number()
+  })
+};
+var TRANSACTION_FAILED = {
+  status: 500,
+  message: "Transaction failed to execute.",
+  data: z.object({
+    logs: z.array(z.string()).optional(),
+    signature: z.string().optional()
+  })
+};
+var SIMULATION_FAILED = {
+  status: 400,
+  message: "Transaction simulation failed.",
+  data: z.object({
+    logs: z.array(z.string()).optional(),
+    link: z.string().optional()
+  })
+};
+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: 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 = {
+  /** 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
+var apiContract = {
+  health: healthContract,
+  tokens: tokensContract,
+  hotspots: hotspotsContract,
+  swap: swapContract,
+  transactions: transactionsContract,
+  welcomePacks: welcomePacksContract
+};
+var fullApiContract = {
+  ...apiContract,
+  fiat: fiatContract,
+  webhooks: webhooksContract
+};
+
+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 };