@glamsystems/glam-sdk 1.0.12 → 1.0.13-test

package/src/client/loopscale.d.ts

@@ -0,0 +1,84 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction, AccountMeta } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+export declare const LOOPSCALE_BS_AUTH: PublicKey;
+export type LoopscaleExpectedLoanValues = {
+    expectedApy: BN;
+    expectedLqt: [number, number, number, number, number];
+};
+export type CreateLoanParams = {
+    nonce: BN;
+};
+export type DepositCollateralParams = {
+    amount: BN;
+    assetType: number;
+    assetIdentifier: PublicKey;
+    assetIndexGuidance: Buffer;
+};
+export type UpdateWeightMatrixParams = {
+    collateralIndex: number;
+    weightMatrix: [number, number, number, number, number];
+    expectedLoanValues: LoopscaleExpectedLoanValues;
+    assetIndexGuidance: Buffer;
+};
+export type BorrowPrincipalParams = {
+    amount: BN;
+    assetIndexGuidance: Buffer;
+    duration: number;
+    expectedLoanValues: LoopscaleExpectedLoanValues;
+    skipSolUnwrap: boolean;
+};
+export type CreateLoanAccounts = {
+    loan: PublicKey;
+};
+export type DepositCollateralAccounts = {
+    loan: PublicKey;
+    depositMint: PublicKey;
+    borrowerCollateralTa?: PublicKey;
+    loanCollateralTa?: PublicKey;
+    assetIdentifier?: PublicKey;
+    tokenProgram?: PublicKey;
+    associatedTokenProgram?: PublicKey;
+};
+export type UpdateWeightMatrixAccounts = {
+    loan: PublicKey;
+};
+export type BorrowPrincipalAccounts = {
+    loan: PublicKey;
+    strategy: PublicKey;
+    marketInformation: PublicKey;
+    principalMint: PublicKey;
+    borrowerTa?: PublicKey;
+    strategyTa?: PublicKey;
+    tokenProgram?: PublicKey;
+    associatedTokenProgram?: PublicKey;
+    remainingAccounts?: AccountMeta[];
+};
+export declare function getLoopscaleEventAuthorityPda(programId?: PublicKey): PublicKey;
+export declare function getLoopscaleLoanPda(borrower: PublicKey, nonce: BN | bigint | number, programId?: PublicKey): PublicKey;
+declare class TxBuilder extends BaseTxBuilder<LoopscaleClient> {
+    createLoanIx(params: CreateLoanParams, accounts: CreateLoanAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    createLoanTx(params: CreateLoanParams, accounts: CreateLoanAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    depositCollateralIx(params: DepositCollateralParams, accounts: DepositCollateralAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    depositCollateralTx(params: DepositCollateralParams, accounts: DepositCollateralAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    updateWeightMatrixIx(params: UpdateWeightMatrixParams, accounts: UpdateWeightMatrixAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    updateWeightMatrixTx(params: UpdateWeightMatrixParams, accounts: UpdateWeightMatrixAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    borrowPrincipalIx(params: BorrowPrincipalParams, accounts: BorrowPrincipalAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    borrowPrincipalTx(params: BorrowPrincipalParams, accounts: BorrowPrincipalAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class LoopscaleClient {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient);
+    getIntegrationAuthorityPda(): PublicKey;
+    getEventAuthorityPda(): PublicKey;
+    getBsAuth(): PublicKey;
+    getLoanPda(nonce: BN | bigint | number, borrower?: PublicKey): PublicKey;
+    getLoanTokenAta(loan: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): PublicKey;
+    getStrategyTokenAta(strategy: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): PublicKey;
+    createLoan(params: CreateLoanParams, accounts: CreateLoanAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
+    depositCollateral(params: DepositCollateralParams, accounts: DepositCollateralAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
+    updateWeightMatrix(params: UpdateWeightMatrixParams, accounts: UpdateWeightMatrixAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
+    borrowPrincipal(params: BorrowPrincipalParams, accounts: BorrowPrincipalAccounts, 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 {};

package/src/client/price.d.ts

@@ -3,10 +3,11 @@ import { BN } from "@coral-xyz/anchor";
 import { KaminoLendingClient, KaminoVaultsClient } from "./kamino";
 import { BaseClient } from "./base";
 import { StateModel } from "../models";
-import { DriftProtocolClient, DriftVaultsClient } from "./drift";
 import { PkMap, PkSet } from "../utils";
-import { DriftSpotMarket, DriftPerpMarket, DriftVault, KVaultState, Reserve, DriftVaultDepositor } from "../deser";
+import { KVaultState, Reserve } from "../deser";
 import { JupiterApiClient, TokenListItem } from "../utils/jupiterApi";
+import { BridgeClient } from "./bridge";
+import { EpiClient } from "./epi";
 /**
  * Represents a single asset holding within a vault.
  *
@@ -31,7 +32,7 @@ export declare class Holding {
 }
 /**
  * Aggregates all holdings for a GLAM vault.
- * Includes token balances, DeFi positions (Drift, Kamino).
+ * Includes token balances and supported DeFi positions.
  *
  * @param vaultState - The vault's state account address (stores vault configuration)
  * @param vaultPda - The vault's PDA that holds tokens and positions
@@ -52,29 +53,33 @@ export declare class VaultHoldings {
     add(holding: Holding): void;
     toJson(): string;
 }
+type PricingChunk = {
+    ixs: TransactionInstruction[];
+    kaminoReserves: PublicKey[];
+};
 export declare class PriceClient {
     readonly base: BaseClient;
     readonly klend: KaminoLendingClient;
     readonly kvaults: KaminoVaultsClient;
-    readonly drift: DriftProtocolClient;
-    readonly dvaults: DriftVaultsClient;
+    readonly bridge: BridgeClient;
+    readonly epi: EpiClient;
     private readonly getJupiterApi;
     private _stateModel;
     private _lookupTables;
     private _kaminoVaults;
-    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, drift: DriftProtocolClient, dvaults: DriftVaultsClient, getJupiterApi: () => JupiterApiClient);
+    private _priceVaultIxsQueue;
+    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, bridge: BridgeClient, epi: EpiClient, getJupiterApi: () => JupiterApiClient);
     get jupiterApi(): JupiterApiClient;
     get cachedStateModel(): StateModel | null;
     set cachedStateModel(stateModel: StateModel);
     get lookupTables(): PublicKey[];
     get kaminoVaults(): PublicKey[];
+    private getKaminoObligationReserveSets;
     /**
      * Fetches all holdings in the vault.
      *
      * The source of truth for external positions is the `externalPositions` array
      * from the state account, which tracks:
-     * - Drift user PDAs (direct trading positions)
-     * - Drift vault depositor accounts (shares in drift vaults)
      * - Kamino obligation accounts (lending positions)
      * - Kamino vault share ATAs (shares in kamino vaults)
      *
@@ -85,12 +90,6 @@ export declare class PriceClient {
      */
     getVaultHoldings(commitment: Commitment, priceBaseAssetMint?: PublicKey): Promise<VaultHoldings>;
     getPubkeysForTokenHoldings(externalPositionsSet: PkSet, commitment?: Commitment): Promise<PublicKey[]>;
-    getPubkeysForSpotHoldings(driftUserPdas: PublicKey[], commitment?: Commitment): Promise<PkMap<PkSet>>;
-    getPubkeysForPerpHoldings(driftUserPdas: PublicKey[], commitment?: Commitment): Promise<PkMap<PkSet>>;
-    /**
-     * Parses drift vault depositors from known pubkeys.
-     */
-    getDepositorsAndDriftVaults(depositorPubkeys: PublicKey[], commitment?: Commitment): Promise<PkMap<DriftVault>>;
     /**
      * Gets kamino obligation reserves from known obligation pubkeys.
      */
@@ -106,45 +105,33 @@ export declare class PriceClient {
      */
     private getTokenPrice;
     getTokenHoldings(tokenAccountPubkeys: PublicKey[], accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
-    getDriftHoldings(userPubkeys: Iterable<PublicKey>, spotMarketsMap: PkMap<DriftSpotMarket>, perpMarketsMap: PkMap<DriftPerpMarket>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
-    getDriftVaultsHoldings(dvaultDepositorsAndVaults: PkMap<DriftVault>, dvaultDepositorsMap: PkMap<DriftVaultDepositor>, spotMarketsMap: PkMap<DriftSpotMarket>, perpMarketsMap: PkMap<DriftPerpMarket>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
     getKaminoLendHoldings(obligationPubkeys: Iterable<PublicKey>, reservesMap: PkMap<Reserve>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
     getKaminoVaultsHoldings(kvaultAtasAndStates: PkMap<KVaultState>, reservesMap: PkMap<Reserve>, accountsDataMap: PkMap<Buffer>, tokenPricesMap: PkMap<TokenListItem>, priceSource: string): Promise<Holding[]>;
     /**
      * Returns an instruction that prices Kamino obligations.
      * If there are no Kamino obligations, returns null.
      */
-    priceKaminoObligationsIxs(): Promise<TransactionInstruction[]>;
-    priceKaminoVaultSharesIx(): Promise<TransactionInstruction[] | null>;
-    /**
-     * Returns an instruction that prices all Drift users (aka sub-accounts) controlled by the GLAM vault.
-     */
-    priceDriftUsersIx(): Promise<TransactionInstruction | null>;
-    /**
-     * Returns an instruction that prices a drift vault depositor.
-     * If there are no vault depositor accounts, returns null.
-     */
-    priceDriftVaultDepositorsIx(): Promise<TransactionInstruction | null>;
+    priceKaminoObligationsIxs(): Promise<PricingChunk>;
+    priceKaminoVaultSharesIx(): Promise<PricingChunk | null>;
     /**
      * Returns an instruction that prices vault balance and tokens
      */
-    priceVaultTokensIx(): Promise<TransactionInstruction>;
+    priceVaultTokensIx(): Promise<PricingChunk>;
     /**
      * Returns an instruction that prices stake accounts.
      * If there are no stake accounts, returns null.
      */
     priceStakeAccountsIx(): Promise<TransactionInstruction | null>;
     priceVaultIxs(): Promise<TransactionInstruction[]>;
+    private enqueuePriceVaultIxs;
+    private priceManagedTransfersIxs;
+    private priceEpiValidatedPositionsIx;
+    private _priceVaultIxsImpl;
     validateAumIx(): Promise<TransactionInstruction>;
-    getbaseAssetOracle(): Promise<PublicKey>;
-    remainingAccountsForPricingDriftVaultDepositors(parsedVaultDepositors: {
-        address: PublicKey;
-        driftVault: PublicKey;
-        shares: any;
-    }[]): Promise<{
-        remainingAccounts: AccountMeta[];
-        numSpotMarkets: number;
-        numPerpMarkets: number;
-    }>;
-    remainingAccountsForPricingVaultAssets(): Promise<AccountMeta[]>;
+    getBaseAssetOracle(): Promise<PublicKey>;
+    remainingAccountsForPricingVaultAssets(): Promise<[
+        AccountMeta[],
+        PublicKey[]
+    ]>;
 }
+export {};

package/src/client.d.ts

@@ -1,6 +1,5 @@
 import { GlamClientConfig } from "./clientConfig";
 import { BaseClient } from "./client/base";
-import { DriftProtocolClient, DriftVaultsClient } from "./client/drift";
 import { JupiterSwapClient } from "./client/jupiter";
 import { MarinadeClient } from "./client/marinade";
 import { VaultClient } from "./client/vault";
@@ -15,14 +14,15 @@ import { TimelockClient } from "./client/timelock";
 import { StakeClient } from "./client/stake";
 import { StakePoolClient } from "./client/stake-pool";
 import { CctpClient } from "./client/cctp";
+import { BridgeClient } from "./client/bridge";
+import { EpiClient } from "./client/epi";
+import { LoopscaleClient } from "./client/loopscale";
 /**
  * Main entrypoint for the GLAM SDK
  *
  * Lazy loads each client/module at first use
  */
 export declare class GlamClient extends BaseClient {
-    private _drift?;
-    private _driftVaults?;
     private _invest?;
     private _jupiterSwap?;
     private _marinade?;
@@ -39,9 +39,10 @@ export declare class GlamClient extends BaseClient {
     private _fees?;
     private _timelock?;
     private _cctp?;
+    private _bridge?;
+    private _epi?;
+    private _loopscale?;
     constructor(config?: GlamClientConfig);
-    get drift(): DriftProtocolClient;
-    get driftVaults(): DriftVaultsClient;
     get invest(): InvestClient;
     get fees(): FeesClient;
     get jupiterSwap(): JupiterSwapClient;
@@ -58,4 +59,7 @@ export declare class GlamClient extends BaseClient {
     get kaminoVaults(): KaminoVaultsClient;
     get timelock(): TimelockClient;
     get cctp(): CctpClient;
+    get bridge(): BridgeClient;
+    get epi(): EpiClient;
+    get loopscale(): LoopscaleClient;
 }

package/src/constants.d.ts

@@ -9,12 +9,15 @@ export declare const SEED_ACCOUNT_POLICY = "account-policy";
 export declare const SEED_EXTRA_ACCOUNT_METAS = "extra-account-metas";
 export declare const SEED_GLOBAL_CONFIG = "global-config";
 export declare const SEED_INTEGRATION_AUTHORITY = "integration-authority";
+export declare const SEED_OBSERVATION_STATE = "observation-state";
+export declare const SEED_BRIDGE_REGISTRY = "bridge-registry";
+export declare const SEED_BRIDGE_SESSION = "bridge-session";
+export declare const SEED_BRIDGE_TRANSFER_RECORD = "bridge-transfer-record";
 export declare const STAKE_ACCOUNT_SIZE = 200;
 export declare const METEORA_POSITION_SIZE = 8120;
 export declare const KAMINO_OBTRIGATION_SIZE = 3344;
 export declare const KAMINO_RESERVE_SIZE = 8624;
 export declare const KAMINO_VAULT_STATE_SIZE = 62552;
-export declare const DRIFT_VAULT_DEPOSITOR_SIZE = 272;
 export declare const JITO_TIP_DEFAULT: PublicKey;
 export declare const MARINADE_NATIVE_STAKE_AUTHORITY: PublicKey;
 /**
@@ -26,13 +29,12 @@ export declare const WSOL: PublicKey;
 export declare const MSOL: PublicKey;
 export declare const USDC: PublicKey;
 export declare const USDC_DEVNET: PublicKey;
+export declare const USDT: PublicKey;
 export declare const JUP: PublicKey;
 /**
  * Program IDs
  */
 export declare const MARINADE_PROGRAM_ID: PublicKey;
-export declare const DRIFT_PROGRAM_ID: PublicKey;
-export declare const DRIFT_VAULTS_PROGRAM_ID: PublicKey;
 export declare const JUPITER_PROGRAM_ID: PublicKey;
 export declare const SANCTUM_STAKE_POOL_PROGRAM_ID: PublicKey;
 export declare const KAMINO_LENDING_PROGRAM: PublicKey;
@@ -42,6 +44,12 @@ export declare const MEMO_PROGRAM: PublicKey;
 export declare const ALT_PROGRAM_ID: PublicKey;
 export declare const TOKEN_MESSENGER_MINTER_V2: PublicKey;
 export declare const MESSAGE_TRANSMITTER_V2: PublicKey;
+export declare const LOOPSCALE_PROGRAM_ID: PublicKey;
+/**
+ * Token ACL (sRFC-37)
+ */
+export declare const TOKEN_ACL_PROGRAM: PublicKey;
+export declare const TOKEN_ACL_GATE_PROGRAM: PublicKey;
 /**
  * GLAM programs
  */
@@ -55,10 +63,6 @@ export declare const GLAM_REFERRER: PublicKey;
  * CCTP domain to chain name mapping
  */
 export declare const CCTP_DOMAIN_MAPPING: Record<number, string>;
-/**
- * Pool ID to lending pool name mapping for Drift Protocol policies
- */
-export declare const DRIFT_POOL_MAPPING: Record<number, string>;
 /**
  * Get protocol and permission mappings at runtime to ensure correct program IDs based on environment.
  *

package/src/deser/index.d.ts

@@ -1,3 +1,3 @@
 export { Decodable } from "./base";
-export * from "./driftLayouts";
 export * from "./kaminoLayouts";
+export * from "./tokenAclLayouts";

package/src/deser/integrationPolicies.d.ts

@@ -16,8 +16,8 @@ export declare class MintPolicy {
 export declare class JupiterSwapPolicy {
     maxSlippageBps: number;
     swapAllowlist: PublicKey[] | null;
-    static _layout: any;
-    constructor(maxSlippageBps: number, swapAllowlist: PublicKey[] | null);
+    maxDeviationBps: number;
+    constructor(maxSlippageBps: number, swapAllowlist: PublicKey[] | null, maxDeviationBps?: number);
     static decode(buffer: Buffer<ArrayBufferLike>): JupiterSwapPolicy;
     encode(): Buffer;
 }
@@ -28,24 +28,6 @@ export declare class TransferPolicy {
     static decode(buffer: Buffer<ArrayBufferLike>): TransferPolicy;
     encode(): Buffer;
 }
-export declare class DriftVaultsPolicy {
-    vaultsAllowlist: PublicKey[];
-    static _layout: any;
-    constructor(allowlist: PublicKey[]);
-    static decode(buffer: Buffer<ArrayBufferLike>): DriftVaultsPolicy;
-    encode(): Buffer;
-}
-export declare class DriftProtocolPolicy {
-    spotMarketsAllowlist: number[];
-    perpMarketsAllowlist: number[];
-    borrowAllowlist: PublicKey[];
-    orderPriceToleranceBps: number;
-    static _layout: any;
-    static _stagingLayout: any;
-    constructor(spotMarketsAllowlist: number[], perpMarketsAllowlist: number[], borrowAllowlist: PublicKey[], orderPriceToleranceBps?: number);
-    static decode(buffer: Buffer<ArrayBufferLike>, staging?: boolean): DriftProtocolPolicy;
-    encode(staging?: boolean): Buffer;
-}
 export declare class KaminoLendingPolicy {
     marketsAllowlist: PublicKey[];
     borrowAllowlist: PublicKey[];
@@ -61,6 +43,13 @@ export declare class KaminoVaultsPolicy {
     static decode(buffer: Buffer<ArrayBufferLike>): KaminoVaultsPolicy;
     encode(): Buffer;
 }
+export declare class LoopscalePolicy {
+    strategiesAllowlist: PublicKey[];
+    static _layout: any;
+    constructor(strategiesAllowlist: PublicKey[]);
+    static decode(buffer: Buffer<ArrayBufferLike>): LoopscalePolicy;
+    encode(): Buffer;
+}
 export declare class CctpPolicy {
     allowedDestinations: {
         domain: number;
@@ -75,6 +64,27 @@ export declare class CctpPolicy {
     encode(): Buffer;
     get domainToAddressesMap(): Map<number, PublicKey[]>;
 }
+export declare enum RouteManagementMode {
+    UnmanagedOnly = 0,
+    ManagedOnly = 1,
+    Either = 2
+}
+export type LayerzeroOftRoute = {
+    sourceMint: PublicKey;
+    destinationChain: number;
+    destinationRecipient: PublicKey;
+    providerProgram: PublicKey;
+    managementMode: RouteManagementMode;
+    minAmount: BN;
+    maxAmount: BN;
+};
+export declare class LayerzeroOftPolicy {
+    routes: LayerzeroOftRoute[];
+    static _layout: any;
+    constructor(routes: LayerzeroOftRoute[]);
+    static decode(buffer: Buffer<ArrayBufferLike>, _staging?: boolean): LayerzeroOftPolicy;
+    encode(): Buffer;
+}
 export declare enum PeriodType {
     Day = 0,
     Week = 1,

package/src/deser/tokenAclLayouts.d.ts

@@ -0,0 +1,67 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey } from "@solana/web3.js";
+import { Decodable } from "./base";
+/**
+ * Token ACL Gate ListConfig account layout.
+ *
+ * Onchain repr(C):
+ *   discriminator: u8
+ *   authority: Pubkey
+ *   seed: Pubkey
+ *   mode: u8
+ *   wallets_count: u64 (LE)
+ *
+ * PDA seeds: ["list_config", authority, seed]
+ * Program: Token ACL Gate
+ */
+export declare class TokenAclListConfig extends Decodable {
+    discriminator: number;
+    authority: PublicKey;
+    seed: PublicKey;
+    mode: number;
+    walletsCount: BN;
+    static _layout: any;
+    get modeName(): string;
+}
+/**
+ * Token ACL Gate WalletEntry account layout.
+ *
+ * Onchain repr(C):
+ *   discriminator: u8
+ *   wallet_address: Pubkey
+ *   list_config: Pubkey
+ *
+ * PDA seeds: ["wallet_entry", list_config, wallet]
+ * Program: Token ACL Gate
+ */
+export declare class TokenAclWalletEntry extends Decodable {
+    discriminator: number;
+    wallet: PublicKey;
+    listConfig: PublicKey;
+    static _layout: any;
+}
+/**
+ * Token ACL MintConfig account layout.
+ *
+ * Onchain repr(C):
+ *   discriminator: u8
+ *   bump: u8
+ *   enable_permissionless_thaw: PodBool (u8)
+ *   enable_permissionless_freeze: PodBool (u8)
+ *   mint: Pubkey
+ *   freeze_authority: Pubkey
+ *   gating_program: Pubkey
+ *
+ * PDA seeds: ["MINT_CONFIG", mint]
+ * Program: Token ACL
+ */
+export declare class TokenAclMintConfig extends Decodable {
+    discriminator: number;
+    bump: number;
+    enablePermissionlessThaw: number;
+    enablePermissionlessFreeze: number;
+    mint: PublicKey;
+    freezeAuthority: PublicKey;
+    gatingProgram: PublicKey;
+    static _layout: any;
+}

package/src/error.d.ts

@@ -7,7 +7,8 @@ export declare class GlamError extends Error {
 }
 /**
  * Extract the program ID that failed from transaction logs.
- * Looks for "Program <ID> failed:" log lines.
+ * Looks for "Program <ID> failed:" log lines and returns the first match,
+ * which corresponds to the innermost CPI that produced the root cause.
  */
 export declare function extractFailedProgramId(logs?: string[] | null): string | undefined;
 /**