infra-sdk-typescript 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,912 @@
+type HttpMethod = "GET" | "POST" | "PATCH" | "PUT" | "DELETE";
+type QueryValue = string | number | boolean | undefined | null;
+interface RequestOptions {
+    method: HttpMethod;
+    path: string;
+    query?: Record<string, QueryValue>;
+    body?: unknown;
+    headers?: Record<string, string>;
+    /**
+     * Sent as the `Idempotency-Key` header. Besides the header itself, its presence tells
+     * the retry logic that a connection failure is safe to retry — the server can dedupe
+     * a resubmission with the same key.
+     */
+    idempotencyKey?: string;
+    timeoutMs?: number;
+    signal?: AbortSignal;
+}
+
+/** Base class every resource namespace (`client.wallet`, `client.tokenization`, `client.indexer`) extends. */
+declare abstract class APIResource {
+    protected readonly client: InfraClient;
+    constructor(client: InfraClient);
+}
+
+/**
+ * The Infra API uses three different pagination envelopes depending on the service
+ * (see the Conventions doc). {@link Page} normalizes all three into one ergonomic type so
+ * callers can iterate any list endpoint the same way:
+ *
+ * ```ts
+ * const page = await client.tokenization.listTokens();
+ * for await (const token of page) {
+ *   console.log(token.ticker);
+ * }
+ *
+ * // or, page by page:
+ * let page = await client.wallet.getTransactionHistory();
+ * while (true) {
+ *   for (const tx of page.data) handle(tx);
+ *   if (!page.hasNextPage()) break;
+ *   page = await page.getNextPage();
+ * }
+ * ```
+ */
+declare class Page<T> implements AsyncIterable<T> {
+    readonly data: readonly T[];
+    private readonly nextParams;
+    private readonly fetchNext;
+    constructor(opts: {
+        data: readonly T[];
+        nextParams: Record<string, unknown> | null;
+        fetchNext: ((params: Record<string, unknown>) => Promise<Page<T>>) | null;
+    });
+    hasNextPage(): boolean;
+    getNextPage(): Promise<Page<T>>;
+    /** Walks every page starting with this one, yielding each `Page<T>` in turn. */
+    iterPages(): AsyncGenerator<Page<T>, void, void>;
+    /** Yields every item across all pages, fetching subsequent pages lazily as iteration proceeds. */
+    [Symbol.asyncIterator](): AsyncGenerator<T, void, void>;
+    /** Eagerly fetches every remaining page and returns all items as a single array. Use with caution on large collections. */
+    toArray(): Promise<T[]>;
+}
+/** Raw shape returned by limit/offset endpoints (currently: Wallet transaction history). */
+interface OffsetPaginatedResponse<T> {
+    items: readonly T[];
+    pagination: {
+        total: number;
+        limit: number;
+        offset: number;
+        hasMore: boolean;
+        nextOffset: number | null;
+    };
+}
+/** Raw shape returned by page/pageSize endpoints with inline totals (currently: Tokenization). */
+interface FlatPaginatedResponse<T> {
+    items: readonly T[];
+    total: number;
+    page: number;
+    pageSize: number;
+}
+/** Raw shape returned by page/limit endpoints with a `meta` block (currently: Indexer). */
+interface MetaPaginatedResponse<T> {
+    data: readonly T[];
+    meta: {
+        total: number;
+        page: number;
+        limit: number;
+        totalPages: number;
+    };
+}
+
+/**
+ * A string literal union that still accepts any other string, so autocomplete surfaces
+ * the known values without rejecting new ones the API adds before this SDK is updated.
+ */
+type LooseUnion<T extends string> = T | (string & Record<never, never>);
+/** Chain family used by the Wallet service's HD tree. */
+type ChainType = "EVM" | "SOLANA";
+/** `MAINNET` for real funds, `TESTNET` for sponsored/free test transfers. */
+type Network = "MAINNET" | "TESTNET";
+/** Lifecycle of an async Wallet transaction (transfer or sponsored sign). */
+type TransactionStatus = "PENDING" | "PROCESSING" | "COMPLETED" | "FAILED";
+/**
+ * Chain identifier used by Tokenization and the Indexer (e.g. `"BASE"`, `"ETH"`). Distinct
+ * from {@link ChainType}, which only distinguishes the EVM/Solana wallet-derivation family.
+ */
+type Chain = LooseUnion<"ATC" | "BSC" | "ETH" | "BASE" | "POL" | "SOL" | "LISK">;
+/** Per-call overrides accepted by every SDK method. */
+interface RequestOverrides {
+    /** Abort this specific call independent of the client's default timeout. */
+    signal?: AbortSignal;
+    /** Overrides the client's default request timeout, in milliseconds, for this call only. */
+    timeoutMs?: number;
+}
+/** Per-call overrides for methods that accept (or require) an `Idempotency-Key`. */
+interface IdempotentRequestOverrides extends RequestOverrides {
+    /**
+     * Client-generated key that makes this request safe to retry — a retry sent with the
+     * same key returns the original result instead of submitting again. Defaults to an
+     * auto-generated UUIDv4 when omitted; pass your own to control retries across separate
+     * SDK calls (e.g. after a process restart).
+     */
+    idempotencyKey?: string;
+}
+
+/** A derived HD wallet address. */
+interface Wallet {
+    id: string;
+    businessName: string;
+    address: string;
+    chainType: ChainType;
+    purpose: string;
+    derivationPath: string;
+    addressIndex: number;
+    isActive: boolean;
+    createdAt: string;
+    deactivatedAt: string | null;
+    metadata: Record<string, unknown> | null;
+}
+/** The minimal shape returned immediately after deriving new addresses. */
+interface GeneratedWallet {
+    address: string;
+    chainType: ChainType;
+    isActive: boolean;
+    addressIndex: number;
+}
+/** A Wallet-service on-chain transaction (transfer or sponsored sign), in any lifecycle state. */
+interface WalletTransaction {
+    id: string;
+    type: string;
+    chainType: ChainType;
+    network: Network;
+    chainId: number;
+    signerType: string;
+    fromAddress: string;
+    addressIndex: number | null;
+    toAddress: string;
+    amount: string | null;
+    /** USD-equivalent value at execution time, when available. */
+    valueUsd?: string;
+    tokenAddress: string | null;
+    data: string | null;
+    value: string | null;
+    txHash: string | null;
+    status: TransactionStatus;
+    gasUsed: string | null;
+    feeWei: string | null;
+    explorerUrl?: string;
+    explorerTxUrl?: string | null;
+    /** Present only when `status` is `FAILED`. */
+    error?: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/** Result of a local-only sign (non-EVM chain, nothing broadcast) — always returned synchronously. */
+interface SignedTransactionResult {
+    signedTransaction: string;
+}
+interface SupportedChain {
+    chainType: ChainType;
+    name: string;
+    chainId: number | null;
+    network: Network;
+}
+interface WalletBalance {
+    /** Spendable USD balance as a decimal string. */
+    balance: string;
+    currency: "USD";
+    updatedAt: string;
+}
+interface WalletCount {
+    count: number;
+}
+interface HdEnabledStatus {
+    enabled: boolean;
+}
+interface GenerateWalletsParams {
+    chainType: ChainType;
+    /** Logical tag for the addresses, e.g. `"deposit"`. */
+    purpose?: string;
+}
+interface ListWalletsParams {
+    chainType?: ChainType;
+    isActive?: boolean;
+    /** Page size. Default 50. */
+    limit?: number;
+    offset?: number;
+}
+interface GetWalletCountParams {
+    chainType?: ChainType;
+}
+interface GetWalletByAddressParams {
+    /** Disambiguates the chain when the same address string could exist on more than one. */
+    chainType?: ChainType;
+}
+interface GetWalletByAddressIndexParams {
+    chainType?: ChainType;
+}
+interface SignTransactionRequest {
+    to: string;
+    /** Native value in the chain's smallest unit. */
+    value?: string;
+    /** Calldata, hex-encoded. */
+    data?: string;
+}
+interface SignTransactionParams {
+    chainType: ChainType;
+    /** HD index of the signing wallet. */
+    addressIndex: number;
+    /** Target chain id (e.g. `8453`). Required for EVM. */
+    chainId?: number;
+    network?: Network;
+    transaction: SignTransactionRequest;
+    /**
+     * `true` = legacy synchronous mode: hold the request open for the relay outcome
+     * instead of `202` + poll. Default `false`.
+     */
+    waitForCompletion?: boolean;
+    /** HTTPS URL to receive the final transaction once execution settles. */
+    webhookUrl?: string;
+    /** Your own HMAC key (16-256 chars) for the webhook signature. Requires `webhookUrl`. */
+    webhookSecret?: string;
+}
+interface DeactivateWalletParams {
+    chainType?: ChainType;
+}
+interface InitiateTransferParams {
+    /** Sending wallet — either its full on-chain address or its HD `addressIndex`. */
+    fromAddress: string | number;
+    toAddress: string;
+    /** Amount in the token's smallest unit (e.g. `"1000000"`). */
+    amount: string;
+    chainType: ChainType;
+    /** Target chain id. Use `84532` (Base Sepolia) for sponsored testnet transfers. Required for EVM. */
+    chainId?: number;
+    network?: Network;
+    /** ERC-20 token contract. Omit for a native transfer. */
+    tokenAddress?: string;
+    /** Set `true` to transfer cNGN. Default `false`. */
+    cNGN?: boolean;
+    /**
+     * `true` = legacy synchronous mode: hold the request open for the final outcome
+     * (`201`/`422`) instead of `202` + poll. Default `false`.
+     */
+    waitForCompletion?: boolean;
+    webhookUrl?: string;
+    webhookSecret?: string;
+}
+interface GetTransactionHistoryParams {
+    chainType?: ChainType;
+    /** e.g. `"COMPLETED"`. */
+    status?: TransactionStatus;
+    /** Page size. Default 20. */
+    limit?: number;
+    offset?: number;
+}
+
+/**
+ * The Wallet service — manages the business HD wallet tree: deriving addresses, reading
+ * them, signing and submitting transactions, and tracking the USD balance used to pay gas
+ * on mainnet transfers.
+ *
+ * [Initiate transfer]{@link WalletResource.initiateTransfer} and sponsored
+ * [Sign transaction]{@link WalletResource.signTransaction} are asynchronous by default:
+ * they return a `PENDING` transaction immediately, and you poll
+ * {@link WalletResource.getTransaction} (or supply `webhookUrl`) for the outcome. Pass
+ * `waitForCompletion: true` for the legacy synchronous behavior.
+ */
+declare class WalletResource extends APIResource {
+    /** Derives one or more new addresses on the business HD tree. Requires `wallet.hd.generate`. */
+    generateWallets(params: GenerateWalletsParams, overrides?: IdempotentRequestOverrides): Promise<GeneratedWallet[]>;
+    /**
+     * Lists derived wallets for the business. Requires `wallet.hd.read`.
+     *
+     * Note: unlike {@link getTransactionHistory}, the API does not return pagination
+     * metadata for this endpoint — it always answers with a plain array sized by `limit`.
+     */
+    listWallets(params?: ListWalletsParams, overrides?: RequestOverrides): Promise<Wallet[]>;
+    /** Returns the number of derived wallets, optionally filtered by chain. Requires `wallet.hd.read`. */
+    getWalletCount(params?: GetWalletCountParams, overrides?: RequestOverrides): Promise<WalletCount>;
+    /** Reports whether HD wallets are enabled for the business. Requires `wallet.hd.read`. */
+    getHdEnabled(overrides?: RequestOverrides): Promise<HdEnabledStatus>;
+    /** Fetches a single wallet by its on-chain address. Requires `wallet.hd.read`. */
+    getWalletByAddress(address: string, params?: GetWalletByAddressParams, overrides?: RequestOverrides): Promise<Wallet>;
+    /** Fetches a wallet by its HD `addressIndex`. Requires `wallet.hd.read`. */
+    getWalletByAddressIndex(addressIndex: number, params?: GetWalletByAddressIndexParams, overrides?: RequestOverrides): Promise<Wallet>;
+    /**
+     * Signs (and, where applicable, sponsors and submits) a transaction from a derived
+     * wallet. Requires `wallet.hd.sign`.
+     *
+     * Returns a {@link SignedTransactionResult} for local-only signing (a non-EVM chain
+     * with `addressIndex` — nothing broadcast), or a {@link WalletTransaction} for a
+     * sponsored sign (async `PENDING` by default, or the settled result with
+     * `waitForCompletion: true`).
+     */
+    signTransaction(params: SignTransactionParams, overrides?: IdempotentRequestOverrides): Promise<SignedTransactionResult | WalletTransaction>;
+    /** Deactivates a wallet so it is no longer used for new operations. Requires `wallet.hd.deactivate`. */
+    deactivateWallet(walletId: string, params?: DeactivateWalletParams, overrides?: RequestOverrides): Promise<null>;
+    /** Lists the chains the platform can sign and broadcast on. */
+    getSupportedChains(overrides?: RequestOverrides): Promise<SupportedChain[]>;
+    /**
+     * Submits a token (or native) transfer from a derived wallet. Requires
+     * `wallet.transfer.create`.
+     *
+     * On a `422` (transfer reverted after broadcast, `waitForCompletion: true` only), the
+     * thrown {@link UnprocessableEntityError} still carries the failed transaction — read it
+     * from `error.body` (shaped like `{ data: WalletTransaction }`) if you need the details
+     * rather than just the message.
+     */
+    initiateTransfer(params: InitiateTransferParams, overrides?: IdempotentRequestOverrides): Promise<WalletTransaction>;
+    /**
+     * Returns a paginated history of the business's transactions. Requires
+     * `wallet.transfer.read`.
+     *
+     * ```ts
+     * const page = await client.wallet.getTransactionHistory({ status: "COMPLETED" });
+     * for await (const tx of page) {
+     *   console.log(tx.id, tx.status);
+     * }
+     * ```
+     */
+    getTransactionHistory(params?: GetTransactionHistoryParams, overrides?: RequestOverrides): Promise<Page<WalletTransaction>>;
+    /**
+     * Fetches a single transaction record — the authoritative view of a transfer's outcome.
+     * Poll this after an async `202` until `status` is `COMPLETED` or `FAILED`. Requires
+     * `wallet.transfer.read`.
+     */
+    getTransaction(id: string, overrides?: RequestOverrides): Promise<WalletTransaction>;
+    /** Returns the business's spendable USD balance, used to pay gas on mainnet transfers. Requires `wallet.balance.read`. */
+    getBalance(overrides?: RequestOverrides): Promise<WalletBalance>;
+}
+
+type TokenType = "ASSET" | "YIELD_BEARING";
+type TokenStatus = LooseUnion<"PENDING" | "ACTIVE" | "PAUSED">;
+type TokenTransactionType = LooseUnion<"MINT" | "BURN" | "TRANSFER">;
+type TokenTransactionStatus = LooseUnion<"PENDING" | "CONFIRMED" | "FAILED">;
+interface YieldParams {
+    /** Annual yield rate as a percentage, e.g. `5.5` for 5.5%. */
+    annualRate: number;
+    /** Maturity date, `YYYY-MM-DD`. */
+    maturityDate: string;
+    /** First coupon date, `YYYY-MM-DD`. */
+    firstCouponDate: string;
+    /** Coupon interval, in days. */
+    couponInterval: number;
+    /** Day-count convention, e.g. `"ACT_365"`. */
+    dayCount: string;
+    /** Face value per token, in fiat major units. */
+    faceValuePerToken: number;
+    /** Grace period, in seconds. */
+    gracePeriod?: number;
+    callable?: boolean;
+    /** Call date, `YYYY-MM-DD`. Only meaningful when `callable` is `true`. */
+    callDate?: string;
+}
+interface CreateTokenParams {
+    /** Short token symbol, e.g. `"ACMB3"`. */
+    ticker: string;
+    name: string;
+    /** Issue price per token, in fiat major units. */
+    price?: number;
+    chain: Chain;
+    decimals: number;
+    /** Asset class, e.g. `"MONEY_MARKET"`. */
+    assetClass: string;
+    tokenType: TokenType;
+    /** Maximum holders; `0` for unlimited. */
+    maxShareholders?: number;
+    /** Per-investor cap; `0` for unlimited. */
+    maxTokensPerInvestor?: number;
+    /** Lock-up duration, in seconds; `0` for none. */
+    lockUpDuration?: number;
+    /** Required when `tokenType` is `"YIELD_BEARING"`. */
+    yieldParams?: YieldParams;
+}
+/** Result of a token deployment submission — `status` starts `PENDING` until the chain confirms it. */
+interface TokenDeploymentResult {
+    id: string;
+    chain: Chain;
+    status: TokenStatus;
+    operationRef: string;
+    tokenAdmin: string;
+    txHash: string;
+}
+/** Summary shape returned by {@link TokenizationResource.listTokens}. */
+interface TokenSummary {
+    id: string;
+    projectId: string;
+    businessId: string;
+    ticker: string;
+    name: string;
+    assetClass: string;
+    tokenType: TokenType;
+    decimals: number;
+    totalSupply: string;
+    circulatingSupply: string;
+    chain: Chain;
+    status: TokenStatus;
+    deploymentRef: string;
+    contractAddress: string;
+    createdAt: string;
+    updatedAt: string;
+    createdBy: string;
+}
+/** Per-chain deployment details within a {@link TokenDetail}. */
+interface TokenChainDeployment {
+    id: string;
+    chain: Chain;
+    tokenAdmin: string;
+    decimals: number;
+    status: TokenStatus;
+    deploymentRef: string;
+    contractAddress: string;
+}
+/** Detailed shape returned by {@link TokenizationResource.getToken}, including every chain it's deployed on. */
+interface TokenDetail {
+    id: string;
+    projectId: string;
+    businessId: string;
+    ticker: string;
+    name: string;
+    price?: string | number;
+    assetClass: string;
+    tokenType: TokenType;
+    status: TokenStatus;
+    createdAt: string;
+    updatedAt: string;
+    chains: TokenChainDeployment[];
+}
+interface ListTokensParams {
+    /** Default `1`. */
+    page?: number;
+    /** Default `20`. */
+    pageSize?: number;
+}
+interface BurnTokenParams {
+    tokenId: string;
+    chain: Chain;
+    /** Holder address to burn from. */
+    fromAddress: string;
+    /** Amount to burn, in token units. */
+    amount: number;
+    /** Optional note recorded with the operation. */
+    memo?: string;
+}
+interface MintTokenParams {
+    tokenId: string;
+    chain: Chain;
+    /** Recipient wallet address. */
+    toAddress: string;
+    /** Amount to mint, in token units. */
+    amount: number;
+    memo?: string;
+}
+interface TransferTokenParams {
+    tokenId: string;
+    chain: Chain;
+    fromAddress: string;
+    toAddress: string;
+    /** Amount to transfer, in token units. */
+    amount: number;
+    memo?: string;
+}
+/** Result of {@link TokenizationResource.mintToken} / {@link TokenizationResource.burnToken}. */
+interface TokenOperationResult {
+    operationRef: string;
+    transactionId: string;
+    txHash: string;
+}
+/** Result of {@link TokenizationResource.transferToken} — the settled on-chain transfer record. */
+interface TokenTransferResult {
+    id: string;
+    type: string;
+    chainType: ChainType;
+    network: Network;
+    chainId: number;
+    signerType: string;
+    fromAddress: string;
+    addressIndex: number | null;
+    toAddress: string;
+    /** Amount in token units, as a decimal string. */
+    amount: string;
+    tokenAddress: string | null;
+    data: string | null;
+    value: string | null;
+    txHash: string;
+    status: TokenTransactionStatus;
+    gasUsed: string | null;
+    feeWei: string | null;
+    createdAt: string;
+    updatedAt: string;
+}
+interface RegisterTokenWalletParams {
+    tokenId: string;
+    chain: Chain;
+    walletAddress: string;
+}
+interface RegisterTokenWalletResult {
+    tokenId: string;
+    chain: Chain;
+    walletAddress: string;
+}
+interface GetTokenHoldersParams {
+    tokenId: string;
+    chain?: Chain;
+    page?: number;
+    pageSize?: number;
+}
+interface TokenHolder {
+    walletAddress: string;
+    /** Balance in token units, as a decimal string. */
+    balance: string;
+}
+interface ListTokenTransactionsParams {
+    tokenId?: string;
+    page?: number;
+    pageSize?: number;
+}
+/** A recorded on-chain operation against a token (mint, burn, or transfer). */
+interface TokenTransactionRecord {
+    id: string;
+    tokenId: string;
+    chain: Chain;
+    projectId?: string;
+    type: TokenTransactionType;
+    status: TokenTransactionStatus;
+    fromAddress?: string;
+    toAddress?: string;
+    /** Amount in token units, as a decimal string. */
+    amount: string;
+    txHash: string;
+    blockNumber?: number;
+    blockHash?: string;
+    gasUsed?: string;
+    feeWei?: string;
+    operationRef?: string;
+    memo?: string;
+    createdAt?: string;
+    confirmedAt?: string;
+}
+interface UpdateTokenYieldParams {
+    /** Yield-bearing token id. */
+    tokenId: string;
+    chain: Chain;
+    /** New annual yield rate, as a percentage. */
+    annualRate: number;
+}
+interface DistributeYieldParams {
+    tokenId: string;
+    chain: Chain;
+    /** Amount to fund the distribution, in fiat major units. */
+    fundAmount: number;
+    /** Seconds after which unclaimed funds may be reclaimed. */
+    reclaimAfter?: number;
+    memo?: string;
+}
+interface PayCouponParams {
+    tokenId: string;
+    chain: Chain;
+    /** Push the coupon to investors instead of letting them claim it. */
+    pushYield?: boolean;
+    reclaimAfter?: number;
+    memo?: string;
+}
+interface ClaimYieldParams {
+    tokenId: string;
+    chain: Chain;
+    /** HD address index of the claiming investor. */
+    investorAddressIndex: number;
+    /** Distribution snapshot to claim against. */
+    snapshotId: number;
+}
+interface RedeemPrincipalParams {
+    tokenId: string;
+    chain: Chain;
+    /** Push redeemed funds to investors instead of letting them claim. */
+    pushYield?: boolean;
+}
+/** Result of a yield operation that only returns a transaction hash. */
+interface YieldTxResult {
+    txHash: string;
+}
+/** Result of a yield operation that also returns an operation reference (distribute, pay-coupon). */
+interface YieldOperationResult {
+    operationRef: string;
+    txHash: string;
+}
+
+/**
+ * The Tokenization service — issues and manages tokenized real-world assets: deployment,
+ * mint/burn/transfer, wallet whitelisting, holder balances, and the yield lifecycle
+ * (rate updates, coupon payments, claims, and principal redemption) for `YIELD_BEARING`
+ * tokens.
+ */
+declare class TokenizationResource extends APIResource {
+    /**
+     * Issues a new tokenized asset and deploys it on the target chain. Returns immediately
+     * with a `PENDING` token plus a deployment `operationRef` and `txHash` — poll
+     * {@link getToken} until `status` is `ACTIVE`. Supply `yieldParams` for a
+     * `YIELD_BEARING` token.
+     */
+    createToken(params: CreateTokenParams, overrides?: RequestOverrides): Promise<TokenDeploymentResult>;
+    /**
+     * Returns a paginated list of tokens for the calling project.
+     *
+     * ```ts
+     * const page = await client.tokenization.listTokens();
+     * for await (const token of page) console.log(token.ticker, token.status);
+     * ```
+     */
+    listTokens(params?: ListTokensParams, overrides?: RequestOverrides): Promise<Page<TokenSummary>>;
+    /** Fetches a single token by id, including its per-chain deployment details. */
+    getToken(id: string, overrides?: RequestOverrides): Promise<TokenDetail>;
+    /** Mints new units of a token to a recipient address. */
+    mintToken(params: MintTokenParams, overrides?: RequestOverrides): Promise<TokenOperationResult>;
+    /** Burns units of a token from a holder address. */
+    burnToken(params: BurnTokenParams, overrides?: RequestOverrides): Promise<TokenOperationResult>;
+    /** Transfers token units between holder addresses. */
+    transferToken(params: TransferTokenParams, overrides?: RequestOverrides): Promise<TokenTransferResult>;
+    /** Registers (whitelists) a wallet address so it can hold a given token. */
+    registerWallet(params: RegisterTokenWalletParams, overrides?: RequestOverrides): Promise<RegisterTokenWalletResult>;
+    /** Returns the paginated list of holder wallet addresses and balances for a token on a chain. */
+    getTokenHolders(params: GetTokenHoldersParams, overrides?: RequestOverrides): Promise<Page<TokenHolder>>;
+    /** Fetches a single token transaction by its reference. */
+    getTokenTransaction(ref: string, overrides?: RequestOverrides): Promise<TokenTransactionRecord>;
+    /** Returns token transactions, optionally filtered by token. */
+    listTokenTransactions(params?: ListTokenTransactionsParams, overrides?: RequestOverrides): Promise<Page<TokenTransactionRecord>>;
+    /** Updates the annual yield rate for a yield-bearing token. */
+    updateYield(params: UpdateTokenYieldParams, overrides?: RequestOverrides): Promise<YieldTxResult>;
+    /** Funds and distributes a yield payout to holders. Unclaimed funds may be reclaimed after `reclaimAfter`. */
+    distributeYield(params: DistributeYieldParams, overrides?: RequestOverrides): Promise<YieldOperationResult>;
+    /** Pays the scheduled coupon for a yield-bearing token. Set `pushYield` to push funds rather than let investors claim. */
+    payCoupon(params: PayCouponParams, overrides?: RequestOverrides): Promise<YieldOperationResult>;
+    /** Claims an investor's yield for a given distribution snapshot. */
+    claimYield(params: ClaimYieldParams, overrides?: RequestOverrides): Promise<YieldTxResult>;
+    /** Redeems principal to holders at maturity. Set `pushYield` to push funds rather than let investors claim. */
+    redeemPrincipal(params: RedeemPrincipalParams, overrides?: RequestOverrides): Promise<YieldTxResult>;
+}
+
+type SubscriptionStatus = LooseUnion<"active" | "paused" | "deleted">;
+type EventFamily = "EVM" | "SOL";
+type EventKind = LooseUnion<"onchain" | "derived">;
+/** A Blockchain Events subscription streaming decoded contract events to your webhook. */
+interface IndexerSubscription {
+    id: string;
+    projectId: string;
+    network: Chain;
+    contractAddress: string;
+    webhookUrl: string;
+    /** Subscribed event catalog keys, e.g. `["transfer", "burn"]`. */
+    events: string[];
+    status: SubscriptionStatus;
+    createdBy: string;
+    createdAt: string;
+    updatedAt: string;
+    lastDeliveryAt: string | null;
+    deliveredCount: number;
+    failedCount: number;
+    droppedCount: number;
+}
+/**
+ * An {@link IndexerSubscription} augmented with the HMAC signing secret. Only returned by
+ * {@link IndexerResource.createSubscription} and {@link IndexerResource.rotateSigningSecret}
+ * — the secret is never shown again after that response, so store it immediately.
+ */
+interface IndexerSubscriptionWithSecret extends IndexerSubscription {
+    signingSecret: string;
+    secretWarning: string;
+}
+interface CreateSubscriptionParams {
+    network: Chain;
+    /** Contract to watch (1-128 chars). */
+    contractAddress: string;
+    /** HTTPS URL to deliver events to. */
+    webhookUrl: string;
+    /** Catalog keys to subscribe to. Omit to subscribe to all events for the contract. */
+    events?: string[];
+}
+interface ListSubscriptionsParams {
+    /** Default `1`. */
+    page?: number;
+    /** Default `20`. */
+    limit?: number;
+}
+interface UpdateSubscriptionParams {
+    /** New HTTPS URL. */
+    webhookUrl?: string;
+    /** Replacement event keys (at least one). */
+    events?: string[];
+    /** Use {@link IndexerResource.deleteSubscription} to remove a subscription instead of setting a "deleted" status. */
+    status?: "active" | "paused";
+}
+interface ListEventCatalogParams {
+    family?: EventFamily;
+}
+/** A subscribable event key in the Blockchain Events catalog. */
+interface EventCatalogEntry {
+    key: string;
+    family: EventFamily;
+    kind: EventKind;
+    label: string;
+    /** Solidity event signature, e.g. `"Transfer(address,address,uint256)"`. */
+    signature: string;
+}
+
+/**
+ * The Blockchain Events (Indexer) service — subscribe to decoded on-chain events for a
+ * contract and receive them at your webhook, signed with a per-subscription secret.
+ *
+ * Every operation requires a token bound to a project and business, and is gated on a
+ * capability granted by your plan (e.g. `indexer.subscribe.evm`).
+ */
+declare class IndexerResource extends APIResource {
+    /**
+     * Creates a subscription that streams decoded events for a contract to your webhook.
+     * Requires the network's subscribe capability (e.g. `indexer.subscribe.evm`).
+     *
+     * The response includes `signingSecret` only on creation — store it securely, it is
+     * never shown again (see {@link rotateSigningSecret} if you lose it).
+     */
+    createSubscription(params: CreateSubscriptionParams, overrides?: RequestOverrides): Promise<IndexerSubscriptionWithSecret>;
+    /** Lists the project's subscriptions. Requires `indexer.subscription.list`. */
+    listSubscriptions(params?: ListSubscriptionsParams, overrides?: RequestOverrides): Promise<Page<IndexerSubscription>>;
+    /** Fetches one subscription. Requires `indexer.subscription.read`. */
+    getSubscription(id: string, overrides?: RequestOverrides): Promise<IndexerSubscription>;
+    /** Updates a subscription's webhook, events, or status. At least one field is required. Requires `indexer.subscription.update`. */
+    updateSubscription(id: string, params: UpdateSubscriptionParams, overrides?: RequestOverrides): Promise<IndexerSubscription>;
+    /** Soft-deletes a subscription (`status` becomes `"deleted"`; deliveries stop). Requires `indexer.subscription.delete`. */
+    deleteSubscription(id: string, overrides?: RequestOverrides): Promise<IndexerSubscription>;
+    /**
+     * Generates a new signing secret and invalidates the old one. Requires
+     * `indexer.subscription.rotate_secret`. The response includes the new `signingSecret`
+     * once — store it immediately.
+     */
+    rotateSigningSecret(id: string, overrides?: RequestOverrides): Promise<IndexerSubscriptionWithSecret>;
+    /** Returns the catalog of subscribable event keys. Requires `indexer.subscription.list`. */
+    listEventCatalog(params?: ListEventCatalogParams, overrides?: RequestOverrides): Promise<EventCatalogEntry[]>;
+}
+
+interface InfraClientOptions {
+    /** Your Convexity Infra project API key (`sk_live_...` or `sk_test_...`). Exchanged internally for a bearer token. */
+    apiKey: string;
+    /** Overrides the API host. Defaults to `"https://api.withconvexity.com"`. */
+    baseURL?: string;
+    /** Space-separated OAuth scopes to request for minted tokens. Omit for full access. */
+    scope?: string;
+    /** Default per-request timeout in milliseconds. Default 30000. */
+    timeoutMs?: number;
+    /** Default number of retries for rate limits, service-unavailable responses, and safe connection errors. Default 2. */
+    maxRetries?: number;
+    /** Override the fetch implementation (mainly for testing). Defaults to the global `fetch`. */
+    fetch?: typeof fetch;
+}
+/**
+ * Client for the Convexity Infra API — Wallet, Tokenization, and Blockchain Events (Indexer).
+ *
+ * ```ts
+ * import { InfraClient } from "infra-sdk-typescript";
+ *
+ * const infra = new InfraClient({ apiKey: process.env.INFRA_API_KEY! });
+ * const balance = await infra.wallet.getBalance();
+ * ```
+ */
+declare class InfraClient {
+    readonly wallet: WalletResource;
+    readonly tokenization: TokenizationResource;
+    readonly indexer: IndexerResource;
+    private readonly http;
+    private readonly auth;
+    constructor(options: InfraClientOptions);
+    /**
+     * Low-level escape hatch that issues a raw request against the Infra API using this
+     * client's auth, retry, and timeout configuration. The typed resource methods
+     * (`client.wallet.*`, `client.tokenization.*`, `client.indexer.*`) are built on top of
+     * this and should be preferred — reach for this only to call an endpoint this SDK
+     * version doesn't wrap yet.
+     */
+    request<T>(options: RequestOptions): Promise<T>;
+}
+
+/** Base class for every error raised by this SDK. */
+declare class InfraError extends Error {
+    constructor(message: string);
+}
+/** The request never reached the server (DNS/TCP/TLS failure, aborted connection, etc). */
+declare class InfraConnectionError extends InfraError {
+    readonly cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined);
+}
+declare class InfraConnectionTimeoutError extends InfraConnectionError {
+    constructor(timeoutMs: number);
+}
+/**
+ * Constructed via {@link errorFromResponse}, which picks the most specific subclass for
+ * the HTTP status code — prefer catching a subclass (e.g. {@link RateLimitError}) over
+ * this base class when you need to branch on the failure kind.
+ */
+declare class InfraAPIError extends InfraError {
+    readonly status: number;
+    /** Field-level validation messages, when the server included an `errors` array. */
+    readonly errors: readonly string[] | undefined;
+    /** The raw, parsed JSON response body, for callers that need fields this SDK doesn't model. */
+    readonly body: unknown;
+    /** Response headers, lower-cased keys. */
+    readonly headers: Readonly<Record<string, string>>;
+    constructor(status: number, message: string, 
+    /** Field-level validation messages, when the server included an `errors` array. */
+    errors: readonly string[] | undefined, 
+    /** The raw, parsed JSON response body, for callers that need fields this SDK doesn't model. */
+    body: unknown, 
+    /** Response headers, lower-cased keys. */
+    headers: Readonly<Record<string, string>>);
+}
+declare class BadRequestError extends InfraAPIError {
+}
+declare class AuthenticationError extends InfraAPIError {
+}
+declare class PaymentRequiredError extends InfraAPIError {
+}
+declare class PermissionDeniedError extends InfraAPIError {
+}
+declare class NotFoundError extends InfraAPIError {
+}
+declare class ConflictError extends InfraAPIError {
+}
+declare class UnprocessableEntityError extends InfraAPIError {
+}
+declare class RateLimitError extends InfraAPIError {
+    /** Seconds to wait before retrying, from the response body's `retryAfter` or a `Retry-After` header. */
+    readonly retryAfterSeconds: number | undefined;
+    constructor(status: number, message: string, errors: readonly string[] | undefined, body: unknown, headers: Readonly<Record<string, string>>, 
+    /** Seconds to wait before retrying, from the response body's `retryAfter` or a `Retry-After` header. */
+    retryAfterSeconds: number | undefined);
+}
+declare class InternalServerError extends InfraAPIError {
+}
+declare class ServiceUnavailableError extends InfraAPIError {
+}
+declare class UnknownAPIError extends InfraAPIError {
+}
+/** Raised by `POST /v1/oauth/token` failures, which use an OAuth 2.0 error body instead of the standard envelope. */
+declare class InfraAuthTokenError extends InfraError {
+    readonly status: number;
+    readonly error: string;
+    readonly errorDescription: string | undefined;
+    constructor(status: number, error: string, errorDescription: string | undefined);
+}
+declare class WebhookSignatureVerificationError extends InfraError {
+}
+
+interface VerifyWalletWebhookOptions {
+    /** The exact, unparsed request body as received (Buffer or string) — do not re-serialize parsed JSON. */
+    payload: string | Buffer;
+    /** Value of the `x-wallet-timestamp` header. */
+    timestampHeader: string;
+    /** Value of the `x-wallet-signature` header. */
+    signatureHeader: string;
+    /** The `webhookSecret` you supplied when creating the transfer/sign request. */
+    secret: string;
+    /** How old (in seconds) a timestamp may be before it's rejected as a possible replay. Default 300 (5 minutes). */
+    toleranceSeconds?: number;
+}
+/**
+ * Verifies a Wallet outcome webhook delivery (`wallet.transfer.completed` /
+ * `wallet.transfer.failed` / `wallet.sign.completed` / `wallet.sign.failed`).
+ *
+ * The signature is `HMAC-SHA256("<timestamp>.<rawBody>")`, hex-encoded, and the delivery
+ * is rejected if the timestamp is older than `toleranceSeconds` to block replay attacks.
+ *
+ * @throws {WebhookSignatureVerificationError} if the timestamp is missing/stale or the signature doesn't match.
+ */
+declare function verifyWalletWebhookSignature(options: VerifyWalletWebhookOptions): void;
+interface VerifyIndexerWebhookOptions {
+    /** The exact, unparsed request body as received (Buffer or string) — do not re-serialize parsed JSON. */
+    payload: string | Buffer;
+    /** Value of the `X-Indexer-Signature` header. */
+    signatureHeader: string;
+    /** The subscription's `signingSecret`, returned once on creation or secret rotation. */
+    secret: string;
+}
+/**
+ * Verifies a Blockchain Events (Indexer) webhook delivery. The signature is
+ * `HMAC-SHA256(rawBody)`, hex-encoded, with no timestamp component.
+ *
+ * @throws {WebhookSignatureVerificationError} if the signature doesn't match.
+ */
+declare function verifyIndexerWebhookSignature(options: VerifyIndexerWebhookOptions): void;
+
+/** Generates a UUIDv4 suitable for use as an `Idempotency-Key` header value. */
+declare function generateIdempotencyKey(): string;
+
+export { AuthenticationError, BadRequestError, type BurnTokenParams, type Chain, type ChainType, type ClaimYieldParams, ConflictError, type CreateSubscriptionParams, type CreateTokenParams, type DeactivateWalletParams, type DistributeYieldParams, type EventCatalogEntry, type EventFamily, type EventKind, type FlatPaginatedResponse, type GenerateWalletsParams, type GeneratedWallet, type GetTokenHoldersParams, type GetTransactionHistoryParams, type GetWalletByAddressIndexParams, type GetWalletByAddressParams, type GetWalletCountParams, type HdEnabledStatus, type HttpMethod, type IdempotentRequestOverrides, IndexerResource, type IndexerSubscription, type IndexerSubscriptionWithSecret, InfraAPIError, InfraAuthTokenError, InfraClient, type InfraClientOptions, InfraConnectionError, InfraConnectionTimeoutError, InfraError, type InitiateTransferParams, InternalServerError, type ListEventCatalogParams, type ListSubscriptionsParams, type ListTokenTransactionsParams, type ListTokensParams, type ListWalletsParams, type LooseUnion, type MetaPaginatedResponse, type MintTokenParams, type Network, NotFoundError, type OffsetPaginatedResponse, Page, type PayCouponParams, PaymentRequiredError, PermissionDeniedError, type QueryValue, RateLimitError, type RedeemPrincipalParams, type RegisterTokenWalletParams, type RegisterTokenWalletResult, type RequestOptions, type RequestOverrides, ServiceUnavailableError, type SignTransactionParams, type SignTransactionRequest, type SignedTransactionResult, type SubscriptionStatus, type SupportedChain, type TokenChainDeployment, type TokenDeploymentResult, type TokenDetail, type TokenHolder, type TokenOperationResult, type TokenStatus, type TokenSummary, type TokenTransactionRecord, type TokenTransactionStatus, type TokenTransactionType, type TokenTransferResult, type TokenType, TokenizationResource, type TransactionStatus, type TransferTokenParams, UnknownAPIError, UnprocessableEntityError, type UpdateSubscriptionParams, type UpdateTokenYieldParams, type VerifyIndexerWebhookOptions, type VerifyWalletWebhookOptions, type Wallet, type WalletBalance, type WalletCount, WalletResource, type WalletTransaction, WebhookSignatureVerificationError, type YieldOperationResult, type YieldParams, type YieldTxResult, generateIdempotencyKey, verifyIndexerWebhookSignature, verifyWalletWebhookSignature };