@helium/blockchain-api 0.1.2 → 0.2.0

package/dist/index.js

@@ -0,0 +1,852 @@
+import { createORPCClient } from '@orpc/client';
+import { RPCLink } from '@orpc/client/fetch';
+import { z } from 'zod';
+
+// 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 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()
+}).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()
+});
+
+// src/schemas/tokens.ts
+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
+});
+
+// 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",
+  "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 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)
+});
+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 TransactionStatusSchema = z.object({
+  signature: z.string(),
+  status: z.string(),
+  transaction: z.unknown().optional()
+});
+var BatchStatusOutputSchema = z.object({
+  batchId: z.string(),
+  status: z.string(),
+  submissionType: z.string(),
+  parallel: z.boolean(),
+  transactions: z.array(TransactionStatusSchema),
+  jitoBundleId: z.string().optional(),
+  jitoBundleStatus: z.unknown().optional()
+});
+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()
+});
+
+// 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 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 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" }
+    }
+  }
+};
+
+// src/contracts/index.ts
+var apiContract = {
+  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;
+}
+
+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 };