@glamsystems/glam-sdk 1.0.12 → 1.0.14-alpha.0

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "1.0.12",
+  "version": "1.0.14-alpha.0",
   "description": "TypeScript SDK for the GLAM Protocol",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",
   "homepage": "https://www.glam.systems",
   "repository": {
     "type": "git",
-    "url": "git@github.com:glamsystems/glam-sdk.git"
+    "url": "git@github.com:glamsystems/glam-sdk-ts.git"
   },
   "keywords": [
     "glam",

package/src/assets.d.ts

@@ -1,5 +1,4 @@
 import { PublicKey } from "@solana/web3.js";
-import { ClusterNetwork } from "./clientConfig";
 export declare const STAKE_POOLS: {
     name: string;
     symbol: string;
@@ -8,6 +7,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 +17,24 @@ 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
+ * Legacy asset metadata snapshot retained for backward compatibility.
  *
- * Note that we use functional prices for LSTs, and the oracle pubkey of a LST asset is the pool state.
+ * Runtime consumers should prefer the onchain-backed helpers in `globalConfig.ts`.
+ * Note that 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;

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, ExtSplProgram, ExtStakePoolProgram, GlamMintProgram, GlamProtocolProgram } from "../glamExports";
 import { ClusterNetwork, GlamClientConfig } from "../clientConfig";
+import type { GlobalConfigAccount } from "../globalConfig";
 import { RequestQueue, StateAccount, StateModel } from "../models";
 import { BlockhashWithCache } from "../utils/blockhash";
 import { JupiterApiClient } from "../utils";
+import { AssetMeta } from "../assets";
 export type TxOptions = {
     signer?: PublicKey;
     computeUnitLimit?: number;
@@ -39,23 +41,27 @@ 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 _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 isVaultConnected(): boolean;
     get statePda(): PublicKey;
     set statePda(statePda: PublicKey);
@@ -117,8 +123,23 @@ export declare class BaseClient {
         uiAmount: number;
     }>;
     isLockupEnabled(): Promise<boolean>;
+    fetchGlobalConfig(options?: {
+        refresh?: boolean;
+    }): Promise<GlobalConfigAccount>;
+    fetchAssetMetas(options?: {
+        refresh?: boolean;
+    }): Promise<Map<string, AssetMeta>>;
+    refreshAssetMetaCache(): Promise<Map<string, 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,184 @@
+import { BN } from "@coral-xyz/anchor";
+import { AccountMeta, 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";
+type BufferLike32 = Uint8Array | number[] | Buffer;
+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: BufferLike32;
+    sourceMint: PublicKey;
+    sourceAmount: BN;
+    providerInstructions: TransactionInstruction[];
+    providerReceipt: PublicKey;
+    sourceTokenAccount?: PublicKey;
+    managed?: boolean;
+    providerSigners?: Keypair[];
+    prepareRemainingAccounts?: AccountMeta[];
+    commitRemainingAccounts?: AccountMeta[];
+};
+export type LayerzeroOftSendParams = {
+    transferId?: BufferLike32;
+    sourceMint: PublicKey;
+    sourceAmount: BN;
+    destinationChain: number;
+    destinationRecipient: PublicKey;
+    nativeFee: BN;
+    minAmountLd?: BN;
+    lzTokenFee?: BN;
+    options?: BufferLike;
+    composeMsg?: BufferLike | null;
+    sourceTokenAccount?: PublicKey;
+    nonceAccount?: PublicKey;
+    managed?: boolean;
+    providerProgram?: PublicKey;
+};
+export declare function deriveLayerzeroNoncePda(endpointProgram: PublicKey, sender: PublicKey, destinationChain: number, destinationRecipient: PublicKey): PublicKey;
+export declare function deriveOftAuxiliaryAccountSeed(glamState: PublicKey, transferId: BufferLike32): Promise<string>;
+export declare function deriveOftAuxiliaryAccount(glamSigner: PublicKey, glamState: PublicKey, transferId: BufferLike32, 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;
+        transferRecordPda: 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;
+        transferRecordPda: 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: BufferLike32): PublicKey;
+    getTransferRecordPda(transferId: BufferLike32): PublicKey;
+    getLayerzeroNoncePda(endpointProgram: PublicKey, sender: PublicKey, destinationChain: number, destinationRecipient: PublicKey): PublicKey;
+    deriveOftAuxiliaryTokenAccount(transferId: BufferLike32, 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: BN;
+        bump: number;
+    } | null>;
+    fetchSession(transferId: BufferLike32): Promise<{
+        glamState: PublicKey;
+        signer: PublicKey;
+        transferId: number[];
+        protocol: number;
+        managed: boolean;
+        sourceMint: PublicKey;
+        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>;
+    fetchTransferRecord(transferId: BufferLike32): Promise<{
+        glamState: PublicKey;
+        transferId: number[];
+        protocol: number;
+        status: any;
+        managed: boolean;
+        receiptVerified: boolean;
+        sourceMint: PublicKey;
+        sourceTokenAccount: PublicKey;
+        providerProgram: PublicKey;
+        providerConfig: PublicKey;
+        sourceAmount: BN;
+        quotedOutAmount: BN;
+        destinationChain: number;
+        destinationRecipient: PublicKey;
+        providerTransferId: number[];
+        providerEmitter: PublicKey;
+        providerSequence: BN;
+        committedSlot: BN;
+        settledSlot: BN;
+        reconciledSlot: BN;
+        failureReason: number;
+        bump: number;
+    }>;
+    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;
+        transferRecordPda: 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;
+        transferRecordPda: PublicKey;
+        sourceTokenAccount: PublicKey;
+    }>;
+    sendOft(params: OftTransferParams, txOptions?: TxOptions): Promise<TransactionSignature>;
+    private extendLookupTables;
+    settleManagedTransfer(transferId: BufferLike32, txOptions?: TxOptions): Promise<string>;
+    reconcileManagedTransfer(transferId: BufferLike32, txOptions?: TxOptions): Promise<string>;
+    failManagedTransfer(transferId: BufferLike32, failureReason: number, txOptions?: TxOptions): Promise<string>;
+    cleanupTransferRecord(transferId: BufferLike32, 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,22 +3,30 @@ import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTrans
 import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
 import { VaultClient } from "./vault";
 import { JupiterApiClient, JupiterInstruction, QuoteParams, QuoteResponse, SwapInstructions } from "../utils/jupiterApi";
+export type JupiterSwapOptions = {
+    quoteParams?: QuoteParams;
+    quoteResponse?: QuoteResponse;
+    swapInstructions?: SwapInstructions;
+    trackingAccount?: PublicKey;
+};
+export type JupiterSwapV2OracleAccounts = {
+    solUsdOracle?: PublicKey;
+    inputTokenOracle?: PublicKey;
+    outputTokenOracle?: PublicKey;
+};
+export type JupiterSwapV2Options = JupiterSwapOptions & {
+    skipQuotePriceCheck?: boolean;
+    oracleAccounts?: JupiterSwapV2OracleAccounts;
+};
 declare class TxBuilder extends BaseTxBuilder<JupiterSwapClient> {
+    private resolveSwapInstructionContext;
     /**
      * 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>;
+    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;
 }
@@ -28,11 +36,7 @@ export declare class JupiterSwapClient {
     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>;
+    swap(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<TransactionSignature>;
+    swapV2(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<TransactionSignature>;
 }
 export {};

package/src/client/mint.d.ts

@@ -1,5 +1,5 @@
 import { BN } from "@coral-xyz/anchor";
-import { PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
+import { Connection, PublicKey, TransactionInstruction, VersionedTransaction } from "@solana/web3.js";
 import { BaseClient, BaseTxBuilder, TokenAccount, TxOptions } from "./base";
 import { PriceClient } from "./price";
 import { MintIdlModel, RequestType, StateAccountType } from "../models";
@@ -22,6 +22,23 @@ export type UpdateMintParams = {
     allowlist?: PublicKey[];
     blocklist?: PublicKey[];
 };
+/**
+ * Resolves the list config + wallet entry pairs needed for permissionless thaw.
+ * Returns empty array if Token ACL is not enabled or no matching pairs found.
+ */
+export declare function resolveThawAccounts(connection: Connection, mintPda: PublicKey, wallet: PublicKey): Promise<{
+    listConfig: PublicKey;
+    walletEntry: PublicKey;
+}[]>;
+/**
+ * Builds a permissionless thaw instruction for the Token ACL program.
+ * Standalone version of TxBuilder.thawPermissionlessIx for use outside
+ * the MintClient context (e.g., in invest.ts).
+ */
+export declare function buildThawPermissionlessIx(mintPda: PublicKey, wallet: PublicKey, listAndWalletPairs: {
+    listConfig: PublicKey;
+    walletEntry: PublicKey;
+}[], signer: PublicKey): TransactionInstruction;
 declare class TxBuilder extends BaseTxBuilder<MintClient> {
     setTokenAccountsStatesIx(tokenAccounts: PublicKey[], frozen: boolean, glamSigner: PublicKey): Promise<TransactionInstruction>;
     setTokenAccountsStatesTx(tokenAccounts: PublicKey[], frozen: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
@@ -45,6 +62,30 @@ declare class TxBuilder extends BaseTxBuilder<MintClient> {
     unpauseRedemptionTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
     closeMintIx(signer?: PublicKey): Promise<TransactionInstruction>;
     closeMintTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    enableTokenAclIx(gatingProgram: PublicKey | undefined, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    enableTokenAclTx(gatingProgram: PublicKey | undefined, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    aclGateCreateListIx(seed: Buffer, mode: number, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    aclGateCreateListTx(seed: Buffer, mode: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    aclGateAddWalletIx(listConfig: PublicKey, wallet: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    aclGateAddWalletTx(listConfig: PublicKey, wallet: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    aclGateRemoveWalletIx(listConfig: PublicKey, walletEntry: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    aclGateRemoveWalletTx(listConfig: PublicKey, walletEntry: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    aclGateDeleteListIx(listConfig: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    aclGateDeleteListTx(listConfig: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    aclGateSetupExtraMetasIx(listConfigs: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
+    aclGateSetupExtraMetasTx(listConfigs: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+    tokenAclFreezeIx(tokenAccounts: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
+    tokenAclFreezeTx(tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+    tokenAclThawIx(tokenAccounts: PublicKey[], glamSigner: PublicKey): Promise<TransactionInstruction>;
+    tokenAclThawTx(tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+    thawPermissionlessIx(wallet: PublicKey, listAndWalletPairs: {
+        listConfig: PublicKey;
+        walletEntry: PublicKey;
+    }[], signer: PublicKey): TransactionInstruction;
+    thawPermissionlessTx(wallet: PublicKey, listAndWalletPairs: {
+        listConfig: PublicKey;
+        walletEntry: PublicKey;
+    }[], txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 export declare class MintClient {
     readonly base: BaseClient;
@@ -69,6 +110,18 @@ export declare class MintClient {
     burn(from: PublicKey, amount: BN | number, unfreeze?: boolean, txOptions?: TxOptions): Promise<string>;
     createTokenAccount(owner: PublicKey, setFrozen: boolean, txOptions?: TxOptions): Promise<string>;
     setTokenAccountsStates(tokenAccounts: PublicKey[], frozen: boolean, txOptions?: TxOptions): Promise<string>;
+    enableTokenAcl(gatingProgram?: PublicKey, txOptions?: TxOptions): Promise<string>;
     forceTransfer(from: PublicKey, to: PublicKey, amount: BN | number, unfreeze?: boolean, txOptions?: TxOptions): Promise<string>;
+    tokenAclFreeze(tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<string>;
+    tokenAclThaw(tokenAccounts: PublicKey[], txOptions?: TxOptions): Promise<string>;
+    aclGateCreateList(seed: Buffer, mode?: number, txOptions?: TxOptions): Promise<string>;
+    aclGateAddWallet(listConfig: PublicKey, wallet: PublicKey, txOptions?: TxOptions): Promise<string>;
+    aclGateRemoveWallet(listConfig: PublicKey, walletEntry: PublicKey, txOptions?: TxOptions): Promise<string>;
+    aclGateDeleteList(listConfig: PublicKey, txOptions?: TxOptions): Promise<string>;
+    aclGateSetupExtraMetas(listConfigs: PublicKey[], txOptions?: TxOptions): Promise<string>;
+    thawPermissionless(wallet: PublicKey, listAndWalletPairs: {
+        listConfig: PublicKey;
+        walletEntry: PublicKey;
+    }[], txOptions?: TxOptions): Promise<string>;
 }
 export {};