@helium/blockchain-api 0.3.12 → 0.11.11

package/dist/chunk-2SBYC2AH.js

@@ -0,0 +1,466 @@
+import { BridgeWebhookInputSchema, BridgeWebhookOutputSchema } from './chunk-7CTJX35S.js';
+import { INSUFFICIENT_FUNDS, INVALID_WALLET_ADDRESS, BAD_REQUEST, UNAUTHORIZED, NOT_FOUND, CONFLICT, SIMULATION_FAILED, UNAUTHENTICATED } from './chunk-6EPXJJY5.js';
+import { MigrateInputSchema, MigrateOutputSchema, MigratableHotspotsInputSchema, MigratableHotspotsOutputSchema } from './chunk-NBOSJXWK.js';
+import { ClaimInviteRequestSchema, ClaimInviteResponseSchema, CreateInviteResponseSchema, DeleteRewardContractTransactionResponseSchema, CreateRewardContractTransactionInputSchema, CreateRewardContractTransactionResponseSchema, EstimateCostToCreateRewardContractResponseSchema, FindRewardContractResponseSchema } from './chunk-4CY5D37F.js';
+import { CreateHntAccountInputSchema, CreateHntAccountOutputSchema, TransferInputSchema, TransferOutputSchema, GetBalancesInputSchema, TokenBalanceDataSchema } from './chunk-MSIA3ZUI.js';
+import { EstimateInputSchema, EstimateOutputSchema, GetByPayerAndTagInputSchema, PayerBatchesOutputSchema, GetByPayerInputSchema, ResubmitInputSchema, ResubmitOutputSchema, GetInputSchema, BatchStatusOutputSchema, SubmitInputSchema, SubmitOutputSchema } from './chunk-7R4XQ5SN.js';
+import { WelcomePackInviteInputSchema, WelcomePackInviteOutputSchema, WelcomePackClaimInputSchema, WelcomePackClaimOutputSchema, WelcomePackGetByAddressInputSchema, WelcomePackSchema, WelcomePackDeleteInputSchema, WelcomePackDeleteOutputSchema, WelcomePackGetInputSchema, WelcomePackCreateInputSchema, WelcomePackCreateOutputSchema, WelcomePackListInputSchema, WelcomePackListOutputSchema } from './chunk-T7OKPHTD.js';
+import { UpdateTransferInputSchema, UpdateTransferOutputSchema, SendFundsInputSchema, SendFundsOutputSchema, GetSendQuoteInputSchema, QuoteOutputSchema, DeleteBankAccountInputSchema, DeleteBankAccountOutputSchema, CreateBankAccountInputSchema, BankAccountSchema, BankAccountListOutputSchema, FeesOutputSchema, InitKycInputSchema, KycStatusOutputSchema } from './chunk-RD5LUTM5.js';
+import { GetInstructionsInputSchema, GetQuoteInputSchema, QuoteResponseSchema, GetTokensInputSchema, TokenListOutputSchema } from './chunk-5ZPW3MRC.js';
+import { UnassignProxiesInputSchema, UnassignProxiesResponseSchema, AssignProxiesInputSchema, AssignProxiesResponseSchema, RelinquishPositionVotesInputSchema, RelinquishPositionVotesResponseSchema, RelinquishVoteInputSchema, RelinquishVoteResponseSchema, VoteInputSchema, VoteResponseSchema, ExtendDelegationInputSchema, ExtendDelegationResponseSchema, UndelegateInputSchema, UndelegatePositionResponseSchema, ClaimDelegationRewardsInputSchema, ClaimDelegationRewardsResponseSchema, DelegatePositionInputSchema, DelegatePositionsResponseSchema, TransferPositionInputSchema, TransferPositionResponseSchema, SplitPositionInputSchema, SplitPositionResponseSchema, ResetLockupInputSchema, ResetLockupResponseSchema, FlipLockupKindInputSchema, FlipLockupKindResponseSchema, ExtendPositionInputSchema, ExtendPositionResponseSchema, ClosePositionInputSchema, ClosePositionResponseSchema, CreatePositionInputSchema, CreatePositionResponseSchema } from './chunk-LHKDTWB2.js';
+import { HealthResponseSchema } from './chunk-4RVSLJOU.js';
+import { UpdateHotspotInfoInputSchema, UpdateHotspotInfoOutputSchema, GetFundingEstimateInputSchema, FundingEstimateOutputSchema, FundAutomationInputSchema, FundAutomationOutputSchema, SetupAutomationInputSchema, SetupAutomationOutputSchema, GetAutomationStatusInputSchema, AutomationStatusOutputSchema, CloseAutomationInputSchema, CloseAutomationOutputSchema, DeleteSplitInputSchema, DeleteSplitOutputSchema, CreateSplitInputSchema, CreateSplitOutputSchema, GetSplitInputSchema, SplitResponseSchema, UpdateRewardsDestinationInputSchema, UpdateRewardsDestinationOutputSchema, TransferHotspotInputSchema, TransferHotspotOutputSchema, GetPendingRewardsInputSchema, GetPendingRewardsOutputSchema, ClaimRewardsInputSchema, ClaimRewardsOutputSchema, GetHotspotsInputSchema, HotspotsDataSchema } from './chunk-6LMSAIIW.js';
+import { WalletAddressSchema, HeliumPublicKeySchema, TransactionDataSchema } from './chunk-YVB4ENKX.js';
+import { oc } from '@orpc/contract';
+import { z } from 'zod';
+
+var healthContract = oc.tag("Health").router({
+  check: oc.route({ method: "GET", path: "/health", summary: "Health check" }).output(HealthResponseSchema),
+  testSentry: oc.route({
+    method: "GET",
+    path: "/health/test-sentry",
+    summary: "Test Sentry error reporting"
+  }).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,
+    INSUFFICIENT_FUNDS
+  })
+});
+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(GetPendingRewardsOutputSchema).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 },
+    INSUFFICIENT_FUNDS,
+    CONFLICT
+  }),
+  /** 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,
+    INSUFFICIENT_FUNDS
+  }),
+  /** 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,
+    INSUFFICIENT_FUNDS
+  }),
+  /** Protected: Close automation */
+  closeAutomation: oc.route({ method: "POST", path: "/wallet/{walletAddress}/automation/close", summary: "Close automation" }).input(CloseAutomationInputSchema).output(CloseAutomationOutputSchema).errors({
+    NOT_FOUND,
+    INSUFFICIENT_FUNDS
+  }),
+  /** Protected: Get automation status */
+  getAutomationStatus: oc.route({ method: "GET", path: "/wallet/{walletAddress}/automation/status", summary: "Get automation status" }).input(GetAutomationStatusInputSchema).output(AutomationStatusOutputSchema).errors({
+    NOT_FOUND
+  }),
+  /** Protected: Create automation */
+  createAutomation: oc.route({
+    method: "POST",
+    path: "/wallet/{walletAddress}/automation",
+    summary: "Setup automation"
+  }).input(SetupAutomationInputSchema).output(SetupAutomationOutputSchema).errors({
+    NOT_FOUND,
+    INSUFFICIENT_FUNDS
+  }),
+  /** Protected: Fund automation */
+  fundAutomation: oc.route({ method: "POST", path: "/wallet/{walletAddress}/automation/fund", summary: "Fund automation" }).input(FundAutomationInputSchema).output(FundAutomationOutputSchema).errors({
+    NOT_FOUND,
+    INSUFFICIENT_FUNDS
+  }),
+  /** Protected: Get funding estimate */
+  getFundingEstimate: oc.route({ method: "GET", path: "/wallet/{walletAddress}/automation/funding-estimate", summary: "Get funding estimate" }).input(GetFundingEstimateInputSchema).output(FundingEstimateOutputSchema).errors({}),
+  updateHotspotInfo: oc.route({ method: "POST", path: "/update-info", summary: "Update hotspot info", description: "Creates an unsigned transaction to update hotspot configuration. Requires deviceType discriminant (iot or mobile) to select the correct update path and validate against on-chain network." }).input(UpdateHotspotInfoInputSchema).output(UpdateHotspotInfoOutputSchema).errors({
+    NOT_FOUND,
+    UNAUTHORIZED,
+    BAD_REQUEST: { message: "Device type mismatch", status: 400 },
+    INSUFFICIENT_FUNDS
+  })
+});
+var governanceContract = oc.tag("Governance").prefix("/governance").router({
+  createPosition: oc.route({
+    method: "POST",
+    path: "/positions",
+    summary: "Create staking position",
+    description: "Create a new staking position with specified lockup parameters. Optionally delegate to a sub-DAO immediately."
+  }).input(CreatePositionInputSchema).errors({ BAD_REQUEST, INSUFFICIENT_FUNDS }).output(CreatePositionResponseSchema),
+  closePosition: oc.route({
+    method: "POST",
+    path: "/positions/{positionMint}/close",
+    summary: "Close staking position",
+    description: "Close an expired staking position and withdraw all deposited tokens. Position must have no active votes and lockup must be expired."
+  }).input(ClosePositionInputSchema).errors({ BAD_REQUEST, NOT_FOUND, UNAUTHORIZED, INSUFFICIENT_FUNDS }).output(ClosePositionResponseSchema),
+  extendPosition: oc.route({
+    method: "POST",
+    path: "/positions/{positionMint}/extend",
+    summary: "Extend position lockup",
+    description: "Extend the lockup period of an existing staking position."
+  }).input(ExtendPositionInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(ExtendPositionResponseSchema),
+  flipLockupKind: oc.route({
+    method: "POST",
+    path: "/positions/{positionMint}/flip-lockup",
+    summary: "Flip lockup kind",
+    description: "Switch position lockup between cliff and constant. Cliff unlocks at a specific time, constant never decays."
+  }).input(FlipLockupKindInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(FlipLockupKindResponseSchema),
+  resetLockup: oc.route({
+    method: "POST",
+    path: "/positions/{positionMint}/reset-lockup",
+    summary: "Reset position lockup",
+    description: "Reset both lockup kind and period for a position. Allows changing cliff/constant and duration in one transaction."
+  }).input(ResetLockupInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(ResetLockupResponseSchema),
+  splitPosition: oc.route({
+    method: "POST",
+    path: "/positions/{positionMint}/split",
+    summary: "Split position",
+    description: "Split tokens from an existing position into a new position with its own lockup parameters."
+  }).input(SplitPositionInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(SplitPositionResponseSchema),
+  transferPosition: oc.route({
+    method: "POST",
+    path: "/positions/{positionMint}/transfer",
+    summary: "Transfer between positions",
+    description: "Transfer tokens from one position to another. Both positions must have no active votes."
+  }).input(TransferPositionInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(TransferPositionResponseSchema),
+  delegatePositions: oc.route({
+    method: "POST",
+    path: "/positions/delegate/{subDaoMint}",
+    summary: "Delegate positions",
+    description: "Delegate one or more positions to a sub-DAO. When changing delegation (already delegated to a different sub-DAO), automatically claims pending rewards first. If many epochs need claiming, may require multiple API calls - check hasMore in the response. Automatically handles expired delegations (claim, close, re-delegate) and renewable delegations (extend expiration). Optionally enable/disable automation for reward claiming. Safe to call repeatedly with the same positions. Supports proxy voting \u2014 positions proxied to the caller are auto-detected."
+  }).input(DelegatePositionInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(DelegatePositionsResponseSchema),
+  claimDelegationRewards: oc.route({
+    method: "POST",
+    path: "/positions/claim-rewards",
+    summary: "Claim delegation rewards",
+    description: "Claim delegation rewards for one or more positions. May produce multiple transactions if rewards span many epochs. If many epochs need claiming, may require multiple API calls - check hasMore in the response. Safe to call repeatedly with the same positions - returns empty transactions when nothing left to claim."
+  }).input(ClaimDelegationRewardsInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(ClaimDelegationRewardsResponseSchema),
+  undelegatePosition: oc.route({
+    method: "POST",
+    path: "/positions/{positionMint}/undelegate",
+    summary: "Undelegate position",
+    description: "Remove delegation from a position. Automatically claims any pending rewards before undelegating. If many epochs need claiming, may require multiple API calls - check hasMore in the response. Submit the returned transactions, then call again to get remaining claims or the final undelegate transaction."
+  }).input(UndelegateInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(UndelegatePositionResponseSchema),
+  extendDelegation: oc.route({
+    method: "POST",
+    path: "/positions/{positionMint}/delegation/extend",
+    summary: "Extend delegation",
+    description: "Extend the expiration of a delegated position to the current season end."
+  }).input(ExtendDelegationInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(ExtendDelegationResponseSchema),
+  vote: oc.route({
+    method: "POST",
+    path: "/proposals/{proposalKey}/vote",
+    summary: "Vote on proposal",
+    description: "Cast votes on a proposal using one or more positions. Auto-detects owned vs proxied positions \u2014 proxied positions use proxy vote path. Automatically queues cleanup tasks to relinquish vote markers after the proposal ends. If many positions are provided, may require multiple API calls - check hasMore in the response."
+  }).input(VoteInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(VoteResponseSchema),
+  relinquishVote: oc.route({
+    method: "POST",
+    path: "/proposals/{proposalKey}/relinquish-votes",
+    summary: "Relinquish vote",
+    description: "Remove votes from a specific choice on a proposal for one or more positions. Auto-detects owned vs proxied positions \u2014 proxied positions use proxy relinquish path. If many positions are provided, may require multiple API calls - check hasMore in the response."
+  }).input(RelinquishVoteInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(RelinquishVoteResponseSchema),
+  relinquishPositionVotes: oc.route({
+    method: "POST",
+    path: "/positions/{positionMint}/relinquish-vote",
+    summary: "Relinquish all position votes",
+    description: "Remove ALL active votes from a single position across all proposals in an organization. If many votes exist, may require multiple API calls - check hasMore in the response."
+  }).input(RelinquishPositionVotesInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(RelinquishPositionVotesResponseSchema),
+  assignProxies: oc.route({
+    method: "POST",
+    path: "/proxy/{proxyKey}/assign",
+    summary: "Assign voting proxy",
+    description: "Delegate voting power to a proxy recipient for one or more positions. The proxy can vote on your behalf until the expiration time. If the recipient has already voted on open proposals, automatically propagates those votes to delegated positions via countProxyVoteV0. If many positions are provided, may require multiple API calls - check hasMore in the response."
+  }).input(AssignProxiesInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(AssignProxiesResponseSchema),
+  unassignProxies: oc.route({
+    method: "POST",
+    path: "/proxy/{proxyKey}/unassign",
+    summary: "Unassign voting proxy",
+    description: "Remove voting proxy delegation from one or more positions, returning voting power to the owner. If many positions are provided, may require multiple API calls - check hasMore in the response."
+  }).input(UnassignProxiesInputSchema).errors({ BAD_REQUEST, NOT_FOUND, INSUFFICIENT_FUNDS }).output(UnassignProxiesResponseSchema)
+});
+var rewardContract = oc.tag("Reward Contract").prefix("/hotspots").router({
+  find: oc.route({
+    method: "GET",
+    path: "/{entityPubKey}/reward-contract",
+    summary: "Get Contract",
+    description: "Retrieves the reward contract (pending or active) associated with a specific hotspot entity."
+  }).input(z.object({
+    entityPubKey: HeliumPublicKeySchema
+  })).errors({
+    NOT_FOUND,
+    BAD_REQUEST
+  }).output(FindRewardContractResponseSchema),
+  estimateCreationCost: oc.route({
+    method: "GET",
+    path: "/{entityPubKey}/reward-contract/estimate-creation-cost",
+    summary: "Estimate Creation Cost",
+    description: "Estimates the cost to create a reward contract for a specific hotspot entity."
+  }).input(CreateRewardContractTransactionInputSchema.extend({
+    entityPubKey: HeliumPublicKeySchema.describe("The public key of the hotspot entity")
+  })).output(EstimateCostToCreateRewardContractResponseSchema).errors({
+    BAD_REQUEST,
+    NOT_FOUND
+  }),
+  create: oc.route({
+    method: "POST",
+    path: "/{entityPubKey}/reward-contract",
+    summary: "Create Reward Contract",
+    description: "Assembles an unsigned transaction to create a claimable or finalized reward contract for a specific hotspot entity. If the input inlcudes a pending/claimable recipient, the contract will be created as a pending/claimable contract. If the input is defined exclusively with preset recipients, an active contract will be created directly."
+  }).input(
+    CreateRewardContractTransactionInputSchema.extend({
+      entityPubKey: HeliumPublicKeySchema.describe("The public key of the hotspot entity"),
+      signerWalletAddress: WalletAddressSchema.describe("The wallet address of the caller")
+    })
+  ).errors({
+    BAD_REQUEST,
+    CONFLICT,
+    NOT_FOUND,
+    UNAUTHORIZED,
+    // Does this belong here to guard gifted currency check?
+    INSUFFICIENT_FUNDS
+  }).output(CreateRewardContractTransactionResponseSchema),
+  delete: oc.route({
+    method: "DELETE",
+    path: "/{entityPubKey}/reward-contract",
+    summary: "Delete Pending Contract",
+    description: "Assembles an unsigned transaction to delete a reward contract (pending or active) for a specific hotspot entity."
+  }).input(
+    z.object({
+      entityPubKey: HeliumPublicKeySchema.describe("The public key of the hotspot entity"),
+      signerWalletAddress: WalletAddressSchema.describe("The wallet address of the caller")
+    })
+  ).errors({
+    BAD_REQUEST,
+    NOT_FOUND,
+    // if wallet is not the delegate
+    UNAUTHORIZED,
+    INSUFFICIENT_FUNDS
+  }).output(DeleteRewardContractTransactionResponseSchema),
+  invite: oc.route({
+    method: "POST",
+    path: "/{entityPubKey}/reward-contract/invite",
+    summary: "Create Invite",
+    description: "Assembles details required to create a shareable invite to claim a pending reward contract."
+  }).input(
+    z.object({
+      entityPubKey: HeliumPublicKeySchema.describe("The public key of the hotspot entity"),
+      signerWalletAddress: WalletAddressSchema.describe("The wallet address of the caller"),
+      expirationDays: z.number().int().positive().max(365).default(7).describe("Number of days until the invite expires")
+    })
+  ).errors({
+    // if no hotspot or contract found
+    NOT_FOUND,
+    // if the contract is not pending
+    BAD_REQUEST,
+    // if wallet is not the delegate
+    UNAUTHORIZED
+  }).output(CreateInviteResponseSchema),
+  claim: oc.route({
+    method: "POST",
+    path: "/{entityPubKey}/reward-contract/claim",
+    summary: "Claim Invite",
+    description: "Assembles an unsigned transaction which can be used to claim an invite."
+  }).input(
+    ClaimInviteRequestSchema.extend({
+      entityPubKey: HeliumPublicKeySchema.describe("The public key of the hotspot entity"),
+      signerWalletAddress: WalletAddressSchema.describe("The wallet address of the caller")
+    })
+  ).errors({
+    // if no hotspot or contract found
+    NOT_FOUND,
+    // if the contract is not pending
+    BAD_REQUEST,
+    // if wallet is not the delegate
+    UNAUTHORIZED
+  }).output(ClaimInviteResponseSchema)
+});
+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" },
+    INSUFFICIENT_FUNDS
+  })
+});
+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
+  }),
+  estimate: oc.route({ method: "POST", path: "/transactions/estimate", summary: "Estimate transaction costs" }).input(EstimateInputSchema).output(EstimateOutputSchema).errors({
+    BAD_REQUEST,
+    SIMULATION_FAILED
+  })
+});
+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,
+    CONFLICT,
+    INSUFFICIENT_FUNDS
+  }),
+  /** 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,
+    INSUFFICIENT_FUNDS
+  }),
+  /** 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 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 },
+    INSUFFICIENT_FUNDS
+  }),
+  updateTransfer: oc.route({ method: "PUT", path: "/fiat/transfer/{id}" }).input(UpdateTransferInputSchema).output(UpdateTransferOutputSchema).errors({
+    NOT_FOUND: { message: "Transfer not found", status: 404 }
+  })
+});
+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 migrationContract = oc.tag("Migration").router({
+  getHotspots: oc.route({
+    method: "GET",
+    path: "/migration/hotspots",
+    summary: "Get hotspots that can be migrated (owned directly or in welcome packs)"
+  }).input(MigratableHotspotsInputSchema).output(MigratableHotspotsOutputSchema).errors({
+    BAD_REQUEST
+  }),
+  migrate: oc.route({
+    method: "POST",
+    path: "/migration/migrate",
+    summary: "Migrate assets to a new wallet",
+    description: "Returns up to 5 transactions per call. If hasMore is true, submit the transactions then call again with nextParams."
+  }).input(MigrateInputSchema).output(MigrateOutputSchema).errors({
+    UNAUTHORIZED,
+    BAD_REQUEST,
+    NOT_FOUND,
+    INSUFFICIENT_FUNDS
+  })
+});
+var apiContract = oc.router({
+  governance: governanceContract,
+  health: healthContract,
+  tokens: tokensContract,
+  hotspots: hotspotsContract,
+  rewardContract,
+  swap: swapContract,
+  transactions: transactionsContract,
+  welcomePacks: welcomePacksContract
+});
+var fullApiContract = oc.router({
+  ...apiContract,
+  fiat: fiatContract,
+  webhooks: webhooksContract,
+  migration: migrationContract
+});
+
+export { apiContract, fiatContract, fullApiContract, governanceContract, healthContract, hotspotsContract, migrationContract, rewardContract, swapContract, tokensContract, transactionsContract, webhooksContract, welcomePacksContract };

package/dist/chunk-4CY5D37F.js

@@ -0,0 +1,176 @@
+import { TokenAmountInputSchema, TokenAmountOutputSchema, WalletAddressSchema, TransactionDataSchema } from './chunk-YVB4ENKX.js';
+import { z } from 'zod';
+
+var CRON_REGEX = /^(\*|[0-9,\-\/]+)\s+(\*|[0-9,\-\/]+)\s+(\*|[0-9,\-\/]+)\s+(\*|[0-9,\-\/]+)\s+(\*|[0-9,\-\/]+)$/;
+var RewardSchedule = z.string().regex(
+  CRON_REGEX,
+  "Invalid cron format. Expected 5 fields: minute hour day month weekday"
+).describe(
+  `UTC cron expression with 5 fields (e.g. '30 9 * * *' or '0 0 1,15 * *')`
+);
+var RecipientShareInput = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("FIXED"),
+    tokenAmount: TokenAmountInputSchema
+  }),
+  z.object({
+    type: z.literal("SHARES"),
+    shares: z.number().int().min(1).max(100).describe("Percentage share of rewards")
+  })
+]);
+var RecipientShareOutput = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("FIXED"),
+    tokenAmount: TokenAmountOutputSchema
+  }),
+  z.object({
+    type: z.literal("SHARES"),
+    shares: z.number().int().min(1).max(100).describe("Percentage share of rewards")
+  })
+]);
+var RecipientConfigInput = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("PRESET"),
+    walletAddress: WalletAddressSchema.describe(
+      "The wallet address of a preconfigured recipient"
+    ),
+    receives: RecipientShareInput
+  }).describe("A recipient that uses a preset configuration"),
+  z.object({
+    type: z.literal("CLAIMABLE"),
+    giftedCurrency: TokenAmountInputSchema.describe(
+      "The amount of currency bundled in the contract, and gifted to the claimer upon creation"
+    ),
+    receives: RecipientShareInput
+  }).describe(
+    "A recipient that in yet unknown, but will claim the pending contract"
+  )
+]);
+var RecipientConfigOutput = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("PRESET"),
+    walletAddress: WalletAddressSchema.describe(
+      "The wallet address of a preconfigured recipient"
+    ),
+    receives: RecipientShareOutput
+  }).describe("A recipient that uses a preset configuration"),
+  z.object({
+    type: z.literal("CLAIMABLE"),
+    giftedCurrency: TokenAmountOutputSchema.describe(
+      "The amount of currency bundled in the contract, and gifted to the claimer upon creation"
+    ),
+    receives: RecipientShareOutput
+  }).describe(
+    "A recipient that in yet unknown, but will claim the pending contract"
+  )
+]);
+var PendingRewardContract = z.object({
+  delegateWalletAddress: WalletAddressSchema.describe(
+    "The wallet address of the contract delegate. This wallet is capable of taking admin actions (delete) on the pending contract."
+  ),
+  recipients: z.array(RecipientConfigOutput).min(1).max(6).describe(
+    "An exhaustive list of recipients and their respective shares in the reward contract"
+  ),
+  rewardSchedule: RewardSchedule.describe(
+    "The schedule on which rewards would be distributed to recipients"
+  )
+});
+var ActiveRewardContract = z.object({
+  delegateWalletAddress: WalletAddressSchema.describe(
+    "The wallet address of the contract delegate. This wallet is capable of taking admin actions (delete) on the active contract."
+  ),
+  entityOwnerAddress: WalletAddressSchema.describe(
+    "The wallet address that owns the entity (hotspot)"
+  ),
+  recipients: z.array(
+    z.object({
+      walletAddress: WalletAddressSchema.describe(
+        "The wallet address of the reward recipient"
+      ),
+      receives: RecipientShareOutput
+    })
+  ).min(1).max(6).describe(
+    "An exhaustive list of recipients and their respective shares in the reward contract"
+  ),
+  rewardSchedule: RewardSchedule.describe(
+    "The schedule on which rewards are distributed to recipients"
+  )
+});
+var FindRewardContractResponseSchema = z.discriminatedUnion("status", [
+  z.object({
+    status: z.literal("PENDING"),
+    contract: PendingRewardContract
+  }),
+  z.object({
+    status: z.literal("ACTIVE"),
+    contract: ActiveRewardContract
+  }),
+  z.object({
+    status: z.literal("NONE")
+  })
+]);
+var CreateRewardContractTransactionInputSchema = z.object({
+  delegateWalletAddress: WalletAddressSchema.describe(
+    "The wallet address of the contract delegate. This wallet is capable of taking admin actions (delete) on the contract."
+  ),
+  recipients: z.array(RecipientConfigInput).min(1).max(6).refine((arr) => arr.filter((s) => s.type === "CLAIMABLE").length <= 1, {
+    message: "At most one recipient can be of type CLAIMABLE."
+  }).refine(
+    (arr) => {
+      const shareEntries = arr.filter((s) => s.receives.type === "SHARES");
+      if (shareEntries.length === 0) {
+        return true;
+      }
+      return shareEntries.reduce(
+        (acc, curr) => acc + (curr.receives.type === "SHARES" ? curr.receives.shares : 0),
+        0
+      ) === 100;
+    },
+    {
+      message: "Total shares must equal 100."
+    }
+  ).describe(
+    "An exhaustive list of recipients and their respective shares in the reward contract"
+  ),
+  rewardSchedule: RewardSchedule.describe(
+    "The schedule on which rewards would be distributed to recipients"
+  )
+});
+var EstimateCostToCreateRewardContractResponseSchema = z.object({
+  total: TokenAmountOutputSchema.describe("The total cost to create the contract."),
+  lineItems: z.object({
+    transactionFees: TokenAmountOutputSchema.describe("The cost of transaction fees, including funding for future scheduled transactions."),
+    rentFee: TokenAmountOutputSchema.describe("The cost of the rent fee."),
+    recipientGift: TokenAmountOutputSchema.describe("The total cost of gifted currency, bundled with the contract.")
+  }).describe("A breakdown of the costs invovled. Should sum to the total cost.")
+});
+var CreateRewardContractTransactionResponseSchema = z.object({
+  unsignedTransactionData: TransactionDataSchema.describe(
+    "The unsigned transaction data which, when signed and submitted will create the pending or finalized reward contract"
+  ),
+  estimatedSolFee: TokenAmountOutputSchema
+});
+var DeleteRewardContractTransactionResponseSchema = z.object({
+  unsignedTransactionData: TransactionDataSchema.describe(
+    "The unsigned transaction data which, when signed and submitted will delete the contract"
+  ),
+  estimatedSolFee: TokenAmountOutputSchema
+});
+var CreateInviteResponseSchema = z.object({
+  unsignedMessage: z.string().min(1).describe(
+    "The unsigned invite message which, when signed by the delegate's wallet, can be used by a recipient to claim the pending contract."
+  ),
+  expiration: z.iso.datetime()
+});
+var ClaimInviteRequestSchema = z.object({
+  delegateSignature: z.string().min(1).describe("The signed invite message provided by the contract delegate."),
+  expiration: z.iso.datetime()
+});
+var ClaimInviteResponseSchema = z.object({
+  unsignedTransactionData: TransactionDataSchema.describe(
+    "The unsigned transaction data which, when signed and submitted will claim the pending reward contract"
+  ),
+  estimatedSolFee: TokenAmountOutputSchema
+});
+
+export { ClaimInviteRequestSchema, ClaimInviteResponseSchema, CreateInviteResponseSchema, CreateRewardContractTransactionInputSchema, CreateRewardContractTransactionResponseSchema, DeleteRewardContractTransactionResponseSchema, EstimateCostToCreateRewardContractResponseSchema, FindRewardContractResponseSchema };

package/dist/chunk-4RVSLJOU.js

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+// src/schemas/health.ts
+var HealthResponseSchema = z.object({
+  ok: z.boolean(),
+  error: z.string().optional()
+});
+
+export { HealthResponseSchema };