@glamsystems/glam-sdk 1.1.0-alpha.6 → 1.1.0

package/src/client/cctp.d.ts

@@ -0,0 +1,164 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, VersionedTransaction, TransactionSignature, Keypair, Commitment, Finality, TransactionInstruction, VersionedTransactionResponse } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "./base";
+import { CctpPolicy } from "../deser/integrationPolicies";
+export declare class CctpBridgeEvent {
+    readonly amount: BN;
+    readonly sourceDomain: number;
+    readonly sourceAddress: string;
+    readonly destinationDomain: number;
+    readonly destinationCaller: string;
+    readonly destinationAddress: string;
+    readonly attestation: string;
+    readonly nonce: string;
+    readonly status: string;
+    readonly txHash: string;
+    readonly uiAmount: number;
+    slot?: number;
+    constructor(amount: BN, sourceDomain: number, sourceAddress: string, destinationDomain: number, destinationCaller: string, destinationAddress: string, attestation: string, nonce: string, status: string, txHash: string);
+}
+declare class TxBuilder extends BaseTxBuilder<CctpClient> implements ProtocolPolicyTxBuilder<CctpPolicy> {
+    /**
+     * Returns a transaction that calls CCTP's `depositForBurn` instruction that bridges USDC to another chain.
+     * A keypair is generated for the message sent event account, which must be included as a transaction signer.
+     */
+    bridgeUsdcIx(amount: BN, domain: number, destinationAddress: PublicKey, params: {
+        maxFee: BN;
+        minFinalityThreshold: number;
+        destinationCaller?: PublicKey;
+    }, glamSigner: PublicKey): Promise<[TransactionInstruction, Keypair]>;
+    bridgeUsdcTx(amount: BN, domain: number, destinationAddress: PublicKey, params: {
+        maxFee: BN;
+        minFinalityThreshold: number;
+        destinationCaller?: PublicKey;
+    }, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
+    receiveMessageIx(sourceDomain: number, messageObj: any): Promise<TransactionInstruction>;
+    receiveUsdcTx(sourceDomain: number, params: {
+        txHash?: string;
+        nonce?: string;
+    }, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    setPolicyIx(policy: CctpPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
+    setPolicyTx(policy: CctpPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class CctpClient implements ProtocolPolicyClient<CctpPolicy> {
+    readonly base: BaseClient;
+    txBuilder: TxBuilder;
+    constructor(base: BaseClient);
+    /**
+     * Bridge USDC to another chain using Circle's CCTP protocol
+     *
+     * @param amount Amount of USDC to bridge (in smallest units)
+     * @param domain Destination domain (e.g., 0 for Ethereum, 1 for Avalanche)
+     * @param destinationAddress Destination address on target chain (EVM address as PublicKey)
+     * @param params Additional parameters (maxFee, minFinalityThreshold)
+     * @param txOptions Transaction options
+     */
+    bridgeUsdc(amount: BN | number, domain: number, destinationAddress: PublicKey, params: {
+        maxFee: BN;
+        minFinalityThreshold: number;
+        destinationCaller?: PublicKey;
+    }, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Receive USDC from another chain using Circle's CCTP protocol
+     *
+     * @param sourceDomain Source domain (e.g., 0 for Ethereum, 6 for Base)
+     * @param params Additional parameters (txHash, nonce)
+     * @param txOptions Transaction options
+     */
+    receiveUsdc(sourceDomain: number, params: {
+        txHash?: string;
+        nonce?: string;
+    }, txOptions?: TxOptions): Promise<string>;
+    fetchPolicy(): Promise<CctpPolicy | null>;
+    setPolicy(policy: CctpPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
+    getReceiveMessagePdas(messageTransmitterProgram: PublicKey, tokenMessengerMinterProgram: PublicKey, solUsdcMint: PublicKey, remoteUsdcAddressHex: string, remoteDomain: string, nonceHex: string): Promise<{
+        messageTransmitter: PublicKey;
+        tokenMessenger: PublicKey;
+        tokenMinter: PublicKey;
+        localToken: PublicKey;
+        remoteTokenMessengerKey: PublicKey;
+        remoteTokenKey: PublicKey;
+        tokenPair: PublicKey;
+        custodyTokenAccount: PublicKey;
+        authorityPda: PublicKey;
+        tokenMessengerEventAuthority: PublicKey;
+        usedNonce: PublicKey;
+        feeRecipientTokenAccount: PublicKey;
+    }>;
+    /**
+     * Get all PDAs required for CCTP deposit for burn operation
+     *
+     * @param messageTransmitterProgram Message transmitter program ID
+     * @param tokenMessengerMinterProgram Token messenger minter program ID
+     * @param usdcAddress USDC mint address
+     * @param destinationDomain Destination domain
+     * @returns Object containing all required PDAs
+     */
+    getDepositForBurnPdas(messageTransmitterProgram: PublicKey, tokenMessengerMinterProgram: PublicKey, usdcAddress: PublicKey, destinationDomain: Number): {
+        messageTransmitterAccount: PublicKey;
+        tokenMessengerAccount: PublicKey;
+        tokenMinterAccount: PublicKey;
+        localToken: PublicKey;
+        remoteTokenMessengerKey: PublicKey;
+        authorityPda: PublicKey;
+        tokenMessengerEventAuthority: PublicKey;
+    };
+    /**
+     * Find all message accounts onchain for a given sender wallet
+     *
+     * TODO: filter by burned token mint
+     */
+    findV2Messages(senderWallet: PublicKey, options: {
+        commitment?: Commitment;
+        minSlot?: number;
+    }): Promise<PublicKey[]>;
+    fetchV2Messages(sourceDomain: number, params: {
+        txHash?: string;
+        nonce?: string;
+    }): Promise<any[]>;
+    /**
+     * Get bridge events from Circle API using either txHash or nonce
+     *
+     * @param sourceDomain Source domain
+     * @param params Either txHash or nonce is required
+     * @returns Array of bridge events
+     */
+    parseEventsFromAttestion(sourceDomain: number, { txHash, nonce }: {
+        txHash?: string;
+        nonce?: string;
+    }): Promise<CctpBridgeEvent[]>;
+    getTransactions(signatures: string[], batchSize: number, commitment?: Finality): Promise<VersionedTransactionResponse[]>;
+    /**
+     * Get incoming bridge events (EVM -> Solana)
+     *
+     * Unlike outgoing bridge events, incoming bridge events are not stored in Message accounts on Solana.
+     * We need to examine all transactions to find the ones that contain the bridge events.
+     * 1. Fetch all transactions involing the vault's USDC token account
+     * 2. Filter transactions that contain the bridge events
+     * 3. Parse the bridge events from the transactions
+     */
+    getIncomingBridgeEvents(options: {
+        batchSize?: number;
+        commitment?: Finality;
+        txHashes?: string[];
+        minSlot?: number;
+    }): Promise<CctpBridgeEvent[]>;
+    /**
+     * Get outgoing bridge events (Solana -> EVM)
+     *
+     * Each transfer has a Message account on Solana. To get all events:
+     * 1. Find all Message accounts for the vault
+     * 2. Get the created transaction for each message account
+     * 3. Call iris api to get the attestation status and parsed message using each tx hash
+     */
+    getOutgoingBridgeEvents(options: {
+        batchSize?: number;
+        commitment?: Commitment;
+        txHashes?: string[];
+        minSlot?: number;
+    }): Promise<CctpBridgeEvent[]>;
+}
+export {};

package/src/client/epi.d.ts

@@ -0,0 +1,228 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, AccountMeta, Keypair, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+type BufferLike = Uint8Array | number[] | Buffer;
+type BufferLike32 = BufferLike;
+type BufferLike20 = BufferLike;
+export type EpiDenominationKindInput = {
+    usd: Record<string, never>;
+} | {
+    mint: Record<string, never>;
+};
+export type EpiDenominationSpecInput = {
+    denom: EpiDenominationKindInput;
+    mint: PublicKey;
+};
+export type EpiExternalPositionTypeInput = {
+    valued: Record<string, never>;
+} | {
+    tokenized: Record<string, never>;
+};
+export type EpiExternalSourceTypeInput = {
+    trusted: Record<string, never>;
+} | {
+    native: Record<string, never>;
+} | {
+    wormhole: Record<string, never>;
+};
+export type EpiNativeCustodyKindInput = {
+    splToken: Record<string, never>;
+} | {
+    nativeSol: Record<string, never>;
+};
+export type UpsertExternalPositionParams = {
+    positionId: BufferLike32;
+    positionType: EpiExternalPositionTypeInput;
+    sourceType: EpiExternalSourceTypeInput;
+    denomination: EpiDenominationSpecInput;
+    nativeCustodyAccount?: PublicKey;
+    nativeCustodyKind?: EpiNativeCustodyKindInput;
+    enabled?: boolean;
+    freshnessOverrideSecs?: number;
+    submitAllowlist?: PublicKey[];
+    validateAllowlist?: PublicKey[];
+    configureAllowlist?: PublicKey[];
+};
+export type SubmitExternalObservationParams = {
+    positionId: BufferLike32;
+    amount: BN;
+    denomination: EpiDenominationSpecInput;
+    observationTimestamp: BN;
+    externalShares?: BN;
+    reserved?: Uint8Array | number[] | Buffer;
+};
+export type ValidateExternalObservationOracleAccounts = {
+    glamConfig?: PublicKey | null;
+    solUsdOracle?: PublicKey | null;
+    baseAssetOracle?: PublicKey | null;
+    observedMintOracle?: PublicKey | null;
+};
+export type ValidateExternalObservationParams = {
+    positionId: BufferLike32;
+} & ValidateExternalObservationOracleAccounts;
+export type WormholeObservationConfigInput = {
+    positionId: BufferLike32;
+    emitterChain: number;
+    emitterAddress: BufferLike32;
+    payloadVersion: number;
+    payloadType: number;
+    maxAgeSeconds: number;
+};
+export type WormholeHyperliquidObservationConfigInput = {
+    positionId: BufferLike32;
+    hyperliquidAccount: BufferLike20;
+    accountMarginSummaryPrecompile: BufferLike20;
+    spotBalancePrecompile: BufferLike20;
+    perpDexIndex: number;
+    usdcSpotToken: BN;
+};
+export type SubmitExternalObservationWormholeParams = {
+    positionId: BufferLike32;
+    signedVaa: BufferLike;
+    payloadConfigAccounts?: AccountMeta[];
+    guardianSignatures?: Keypair;
+    guardianSet?: PublicKey;
+    wormholeCoreBridgeProgram?: PublicKey;
+    wormholeVerifyVaaShimProgram?: PublicKey;
+    maxSignaturesPerPost?: number;
+};
+export type SubmitExternalObservationWormholeResult = {
+    postSignatureTxs: TransactionSignature[];
+    submitTx: TransactionSignature;
+    guardianSignatures: PublicKey;
+};
+export type ParsedWormholeSignedVaa = {
+    version: number;
+    guardianSetIndex: number;
+    signatures: Buffer[];
+    vaaBody: Buffer;
+};
+export declare function evmAddressToBytes20(address: string): number[];
+export declare function evmAddressToWormholeEmitterAddress(address: string): number[];
+export declare function parseWormholeSignedVaa(signedVaa: BufferLike): ParsedWormholeSignedVaa;
+export declare function getWormholeGuardianSetPda(guardianSetIndex: number, wormholeCoreBridgeProgram?: PublicKey): [PublicKey, number];
+declare class TxBuilder extends BaseTxBuilder<EpiClient> {
+    upsertExternalPositionIx(params: UpsertExternalPositionParams, signer?: PublicKey): Promise<TransactionInstruction>;
+    upsertExternalPositionWormholeConfigIx(params: WormholeObservationConfigInput, signer?: PublicKey): Promise<TransactionInstruction>;
+    upsertExternalPositionWormholeHyperliquidConfigIx(params: WormholeHyperliquidObservationConfigInput, signer?: PublicKey): Promise<TransactionInstruction>;
+    submitExternalObservationIx(params: SubmitExternalObservationParams, signer?: PublicKey): Promise<TransactionInstruction>;
+    wormholePostSignaturesIx(parsedVaa: ParsedWormholeSignedVaa, guardianSignatures: PublicKey, payer?: PublicKey, signatures?: Buffer[], wormholeVerifyVaaShimProgram?: PublicKey): TransactionInstruction;
+    wormholeCloseSignaturesIx(guardianSignatures: PublicKey, refundRecipient?: PublicKey, wormholeVerifyVaaShimProgram?: PublicKey): TransactionInstruction;
+    submitExternalObservationWormholeIx(params: SubmitExternalObservationWormholeParams, guardianSignatures: PublicKey, signer?: PublicKey): Promise<TransactionInstruction>;
+    validateExternalObservationIx(paramsOrPositionId: BufferLike32 | ValidateExternalObservationParams, signer?: PublicKey): Promise<TransactionInstruction>;
+    refreshPricedProtocolIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    submitExternalObservationTx(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    upsertExternalPositionTx(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    removeExternalPositionTx(positionId: BufferLike32, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    upsertExternalPositionWormholeConfigTx(params: WormholeObservationConfigInput, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    upsertExternalPositionWormholeHyperliquidConfigTx(params: WormholeHyperliquidObservationConfigInput, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    submitExternalObservationWormholeTx(params: SubmitExternalObservationWormholeParams, guardianSignatures: PublicKey, txOptions?: TxOptions, closeSignatures?: boolean): Promise<VersionedTransaction>;
+    validateExternalObservationTx(paramsOrPositionId: BufferLike32 | ValidateExternalObservationParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    refreshPricedProtocolTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class EpiClient {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient);
+    getObservationStatePda(): PublicKey;
+    getWormholeObservationConfigPda(positionId: BufferLike32): PublicKey;
+    getWormholeHyperliquidObservationConfigPda(positionId: BufferLike32): PublicKey;
+    getIntegrationAuthorityPda(): PublicKey;
+    fetchObservationState(): Promise<{
+        glamState: PublicKey;
+        bump: number;
+        positionsLen: number;
+        reserved: number[];
+        positions: {
+            positionId: number[];
+            hasPending: boolean;
+            padPending: number[];
+            pendingObservation: {
+                amount: {
+                    bytes: number[];
+                };
+                denomination: {
+                    denom: ({
+                        usd?: undefined;
+                    } & {
+                        mint: Record<string, never>;
+                    }) | ({
+                        mint?: undefined;
+                    } & {
+                        usd: Record<string, never>;
+                    });
+                    mint: PublicKey;
+                };
+                padDenom: number[];
+                observationTimestamp: BN;
+                externalShares: BN;
+                submittedBy: PublicKey;
+                submittedAtSlot: BN;
+            };
+            hasValidated: boolean;
+            padValidated: number[];
+            lastValidatedObservation: {
+                amount: {
+                    bytes: number[];
+                };
+                denomination: {
+                    denom: ({
+                        usd?: undefined;
+                    } & {
+                        mint: Record<string, never>;
+                    }) | ({
+                        mint?: undefined;
+                    } & {
+                        usd: Record<string, never>;
+                    });
+                    mint: PublicKey;
+                };
+                padDenom: number[];
+                observationTimestamp: BN;
+                externalShares: BN;
+                submittedBy: PublicKey;
+                submittedAtSlot: BN;
+            };
+            validatedBy: PublicKey;
+            validatedAtSlot: BN;
+            validatedBaseAssetAmount: {
+                bytes: number[];
+            };
+        }[];
+    } | null>;
+    fetchWormholeObservationConfig(positionId: BufferLike32): Promise<{
+        glamState: PublicKey;
+        positionId: number[];
+        emitterChain: number;
+        emitterAddress: number[];
+        payloadVersion: number;
+        payloadType: number;
+        maxAgeSeconds: number;
+        hasLastSequence: boolean;
+        lastSequence: BN;
+        lastVaaHash: number[];
+        bump: number;
+    } | null>;
+    fetchWormholeHyperliquidObservationConfig(positionId: BufferLike32): Promise<{
+        glamState: PublicKey;
+        positionId: number[];
+        hyperliquidAccount: number[];
+        accountMarginSummaryPrecompile: number[];
+        spotBalancePrecompile: number[];
+        perpDexIndex: number;
+        usdcSpotToken: BN;
+        bump: number;
+    } | null>;
+    submitExternalObservation(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    upsertExternalPosition(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    removeExternalPosition(positionId: BufferLike32, txOptions?: TxOptions): Promise<TransactionSignature>;
+    upsertExternalPositionWormholeConfig(params: WormholeObservationConfigInput, txOptions?: TxOptions): Promise<TransactionSignature>;
+    upsertExternalPositionWormholeHyperliquidConfig(params: WormholeHyperliquidObservationConfigInput, txOptions?: TxOptions): Promise<TransactionSignature>;
+    submitExternalObservationWormhole(params: SubmitExternalObservationWormholeParams, txOptions?: TxOptions): Promise<SubmitExternalObservationWormholeResult>;
+    validateExternalObservation(paramsOrPositionId: BufferLike32 | ValidateExternalObservationParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    resolveValidateExternalObservationAccounts(params: ValidateExternalObservationParams): Promise<Required<Omit<ValidateExternalObservationOracleAccounts, "observedMintOracle">> & {
+        remainingAccounts: AccountMeta[];
+    }>;
+    refreshPricedProtocol(txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export {};

package/src/client/fees.d.ts

@@ -0,0 +1,33 @@
+import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+import { PriceClient } from "./price";
+declare class TxBuilder extends BaseTxBuilder<FeesClient> {
+    crystallizeFeesIxs(glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    crystallizeFeesTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    claimFeesIxs(glamSigner: PublicKey): Promise<TransactionInstruction[]>;
+    claimFeesTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    chargeProtocolFeeIxs(glamSigner: PublicKey, protocolFeeAuthority: PublicKey): Promise<TransactionInstruction[]>;
+    chargeProtocolFeeTx(protocolFeeAuthority: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    setProtocolFeesIx(baseFeeBps: number, flowFeeBps: number, signer?: PublicKey): Promise<TransactionInstruction>;
+    setProtocolFeesTx(baseFeeBps: number, flowFeeBps: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class FeesClient {
+    readonly base: BaseClient;
+    readonly price: PriceClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient, price: PriceClient);
+    /**
+     * Returns claimable fees object
+     */
+    getClaimableFees(): Promise<any>;
+    /**
+     * Returns claimed fees object
+     */
+    getClaimedFees(): Promise<any>;
+    crystallizeFees(txOptions?: TxOptions): Promise<TransactionSignature>;
+    claimFees(txOptions?: TxOptions): Promise<TransactionSignature>;
+    chargeProtocolFee(protocolFeeAuthority: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    setProtocolFeesIx(baseFeeBps: number, flowFeeBps: number, signer?: PublicKey): Promise<TransactionInstruction>;
+    setProtocolFees(baseFeeBps: number, flowFeeBps: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export {};

package/src/client/invest.d.ts

@@ -0,0 +1,37 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+import { PendingRequest } from "../models";
+declare class TxBuilder extends BaseTxBuilder<InvestClient> {
+    subscribeIxs(amount: BN, signer: PublicKey): Promise<TransactionInstruction[]>;
+    subscribeTx(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    queuedSubscribeIxs(amount: BN, signer: PublicKey): Promise<TransactionInstruction[]>;
+    queuedSubscribeTx(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    queuedRedeemIx(amount: BN, signer: PublicKey): Promise<TransactionInstruction>;
+    queuedRedeemTx(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    cancelIx(pubkey: PublicKey | null, signer: PublicKey): Promise<TransactionInstruction>;
+    cancelTx(pubkey: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    fulfillIx(limit: number | null, signer: PublicKey): Promise<TransactionInstruction>;
+    fulfillTx(limit: number | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    claimIxs(user: PublicKey | null, signer: PublicKey): Promise<TransactionInstruction[]>;
+    claimTx(user: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class InvestClient {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient);
+    subscribe(amount: BN, queued?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
+    queuedRedeem(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    cancel(txOptions?: TxOptions): Promise<TransactionSignature>;
+    cancelForUser(user: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    fulfill(limit: number | null, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Claims the pending request for the signer.
+     * @param txOptions
+     * @returns
+     */
+    claim(txOptions?: TxOptions): Promise<TransactionSignature>;
+    claimForUser(user: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    fetchPendingRequest(user?: PublicKey): Promise<PendingRequest | null>;
+}
+export {};

package/src/client/jupiter-lend/borrow.d.ts

@@ -0,0 +1,92 @@
+import { BN } from "@coral-xyz/anchor";
+import { AccountMeta, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "../base";
+import { VaultClient } from "../vault";
+import { JupiterBorrowPolicy } from "../../deser/integrationPolicies";
+import { JupiterPosition, JupiterTransferType, JupiterVault } from "./shared";
+export type JupiterBorrowInitPositionAccounts = {
+    vaultAdmin: PublicKey;
+    vaultState: PublicKey;
+    position: PublicKey;
+    positionMint: PublicKey;
+    positionTokenAccount: PublicKey;
+    metadataAccount?: PublicKey;
+    tokenProgram?: PublicKey;
+    associatedTokenProgram?: PublicKey;
+    sysvarInstruction?: PublicKey;
+    metadataProgram?: PublicKey;
+};
+export type JupiterBorrowOperateAccounts = {
+    signerSupplyTokenAccount?: PublicKey;
+    signerBorrowTokenAccount?: PublicKey;
+    recipient?: PublicKey | null;
+    recipientBorrowTokenAccount?: PublicKey | null;
+    recipientSupplyTokenAccount?: PublicKey | null;
+    vaultConfig: PublicKey;
+    vaultState: PublicKey;
+    supplyToken: PublicKey;
+    borrowToken: PublicKey;
+    oracle: PublicKey;
+    position: PublicKey;
+    positionTokenAccount: PublicKey;
+    currentPositionTick: PublicKey;
+    finalPositionTick: PublicKey;
+    currentPositionTickId: PublicKey;
+    finalPositionTickId: PublicKey;
+    newBranch: PublicKey;
+    supplyTokenReservesLiquidity: PublicKey;
+    borrowTokenReservesLiquidity: PublicKey;
+    vaultSupplyPositionOnLiquidity: PublicKey;
+    vaultBorrowPositionOnLiquidity: PublicKey;
+    supplyRateModel: PublicKey;
+    borrowRateModel: PublicKey;
+    vaultSupplyTokenAccount: PublicKey;
+    vaultBorrowTokenAccount: PublicKey;
+    supplyTokenClaimAccount?: PublicKey | null;
+    borrowTokenClaimAccount?: PublicKey | null;
+    liquidity: PublicKey;
+    liquidityProgram?: PublicKey;
+    oracleProgram?: PublicKey;
+    supplyTokenProgram?: PublicKey;
+    borrowTokenProgram?: PublicKey;
+    associatedTokenProgram?: PublicKey;
+    remainingAccounts?: AccountMeta[];
+};
+export type JupiterBorrowPosition = JupiterPosition & {
+    positionTokenAccount: PublicKey;
+    tokenAmount: string;
+    tokenProgram: PublicKey;
+};
+declare class TxBuilder extends BaseTxBuilder<JupiterBorrowClient> implements ProtocolPolicyTxBuilder<JupiterBorrowPolicy> {
+    initPositionIx(vaultId: number, nextPositionId: number, accounts: JupiterBorrowInitPositionAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    initPositionTx(vaultId: number, nextPositionId: number, accounts: JupiterBorrowInitPositionAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    operateIx(newCol: BN | bigint | number, newDebt: BN | bigint | number, transferType: JupiterTransferType | null, remainingAccountsIndices: Buffer | Uint8Array | number[], accounts: JupiterBorrowOperateAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    operateTx(newCol: BN | bigint | number, newDebt: BN | bigint | number, transferType: JupiterTransferType | null, remainingAccountsIndices: Buffer | Uint8Array | number[], accounts: JupiterBorrowOperateAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    setPolicyIx(policy: JupiterBorrowPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
+    setPolicyTx(policy: JupiterBorrowPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class JupiterBorrowClient implements ProtocolPolicyClient<JupiterBorrowPolicy> {
+    readonly base: BaseClient;
+    readonly vault: VaultClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient, vault: VaultClient);
+    getIntegrationAuthorityPda(): PublicKey;
+    getPosition(position: PublicKey): Promise<JupiterPosition>;
+    listPositions(vaultId?: number): Promise<JupiterBorrowPosition[]>;
+    getVault(vaultId: number): Promise<JupiterVault>;
+    listVaults(): Promise<JupiterVault[]>;
+    initPosition(vaultId: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    deposit(position: PublicKey, amount: BN | bigint | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(position: PublicKey, amount: BN | bigint | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    borrow(position: PublicKey, amount: BN | bigint | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    repay(position: PublicKey, amount: BN | bigint | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    operate(newCol: BN | bigint | number, newDebt: BN | bigint | number, transferType: JupiterTransferType | null, remainingAccountsIndices: Buffer | Uint8Array | number[], accounts: JupiterBorrowOperateAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
+    fetchPolicy(): Promise<JupiterBorrowPolicy | null>;
+    setPolicy(policy: JupiterBorrowPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
+    private simulateExpectedFinalTick;
+    private runBorrowOperate;
+}
+export {};

package/src/client/jupiter-lend/earn.d.ts

@@ -0,0 +1,64 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "../base";
+import { JupiterEarnPolicy } from "../../deser/integrationPolicies";
+export type JupiterEarnDepositAccounts = {
+    depositorTokenAccount?: PublicKey;
+    recipientTokenAccount?: PublicKey;
+    mint: PublicKey;
+    lendingAdmin: PublicKey;
+    lending: PublicKey;
+    fTokenMint: PublicKey;
+    supplyTokenReservesLiquidity: PublicKey;
+    lendingSupplyPositionOnLiquidity: PublicKey;
+    rateModel: PublicKey;
+    vault: PublicKey;
+    liquidity: PublicKey;
+    liquidityProgram?: PublicKey;
+    rewardsRateModel: PublicKey;
+    tokenProgram?: PublicKey;
+    fTokenProgram?: PublicKey;
+    associatedTokenProgram?: PublicKey;
+};
+export type JupiterEarnWithdrawAccounts = {
+    ownerTokenAccount?: PublicKey;
+    recipientTokenAccount?: PublicKey;
+    lendingAdmin: PublicKey;
+    lending: PublicKey;
+    mint: PublicKey;
+    fTokenMint: PublicKey;
+    supplyTokenReservesLiquidity: PublicKey;
+    lendingSupplyPositionOnLiquidity: PublicKey;
+    rateModel: PublicKey;
+    vault: PublicKey;
+    claimAccount: PublicKey;
+    liquidity: PublicKey;
+    liquidityProgram?: PublicKey;
+    rewardsRateModel: PublicKey;
+    tokenProgram?: PublicKey;
+    fTokenProgram?: PublicKey;
+    associatedTokenProgram?: PublicKey;
+};
+declare class TxBuilder extends BaseTxBuilder<JupiterEarnClient> implements ProtocolPolicyTxBuilder<JupiterEarnPolicy> {
+    depositIx(amount: BN | bigint | number, minAmountOut: BN | bigint | number, accounts: JupiterEarnDepositAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    depositTx(amount: BN | bigint | number, minAmountOut: BN | bigint | number, accounts: JupiterEarnDepositAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    withdrawIx(amount: BN | bigint | number, maxSharesBurn: BN | bigint | number, accounts: JupiterEarnWithdrawAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    withdrawTx(amount: BN | bigint | number, maxSharesBurn: BN | bigint | number, accounts: JupiterEarnWithdrawAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    setPolicyIx(policy: JupiterEarnPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
+    setPolicyTx(policy: JupiterEarnPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class JupiterEarnClient implements ProtocolPolicyClient<JupiterEarnPolicy> {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient);
+    getIntegrationAuthorityPda(): PublicKey;
+    deposit(mint: PublicKey, amount: BN | bigint | number, minAmountOut?: BN | bigint | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    withdraw(mint: PublicKey, amount: BN | bigint | number, maxSharesBurn?: BN | bigint | number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    fetchPolicy(): Promise<JupiterEarnPolicy | null>;
+    setPolicy(policy: JupiterEarnPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
+    private resolveAccounts;
+}
+export {};

package/src/client/jupiter-lend/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./shared";
+export * from "./earn";
+export * from "./borrow";