@glamsystems/glam-sdk 1.0.12-alpha.3 → 1.0.13-test

package/package.json

@@ -1,19 +1,38 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "1.0.12-alpha.3",
+  "version": "1.0.13-test",
   "description": "TypeScript SDK for the GLAM Protocol",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",
+  "types": "./index.esm.d.ts",
   "homepage": "https://www.glam.systems",
   "repository": {
     "type": "git",
-    "url": "git@github.com:glamsystems/glam-sdk.git"
+    "url": "https://github.com/glamsystems/glam-sdk-ts.git"
   },
   "keywords": [
     "glam",
     "solana"
   ],
   "license": "Apache-2.0",
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "clean": "node scripts/clean.mjs",
+    "prepack": "npm run build",
+    "pack:dry-run": "npm pack --dry-run --json"
+  },
+  "files": [
+    "README.md",
+    "LICENSE",
+    "index.cjs.js",
+    "index.esm.js",
+    "index.cjs.d.ts",
+    "index.esm.d.ts",
+    "src/**/*.d.ts",
+    "target/idl/**/*.json",
+    "target/types/**/*.ts",
+    "target/types/**/*.d.ts"
+  ],
   "publishConfig": {
     "access": "public"
   },
@@ -36,16 +55,8 @@
     "node": ">=20.20.0"
   },
   "devDependencies": {
-    "@rollup/plugin-terser": "^0.4.4"
-  },
-  "pnpm": {
-    "overrides": {
-      "@solana/web3.js@>=0.0.1": "^1.98.4",
-      "@solana/spl-token@>=0.0.1": "^0.4.6",
-      "@solana/spl-stake-pool@>=0.0.1": "^1.1.5",
-      "typescript@>=0.0.1": "^5.5.3",
-      "solana-bankrun@>=0.0.1": "^0.3.0"
-    }
-  },
-  "types": "./index.esm.d.ts"
-}
+    "@types/node": "^20.17.30",
+    "esbuild": "^0.25.2",
+    "typescript": "^5.8.3"
+  }
+}

package/src/assets.d.ts

@@ -1,5 +1,5 @@
 import { PublicKey } from "@solana/web3.js";
-import { ClusterNetwork } from "./clientConfig";
+import { PkMap } from "./utils/pkmap";
 export declare const STAKE_POOLS: {
     name: string;
     symbol: string;
@@ -8,6 +8,7 @@ export declare const STAKE_POOLS: {
     logoURI: string;
     tokenProgram: PublicKey;
     poolState: PublicKey;
+    isMarinade: boolean;
 }[];
 export declare const STAKE_POOLS_MAP: Map<string, {
     name: string;
@@ -17,30 +18,22 @@ export declare const STAKE_POOLS_MAP: Map<string, {
     logoURI: string;
     tokenProgram: PublicKey;
     poolState: PublicKey;
+    isMarinade: boolean;
 }>;
 /**
  * Metadata for an asset for pricing
  */
 export interface AssetMeta {
+    asset: PublicKey;
     decimals: number;
     oracle: PublicKey;
-    programId?: PublicKey;
-    aggIndex?: number;
+    programId: PublicKey;
+    oracleSource: string;
 }
 /**
- * Asset-Oracle mapping supported by the protocol. This map is a mirror of onchain mapping stored in `global_config` https://solscan.io/account/6avract7PxKqoq6hdmpAgGKgJWoJWdiXPPzzFZ62Hck6
+ * Transforms the LST list into a map of asset metas.
  *
- * Note that we use functional prices for LSTs, and the oracle pubkey of a LST asset is the pool state.
+ * We use functional prices for LSTs, and the oracle pubkey of a LST
+ * asset is the pool state.
  */
-export declare const ASSETS_MAINNET: Map<string, AssetMeta>;
-export declare const ASSETS_TESTS: Map<string, AssetMeta>;
-export declare const SOL_ORACLE: PublicKey;
-export declare const USDC_ORACLE: PublicKey;
-/**
- * Get metadata of an asset for pricing
- *
- * @param assetMint Token mint of the asset
- * @param cluster The cluster network (defaults to mainnet)
- * @returns Metadata of the asset
- */
-export declare function getAssetMeta(assetMint: string | PublicKey, cluster?: ClusterNetwork): AssetMeta;
+export declare const ASSETS_MAINNET: PkMap<AssetMeta>;

package/src/client/access.d.ts

@@ -9,6 +9,10 @@ declare class TxBuilder extends BaseTxBuilder<AccessClient> {
     enableDisableProtocolsTx(integrationProgram: PublicKey, protocolBitmask: number, setEnabled: boolean, txOptions: TxOptions): Promise<VersionedTransaction>;
     grantRevokeDelegatePermissionsIx(delegate: PublicKey, integrationProgram: PublicKey, protocolBitflag: number, permissionsBitmask: BN, setGranted: boolean, signer?: PublicKey): Promise<TransactionInstruction>;
     grantRevokeDelegatePermissionsTx(delegate: PublicKey, integrationProgram: PublicKey, protocolBitflag: number, permissionsBitmask: BN, setGranted: boolean, txOptions: TxOptions): Promise<VersionedTransaction>;
+    addAssetsIx(assets: PublicKey[], signer?: PublicKey): Promise<TransactionInstruction>;
+    addAssetsTx(assets: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+    deleteAssetsIx(assets: PublicKey[], signer?: PublicKey): Promise<TransactionInstruction>;
+    deleteAssetsTx(assets: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
     setProtocolPolicyIx(integrationProgram: PublicKey, protocolBitflag: number, data: Buffer, glamSigner: PublicKey): Promise<TransactionInstruction>;
     setProtocolPolicyTx(integrationProgram: PublicKey, protocolBitflag: number, data: Buffer, txOptions: TxOptions): Promise<VersionedTransaction>;
 }
@@ -16,6 +20,15 @@ export declare class AccessClient {
     readonly base: BaseClient;
     txBuilder: TxBuilder;
     constructor(base: BaseClient);
+    /**
+     * Add assets to the vault allowlist
+     */
+    addAssets(assets: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Delete assets from the vault allowlist.
+     * Assets must have zero vault balance (ATA empty or non-existent).
+     */
+    deleteAssets(assets: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
     /**
      * Emergency access update - bypasses timelock for critical access control changes
      */

package/src/client/base.d.ts

@@ -2,11 +2,13 @@ import * as anchor from "@coral-xyz/anchor";
 import { BN } from "@coral-xyz/anchor";
 import { Wallet } from "@coral-xyz/anchor";
 import { AddressLookupTableAccount, Connection, Keypair, PublicKey, Transaction, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { ExtCctpProgram, ExtDriftProgram, ExtKaminoProgram, ExtMarinadeProgram, ExtOffchainProgram, ExtSplProgram, ExtStakePoolProgram, GlamMintProgram, GlamProtocolProgram } from "../glamExports";
+import { ExtBridgeProgram, ExtEpiProgram, ExtCctpProgram, ExtKaminoProgram, ExtMarinadeProgram, ExtLoopscaleProgram, ExtSplProgram, ExtStakePoolProgram, GlamMintProgram, GlamProtocolProgram } from "../glamExports";
 import { ClusterNetwork, GlamClientConfig } from "../clientConfig";
+import { GlobalConfig } from "../globalConfig";
 import { RequestQueue, StateAccount, StateModel } from "../models";
 import { BlockhashWithCache } from "../utils/blockhash";
-import { JupiterApiClient } from "../utils";
+import { JupiterApiClient, PkMap } from "../utils";
+import { AssetMeta } from "../assets";
 export type TxOptions = {
     signer?: PublicKey;
     computeUnitLimit?: number;
@@ -39,23 +41,29 @@ export declare class BaseClient {
     private _protocolProgram?;
     private _mintProgram?;
     private _extSplProgram?;
-    private _extDriftProgram?;
     private _extKaminoProgram?;
     private _extMarinadeProgram?;
     private _extStakePoolProgram?;
     private _extCctpProgram?;
-    private _extOffchainProgram?;
+    private _extBridgeProgram?;
+    private _extEpiProgram?;
+    private _extLoopscaleProgram?;
     private _statePda?;
+    private _globalConfig?;
+    private _globalConfigPromise?;
+    private _assetMetas?;
+    private _assetMetasPromise?;
     constructor(config?: GlamClientConfig);
     get protocolProgram(): GlamProtocolProgram;
     get mintProgram(): GlamMintProgram;
     get extSplProgram(): ExtSplProgram;
-    get extDriftProgram(): ExtDriftProgram;
     get extKaminoProgram(): ExtKaminoProgram;
     get extMarinadeProgram(): ExtMarinadeProgram;
     get extStakePoolProgram(): ExtStakePoolProgram;
     get extCctpProgram(): ExtCctpProgram;
-    get extOffchainProgram(): ExtOffchainProgram;
+    get extBridgeProgram(): ExtBridgeProgram;
+    get extEpiProgram(): ExtEpiProgram;
+    get extLoopscaleProgram(): ExtLoopscaleProgram;
     get isVaultConnected(): boolean;
     get statePda(): PublicKey;
     set statePda(statePda: PublicKey);
@@ -117,8 +125,23 @@ export declare class BaseClient {
         uiAmount: number;
     }>;
     isLockupEnabled(): Promise<boolean>;
+    fetchGlobalConfig(options?: {
+        refresh?: boolean;
+    }): Promise<GlobalConfig>;
+    fetchAssetMetas(options?: {
+        refresh?: boolean;
+    }): Promise<PkMap<AssetMeta>>;
+    refreshAssetMetaCache(): Promise<PkMap<AssetMeta>>;
+    getAssetMeta(assetMint: string | PublicKey, options?: {
+        refresh?: boolean;
+    }): Promise<AssetMeta>;
+    getSolOracle(options?: {
+        refresh?: boolean;
+    }): Promise<PublicKey>;
     fetchStateAccount(statePda?: PublicKey): Promise<StateAccount>;
-    fetchRequestQueue(requestQueuePda?: PublicKey): Promise<RequestQueue>;
+    private getMintProgramIdForStateAccount;
+    private getMintProgramForStateAccount;
+    fetchRequestQueue(requestQueuePda?: PublicKey, mintProgram?: GlamMintProgram): Promise<RequestQueue>;
     /**
      * Builds a StateModel from onchain accounts (state, mint, etc)
      *

package/src/client/bridge.d.ts

@@ -0,0 +1,183 @@
+import { BN } from "@coral-xyz/anchor";
+import { Keypair, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+import { LayerzeroOftRouteProfile } from "./bridgeRegistry";
+import { LayerzeroOftPolicy, LayerzeroOftRoute, RouteManagementMode } from "../deser/integrationPolicies";
+export declare const LAYERZERO_OFT_PROTOCOL: number;
+type BufferLike = Uint8Array | number[] | Buffer;
+type RouteManagementModeArg = RouteManagementMode | number | {
+    unmanagedOnly: Record<string, never>;
+} | {
+    managedOnly: Record<string, never>;
+} | {
+    either: Record<string, never>;
+};
+export type LayerzeroOftRouteInput = Omit<LayerzeroOftRoute, "managementMode"> & {
+    managementMode: RouteManagementModeArg;
+};
+export type OftTransferParams = {
+    transferId: PublicKey;
+    sourceMint: PublicKey;
+    sourceAmount: BN;
+    providerInstructions: TransactionInstruction[];
+    providerReceipt: PublicKey;
+    managed?: boolean;
+    providerSigners?: Keypair[];
+};
+export type LayerzeroOftSendParams = {
+    transferId?: PublicKey;
+    sourceMint: PublicKey;
+    sourceAmount: BN;
+    destinationChain: number;
+    destinationRecipient: PublicKey;
+    nativeFeeLamports: BN;
+    minAmountLd?: BN;
+    lzTokenFee?: BN;
+    options?: BufferLike;
+    composeMsg?: BufferLike | null;
+    sourceTokenAccount?: PublicKey;
+    nonceAccount?: PublicKey;
+    managed?: boolean;
+    providerProgram?: PublicKey;
+};
+type BridgeTransferStatusAccount = {
+    committed: Record<string, never>;
+} | {
+    validated: Record<string, never>;
+} | {
+    settled: Record<string, never>;
+};
+type BridgeTransferRecordAccount = {
+    glamState: PublicKey;
+    transferId: PublicKey;
+    protocol: number;
+    status: BridgeTransferStatusAccount;
+    managed: true;
+    receiptVerified: true;
+    sourceMint: PublicKey;
+    sourceDecimals: number;
+    providerProgram: PublicKey;
+    providerConfig: PublicKey;
+    sourceAmount: BN;
+    quotedOutAmount: BN;
+    destinationChain: number;
+    destinationRecipient: PublicKey;
+    providerEmitter: PublicKey;
+    providerSequence: BN;
+    committedSlot: BN;
+};
+export declare function getActiveRegistryTransfers(registry: {
+    managedTransferCount: BN | number;
+    transfers: any[];
+}): any[];
+export declare function deriveLayerzeroNoncePda(endpointProgram: PublicKey, sender: PublicKey, destinationChain: number, destinationRecipient: PublicKey): PublicKey;
+export declare function deriveOftAuxiliaryAccountSeed(glamState: PublicKey, transferId: PublicKey): Promise<string>;
+export declare function deriveOftAuxiliaryAccount(glamSigner: PublicKey, glamState: PublicKey, transferId: PublicKey, tokenProgram: PublicKey): Promise<{
+    address: PublicKey;
+    seed: string;
+}>;
+declare class TxBuilder extends BaseTxBuilder<BridgeClient> {
+    addLayerzeroOftRouteIx(route: LayerzeroOftRouteInput, signer?: PublicKey): Promise<TransactionInstruction>;
+    updateLayerzeroOftRouteIx(route: LayerzeroOftRouteInput, signer?: PublicKey): Promise<TransactionInstruction>;
+    deleteLayerzeroOftRouteIx(route: LayerzeroOftRouteInput, signer?: PublicKey): Promise<TransactionInstruction>;
+    buildOftTransferTx(params: OftTransferParams, txOptions?: TxOptions): Promise<{
+        tx: VersionedTransaction;
+        additionalSigners: Keypair[];
+        sessionPda: PublicKey;
+        auxiliaryTokenAccount: PublicKey;
+        sourceTokenAccount: PublicKey;
+    }>;
+}
+declare class LayerzeroOftBridgeProtocolClient {
+    readonly bridge: BridgeClient;
+    constructor(bridge: BridgeClient);
+    buildSendTx(params: LayerzeroOftSendParams, txOptions?: TxOptions): Promise<{
+        auxiliaryTokenAccount: PublicKey;
+        nonceAccount: PublicKey;
+        routeProfile: LayerzeroOftRouteProfile;
+        sendInstruction: TransactionInstruction;
+        tx: VersionedTransaction;
+        additionalSigners: Keypair[];
+        sessionPda: PublicKey;
+        sourceTokenAccount: PublicKey;
+    }>;
+    send(params: LayerzeroOftSendParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export declare class BridgeClient {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    readonly oft: LayerzeroOftBridgeProtocolClient;
+    constructor(base: BaseClient);
+    getRegistryPda(): PublicKey;
+    getSessionPda(transferId: PublicKey): PublicKey;
+    getLayerzeroNoncePda(endpointProgram: PublicKey, sender: PublicKey, destinationChain: number, destinationRecipient: PublicKey): PublicKey;
+    deriveOftAuxiliaryTokenAccount(transferId: PublicKey, sourceMint: PublicKey, signer?: PublicKey): Promise<{
+        tokenProgram: PublicKey;
+        address: PublicKey;
+        seed: string;
+    }>;
+    private resolveLayerzeroOftRouteProfile;
+    private resolveLayerzeroOftNonceAccount;
+    private materializeLayerzeroOftRemainingAccounts;
+    private buildLayerzeroOftInstructionBaseAccounts;
+    private buildLayerzeroOftSendInstruction;
+    fetchLayerzeroOftPolicy(): Promise<LayerzeroOftPolicy | null>;
+    fetchRegistry(): Promise<{
+        glamState: PublicKey;
+        managedTransferCount: number;
+        reserved: number[];
+        transfers: any[];
+    } | null>;
+    fetchSession(transferId: PublicKey): Promise<{
+        glamState: PublicKey;
+        signer: PublicKey;
+        transferId: PublicKey;
+        protocol: number;
+        managed: boolean;
+        sourceMint: PublicKey;
+        sourceDecimals: number;
+        sourceTokenAccount: PublicKey;
+        providerProgram: PublicKey;
+        providerConfig: PublicKey;
+        providerSender: PublicKey;
+        providerDelegate: PublicKey;
+        providerReceipt: PublicKey;
+        providerInstructionHash: number[];
+        providerInstructionCount: number;
+        sourceAmount: BN;
+        quotedOutAmount: BN;
+        initialSourceBalance: BN;
+        initialProviderSequence: BN;
+        destinationChain: number;
+        destinationRecipient: PublicKey;
+        quoteExpiresAt: BN;
+        preparedSlot: BN;
+        bump: number;
+    } | null>;
+    fetchTransferRecordNullable(transferId: PublicKey): Promise<BridgeTransferRecordAccount | null>;
+    addLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
+    updateLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
+    deleteLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
+    buildOftTransferTx(params: OftTransferParams, txOptions?: TxOptions): Promise<{
+        tx: VersionedTransaction;
+        additionalSigners: Keypair[];
+        sessionPda: PublicKey;
+        auxiliaryTokenAccount: PublicKey;
+        sourceTokenAccount: PublicKey;
+    }>;
+    buildLayerzeroOftSendTx(params: LayerzeroOftSendParams, txOptions?: TxOptions): Promise<{
+        auxiliaryTokenAccount: PublicKey;
+        nonceAccount: PublicKey;
+        routeProfile: LayerzeroOftRouteProfile;
+        sendInstruction: TransactionInstruction;
+        tx: VersionedTransaction;
+        additionalSigners: Keypair[];
+        sessionPda: PublicKey;
+        sourceTokenAccount: PublicKey;
+    }>;
+    sendOft(params: OftTransferParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    private extendLookupTables;
+    settleManagedTransfer(transferId: PublicKey, txOptions?: TxOptions): Promise<string>;
+    validateManagedTransfer(transferId: PublicKey, txOptions?: TxOptions): Promise<string>;
+}
+export {};

package/src/client/bridgeRegistry.d.ts

@@ -0,0 +1,32 @@
+import { PublicKey } from "@solana/web3.js";
+import { ClusterNetwork } from "../clientConfig";
+export type RouteAccountPlaceholder = "payer" | "nonce";
+export type SerializableRouteAccountMeta = {
+    pubkey?: PublicKey;
+    placeholder?: RouteAccountPlaceholder;
+    isSigner: boolean;
+    isWritable: boolean;
+};
+export type LayerzeroOftRouteProfile = {
+    sourceMint: PublicKey;
+    destinationChain: number;
+    providerProgram: PublicKey;
+    providerConfig: PublicKey;
+    nonceAccount?: PublicKey;
+    peerConfig: PublicKey;
+    providerSender: PublicKey;
+    enforcedOptions: PublicKey;
+    tokenEscrow: PublicKey;
+    eventAuthority: PublicKey;
+    lookupTables?: PublicKey[];
+    defaultOptions?: Uint8Array | number[] | Buffer;
+    defaultMinAmountBps?: number;
+    remainingAccounts: SerializableRouteAccountMeta[];
+    quoteRemainingAccounts?: SerializableRouteAccountMeta[];
+};
+export declare function resolveCanonicalLayerzeroOftRouteProfile(params: {
+    sourceMint: PublicKey;
+    destinationChain: number;
+    cluster: ClusterNetwork;
+    providerProgram?: PublicKey;
+}): LayerzeroOftRouteProfile | null;

package/src/client/epi.d.ts

@@ -0,0 +1,78 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+type BufferLike32 = Uint8Array | number[] | Buffer;
+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>;
+};
+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;
+};
+declare class TxBuilder extends BaseTxBuilder<EpiClient> {
+    upsertExternalPositionIx(params: UpsertExternalPositionParams, signer?: PublicKey): Promise<TransactionInstruction>;
+    submitExternalObservationIx(params: SubmitExternalObservationParams, signer?: PublicKey): Promise<TransactionInstruction>;
+    validateExternalObservationIx(positionId: BufferLike32, normalizedBaseAssetAmount: BN | null, signer?: PublicKey): Promise<TransactionInstruction>;
+    refreshPricedProtocolIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    submitExternalObservationTx(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    upsertExternalPositionTx(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    validateExternalObservationTx(positionId: BufferLike32, normalizedBaseAssetAmount: BN | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    refreshPricedProtocolTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class EpiClient {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient);
+    getObservationStatePda(): PublicKey;
+    getIntegrationAuthorityPda(): PublicKey;
+    fetchObservationState(): Promise<{
+        glamState: PublicKey;
+        bump: number;
+        positionsLen: number;
+        reserved: number[];
+        positions: any[];
+    } | null>;
+    submitExternalObservation(params: SubmitExternalObservationParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    upsertExternalPosition(params: UpsertExternalPositionParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    validateExternalObservation(positionId: BufferLike32, normalizedBaseAssetAmount: BN | null, txOptions?: TxOptions): Promise<TransactionSignature>;
+    refreshPricedProtocol(txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export {};

package/src/client/fees.d.ts

@@ -6,6 +6,8 @@ declare class TxBuilder extends BaseTxBuilder<FeesClient> {
     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>;
 }
@@ -24,6 +26,8 @@ export declare class FeesClient {
     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

@@ -13,7 +13,7 @@ declare class TxBuilder extends BaseTxBuilder<InvestClient> {
     cancelTx(pubkey: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
     fulfillIx(limit: number | null, signer: PublicKey): Promise<TransactionInstruction>;
     fulfillTx(limit: number | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    claimIx(user: PublicKey | null, signer: PublicKey): Promise<TransactionInstruction>;
+    claimIxs(user: PublicKey | null, signer: PublicKey): Promise<TransactionInstruction[]>;
     claimTx(user: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export declare class InvestClient {

package/src/client/jupiter.d.ts

@@ -3,36 +3,43 @@ import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTrans
 import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
 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> {
+    private resolveSwapInstructionContext;
+    getSwapV2OracleAccounts(inputMint: PublicKey, outputMint: PublicKey, skipQuotePriceCheck: boolean): Promise<JupiterSwapV2OracleAccounts>;
     /**
      * Returns the instructions for a Jupiter swap and the lookup tables
      */
-    swapIxs(options: {
-        quoteParams?: QuoteParams;
-        quoteResponse?: QuoteResponse;
-        swapInstructions?: SwapInstructions;
-        trackingAccount?: PublicKey;
-    }, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
-    swapTx(options: {
-        quoteParams?: QuoteParams;
-        quoteResponse?: QuoteResponse;
-        swapInstructions?: SwapInstructions;
-        trackingAccount?: PublicKey;
-    }, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    getPreInstructions: (signer: PublicKey, inputMint: PublicKey, outputMint: PublicKey, amount: BN, outputTokenProgram?: PublicKey) => Promise<TransactionInstruction[]>;
+    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>;
+    getPreInstructions(signer: PublicKey, inputMint: PublicKey, outputMint: PublicKey, amount: BN, outputTokenProgram?: PublicKey): Promise<TransactionInstruction[]>;
     toTransactionInstruction: (ix: JupiterInstruction) => TransactionInstruction;
 }
 export declare class JupiterSwapClient {
     readonly base: BaseClient;
     readonly vault: VaultClient;
+    readonly klend: KaminoLendingClient;
     readonly txBuilder: TxBuilder;
     readonly jupApi: JupiterApiClient;
-    constructor(base: BaseClient, vault: VaultClient);
-    swap(options: {
-        quoteParams?: QuoteParams;
-        quoteResponse?: QuoteResponse;
-        swapInstructions?: SwapInstructions;
-        trackingAccount?: PublicKey;
-    }, txOptions?: TxOptions): Promise<TransactionSignature>;
+    constructor(base: BaseClient, vault: VaultClient, klend: KaminoLendingClient);
+    swap(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<TransactionSignature>;
+    swapV2(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<TransactionSignature>;
 }
 export {};