@glamsystems/glam-sdk 1.1.0 → 1.1.1-alpha.0

package/src/client/epi.d.ts

@@ -1,228 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,92 +0,0 @@
-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

@@ -1,64 +0,0 @@
-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

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

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

@@ -1,129 +0,0 @@
-import { AccountMeta, AddressLookupTableAccount, Connection, PublicKey } from "@solana/web3.js";
-import { U64_MAX_BN as U64_MAX } from "../../utils/common";
-export { JUPITER_BORROW_PROTOCOL, JUPITER_EARN_PROTOCOL, } from "../../protocols";
-export type JupiterTransferType = {
-    skip: Record<string, never>;
-} | {
-    direct: Record<string, never>;
-} | {
-    claim: Record<string, never>;
-};
-export declare const PUBKEY_BYTES = 32;
-export { U64_MAX };
-export declare const LENDING_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const TOKEN_RESERVE_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const VAULT_STATE_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const VAULT_CONFIG_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const VAULT_METADATA_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const POSITION_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const ORACLE_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const TICK_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const TICK_ID_LIQUIDATION_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const LIQUIDITY_SUPPLY_POSITION_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const LIQUIDITY_BORROW_POSITION_DISCRIMINATOR: Buffer<ArrayBuffer>;
-export declare const LENDING_REWARDS_RATE_MODEL_OFFSET: number;
-export declare const LENDING_TOKEN_RESERVES_LIQUIDITY_OFFSET: number;
-export declare const LENDING_SUPPLY_POSITION_OFFSET: number;
-export declare const TOKEN_RESERVE_VAULT_OFFSET: number;
-export declare const VAULT_CONFIG_ORACLE_OFFSET: number;
-export declare const VAULT_CONFIG_SUPPLY_TOKEN_OFFSET: number;
-export declare const VAULT_CONFIG_BORROW_TOKEN_OFFSET: number;
-export declare const VAULT_METADATA_LOOKUP_TABLE_OFFSET: number;
-export declare const VAULT_STATE_VAULT_ID_OFFSET = 8;
-export declare const VAULT_STATE_CURRENT_BRANCH_ID_OFFSET: number;
-export declare const VAULT_STATE_NEXT_POSITION_ID_OFFSET: number;
-export declare const POSITION_VAULT_ID_OFFSET = 8;
-export declare const POSITION_MINT_OFFSET: number;
-export declare const POSITION_IS_SUPPLY_ONLY_OFFSET: number;
-export declare const POSITION_TICK_OFFSET: number;
-export declare const POSITION_TICK_ID_OFFSET: number;
-export declare const ORACLE_SOURCE_BYTES: number;
-export declare const TICK_VALUE_OFFSET: number;
-export declare const TICK_TOTAL_IDS_OFFSET: number;
-export declare const TICK_ID_VALUE_OFFSET: number;
-export declare const TICK_ID_MAP_OFFSET: number;
-export declare const MIN_TICK = -16383;
-export declare const TICKS_PER_TICK_HAS_DEBT_ARRAY = 2048;
-export declare const LIQUIDITY_POSITION_VAULT_CONFIG_OFFSET = 8;
-export declare const LIQUIDITY_POSITION_MINT_OFFSET: number;
-export declare const LIQUIDITY_SUPPLY_POSITION_SIZE = 124;
-export declare const LIQUIDITY_BORROW_POSITION_SIZE = 120;
-export declare const BORROW_OPERATE_EXPECTED_TICK_RE: RegExp;
-export type JupiterPosition = {
-    pubkey: PublicKey;
-    vaultId: number;
-    positionMint: PublicKey;
-    isSupplyOnlyPosition: boolean;
-    tick: number;
-    tickId: number;
-};
-export type JupiterVault = {
-    vaultId: number;
-    vaultConfig: PublicKey;
-    vaultState: PublicKey;
-    oracle: PublicKey;
-    supplyToken: PublicKey;
-    borrowToken: PublicKey;
-};
-export type VaultStateInfo = {
-    vaultId: number;
-    currentBranchId: number;
-    nextPositionId: number;
-};
-export type TickInfo = {
-    pubkey: PublicKey;
-    tick: number;
-    totalIds: number;
-};
-export type BorrowOperateRemainingAccounts = {
-    indices: Buffer;
-    accounts: AccountMeta[];
-};
-export declare function decodePositionInfo(pubkey: PublicKey, data: Buffer): JupiterPosition;
-export declare function u16LeBytes(value: number): Buffer;
-export declare function u32LeBytes(value: number): Buffer;
-export declare function i32LeBytes(value: number): Buffer;
-export declare function memcmpFilter(offset: number, data: Buffer): {
-    memcmp: {
-        offset: number;
-        bytes: string;
-        encoding: "base64";
-    };
-};
-export declare function toU8Buffer(value: Buffer | Uint8Array | number[]): Buffer;
-export declare function getTokenMetadataPda(mint: PublicKey): PublicKey;
-export declare function getLendingAdminPda(): PublicKey;
-export declare function getFTokenMintPda(mint: PublicKey): PublicKey;
-export declare function getLendingPda(mint: PublicKey, fTokenMint: PublicKey): PublicKey;
-export declare function getClaimAccountPda(mint: PublicKey, lendingAdmin: PublicKey): PublicKey;
-export declare function getRateModelPda(mint: PublicKey): PublicKey;
-export declare function getLiquidityPda(): PublicKey;
-export declare function getVaultAdminPda(): PublicKey;
-export declare function getVaultConfigPda(vaultId: number): PublicKey;
-export declare function getVaultMetadataPda(vaultId: number): PublicKey;
-export declare function getVaultStatePda(vaultId: number): PublicKey;
-export declare function getPositionPda(vaultId: number, positionId: number): PublicKey;
-export declare function getPositionMintPda(vaultId: number, positionId: number): PublicKey;
-export declare function getBranchPda(vaultId: number, branchId: number): PublicKey;
-export declare function getTickHasDebtPda(vaultId: number, index: number): PublicKey;
-export declare function getTickHasDebtIndex(tick: number): number;
-export declare function fetchAndValidate(connection: Connection, pubkey: PublicKey, expectedOwner: PublicKey, expectedDiscriminator: Buffer, label: string): Promise<Buffer>;
-export declare function resolveLookupTableAccounts(connection: Connection, statePda: PublicKey, vaultPda: PublicKey, lookupTable?: PublicKey): Promise<AddressLookupTableAccount[]>;
-export declare function fetchPositionInfo(connection: Connection, position: PublicKey): Promise<JupiterPosition>;
-export declare function fetchVaultStateInfo(connection: Connection, vaultState: PublicKey): Promise<VaultStateInfo>;
-export declare function fetchVaultConfigInfo(connection: Connection, vaultConfig: PublicKey): Promise<{
-    oracle: PublicKey;
-    supplyToken: PublicKey;
-    borrowToken: PublicKey;
-}>;
-export declare function fetchVaultMetadataLookupTable(connection: Connection, vaultMetadata: PublicKey): Promise<PublicKey | null>;
-export declare function fetchReserveVault(connection: Connection, reserve: PublicKey, expectedMint: PublicKey): Promise<PublicKey>;
-export declare function fetchLendingReserveAndVault(connection: Connection, mint: PublicKey): Promise<{
-    reserve: PublicKey;
-    vault: PublicKey;
-}>;
-export declare function fetchLiquidityPosition(connection: Connection, discriminator: Buffer, dataSize: number, vaultConfig: PublicKey, mint: PublicKey, label: string): Promise<PublicKey>;
-export declare function fetchTickByValue(connection: Connection, vaultId: number, tick: number): Promise<TickInfo>;
-export declare function fetchTickIdLiquidationByTick(connection: Connection, vaultId: number, tick: number, tickMap: number): Promise<PublicKey>;
-export declare function resolveOracleRemainingAccounts(connection: Connection, oracle: PublicKey): Promise<AccountMeta[]>;
-export declare function buildBorrowOperateRemainingAccounts(vaultId: number, oracleAccounts: AccountMeta[], currentTickValue: number, finalTickValue: number): BorrowOperateRemainingAccounts;

package/src/client/jupiter.d.ts

@@ -1,53 +0,0 @@
-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 { JupiterSwapPolicy } from "../deser/integrationPolicies";
-import { VaultClient } from "./vault";
-import { JupiterApiClient, JupiterInstruction, QuoteParams, QuoteResponse, SwapInstructions } from "../utils/jupiterApi";
-import { KaminoLendingClient } from "./kamino";
-export type JupiterSwapOptions = {
-    quoteParams?: QuoteParams;
-    quoteResponse?: QuoteResponse;
-    swapInstructions?: SwapInstructions;
-    trackingAccount?: PublicKey;
-};
-export type JupiterSwapV2OracleAccounts = {
-    solUsdOracle?: PublicKey;
-    inputTokenOracle?: PublicKey;
-    outputTokenOracle?: PublicKey;
-    kaminoReservesToRefresh: PublicKey[];
-};
-export type JupiterSwapV2Options = JupiterSwapOptions & {
-    skipQuotePriceCheck?: boolean;
-};
-declare class TxBuilder extends BaseTxBuilder<JupiterSwapClient> implements ProtocolPolicyTxBuilder<JupiterSwapPolicy> {
-    private resolveSwapInstructionContext;
-    getSwapV2OracleAccounts(inputMint: PublicKey, outputMint: PublicKey, skipQuotePriceCheck: boolean): Promise<JupiterSwapV2OracleAccounts>;
-    /**
-     * Returns the instructions for a Jupiter swap and the lookup tables
-     */
-    swapIxs(options: JupiterSwapOptions, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
-    swapV2Ixs(options: JupiterSwapV2Options, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
-    swapTx(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    swapV2Tx(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    setPolicyIx(policy: JupiterSwapPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
-    setPolicyTx(policy: JupiterSwapPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
-    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    getPreInstructions(signer: PublicKey, inputMint: PublicKey, outputMint: PublicKey, amount: BN, outputTokenProgram?: PublicKey): Promise<TransactionInstruction[]>;
-    toTransactionInstruction: (ix: JupiterInstruction) => TransactionInstruction;
-}
-export declare class JupiterSwapClient implements ProtocolPolicyClient<JupiterSwapPolicy> {
-    readonly base: BaseClient;
-    readonly vault: VaultClient;
-    readonly klend: KaminoLendingClient;
-    readonly txBuilder: TxBuilder;
-    readonly jupApi: JupiterApiClient;
-    constructor(base: BaseClient, vault: VaultClient, klend: KaminoLendingClient);
-    swap(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<TransactionSignature>;
-    swapV2(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<TransactionSignature>;
-    fetchPolicy(): Promise<JupiterSwapPolicy | null>;
-    setPolicy(policy: JupiterSwapPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};