@glamsystems/glam-sdk 1.0.14-alpha.5 → 1.1.0-alpha.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "1.0.14-alpha.5",
+  "version": "1.1.0-alpha.0",
   "description": "TypeScript SDK for the GLAM Protocol",
   "main": "./index.cjs.js",
   "module": "./index.esm.js",

package/src/assets.d.ts

@@ -1,4 +1,5 @@
 import { PublicKey } from "@solana/web3.js";
+import { PkMap } from "./utils/pkmap";
 export declare const STAKE_POOLS: {
     name: string;
     symbol: string;
@@ -27,14 +28,12 @@ export interface AssetMeta {
     decimals: number;
     oracle: PublicKey;
     programId: PublicKey;
-    oracleSource?: string;
+    oracleSource: string;
 }
 /**
- * Legacy asset metadata snapshot retained for backward compatibility.
+ * Transforms the LST list into a map of asset metas.
  *
- * 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
+ * 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 ASSETS_MAINNET: PkMap<AssetMeta>;

package/src/client/base.d.ts

@@ -2,12 +2,12 @@ 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 { ExtBridgeProgram, ExtEpiProgram, ExtCctpProgram, ExtKaminoProgram, ExtMarinadeProgram, ExtSplProgram, ExtStakePoolProgram, GlamMintProgram, GlamProtocolProgram } from "../glamExports";
+import { ExtBridgeProgram, ExtEpiProgram, ExtCctpProgram, ExtKaminoProgram, ExtMarinadeProgram, ExtLoopscaleProgram, ExtNeutralProgram, ExtSplProgram, ExtStakePoolProgram, GlamMintProgram, GlamProtocolProgram } from "../glamExports";
 import { ClusterNetwork, GlamClientConfig } from "../clientConfig";
-import type { GlobalConfigAccount } from "../globalConfig";
+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;
@@ -47,6 +47,8 @@ export declare class BaseClient {
     private _extCctpProgram?;
     private _extBridgeProgram?;
     private _extEpiProgram?;
+    private _extLoopscaleProgram?;
+    private _extNeutralProgram?;
     private _statePda?;
     private _globalConfig?;
     private _globalConfigPromise?;
@@ -62,6 +64,8 @@ export declare class BaseClient {
     get extCctpProgram(): ExtCctpProgram;
     get extBridgeProgram(): ExtBridgeProgram;
     get extEpiProgram(): ExtEpiProgram;
+    get extLoopscaleProgram(): ExtLoopscaleProgram;
+    get extNeutralProgram(): ExtNeutralProgram;
     get isVaultConnected(): boolean;
     get statePda(): PublicKey;
     set statePda(statePda: PublicKey);
@@ -125,11 +129,11 @@ export declare class BaseClient {
     isLockupEnabled(): Promise<boolean>;
     fetchGlobalConfig(options?: {
         refresh?: boolean;
-    }): Promise<GlobalConfigAccount>;
+    }): Promise<GlobalConfig>;
     fetchAssetMetas(options?: {
         refresh?: boolean;
-    }): Promise<Map<string, AssetMeta>>;
-    refreshAssetMetaCache(): Promise<Map<string, AssetMeta>>;
+    }): Promise<PkMap<AssetMeta>>;
+    refreshAssetMetaCache(): Promise<PkMap<AssetMeta>>;
     getAssetMeta(assetMint: string | PublicKey, options?: {
         refresh?: boolean;
     }): Promise<AssetMeta>;

package/src/client/bridge.d.ts

@@ -1,8 +1,9 @@
 import { BN } from "@coral-xyz/anchor";
-import { AccountMeta, Keypair, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+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>;
@@ -20,11 +21,8 @@ export type OftTransferParams = {
     sourceAmount: BN;
     providerInstructions: TransactionInstruction[];
     providerReceipt: PublicKey;
-    sourceTokenAccount?: PublicKey;
     managed?: boolean;
     providerSigners?: Keypair[];
-    prepareRemainingAccounts?: AccountMeta[];
-    commitRemainingAccounts?: AccountMeta[];
 };
 export type LayerzeroOftSendParams = {
     transferId?: PublicKey;
@@ -32,7 +30,7 @@ export type LayerzeroOftSendParams = {
     sourceAmount: BN;
     destinationChain: number;
     destinationRecipient: PublicKey;
-    nativeFee: BN;
+    nativeFeeLamports: BN;
     minAmountLd?: BN;
     lzTokenFee?: BN;
     options?: BufferLike;
@@ -68,6 +66,10 @@ type BridgeTransferRecordAccount = {
     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<{
@@ -85,8 +87,6 @@ declare class TxBuilder extends BaseTxBuilder<BridgeClient> {
         auxiliaryTokenAccount: PublicKey;
         sourceTokenAccount: PublicKey;
     }>;
-    priceManagedTransfersIxs(): Promise<TransactionInstruction[]>;
-    priceManagedTransfersTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
 }
 declare class LayerzeroOftBridgeProtocolClient {
     readonly bridge: BridgeClient;
@@ -154,7 +154,6 @@ export declare class BridgeClient {
         preparedSlot: BN;
         bump: number;
     } | null>;
-    fetchTransferRecord(transferId: PublicKey): Promise<BridgeTransferRecordAccount>;
     fetchTransferRecordNullable(transferId: PublicKey): Promise<BridgeTransferRecordAccount | null>;
     addLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
     updateLayerzeroOftRoute(route: LayerzeroOftRouteInput, txOptions?: TxOptions): Promise<TransactionSignature>;
@@ -180,6 +179,5 @@ export declare class BridgeClient {
     private extendLookupTables;
     settleManagedTransfer(transferId: PublicKey, txOptions?: TxOptions): Promise<string>;
     validateManagedTransfer(transferId: PublicKey, txOptions?: TxOptions): Promise<string>;
-    priceManagedTransfers(txOptions?: TxOptions): Promise<string>;
 }
 export {};

package/src/client/jupiter.d.ts

@@ -18,10 +18,10 @@ export type JupiterSwapV2OracleAccounts = {
 };
 export type JupiterSwapV2Options = JupiterSwapOptions & {
     skipQuotePriceCheck?: boolean;
-    oracleAccounts?: JupiterSwapV2OracleAccounts;
 };
 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
      */
@@ -29,7 +29,7 @@ declare class TxBuilder extends BaseTxBuilder<JupiterSwapClient> {
     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[]>;
+    getPreInstructions(signer: PublicKey, inputMint: PublicKey, outputMint: PublicKey, amount: BN, outputTokenProgram?: PublicKey): Promise<TransactionInstruction[]>;
     toTransactionInstruction: (ix: JupiterInstruction) => TransactionInstruction;
 }
 export declare class JupiterSwapClient {

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/neutral.d.ts

@@ -0,0 +1,111 @@
+import { BN } from "@coral-xyz/anchor";
+import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+import { NeutralPolicy } from "../deser/integrationPolicies";
+export declare const NEUTRAL_PROTOCOL = 1;
+export declare const NEUTRAL_BUNDLE_DISCRIMINATOR: Buffer<ArrayBuffer>;
+export type InitializeBundleDepositorAccounts = {
+    bundle: PublicKey;
+    userBundleAccount?: PublicKey;
+};
+export type RequestDepositAccounts = {
+    bundle: PublicKey;
+    userTokenAccount?: PublicKey;
+    pendingDepositTokenAccount?: PublicKey;
+    treasuryAccount?: PublicKey;
+    userBundleAccount?: PublicKey;
+    assetAddress?: PublicKey;
+    oracleData?: PublicKey;
+    bundleTempData?: PublicKey;
+    pendingBundleAssetAuthority?: PublicKey;
+    tokenProgram?: PublicKey;
+};
+export type NeutralBundleView = {
+    treasuryAccount: PublicKey;
+    assetAddress: PublicKey;
+    assetDecimals: number;
+    permissioned: boolean;
+};
+export declare class NeutralBundleAccount {
+    readonly _address: PublicKey;
+    discriminator: number[];
+    name: number[];
+    manager: PublicKey;
+    keeper: PublicKey;
+    treasuryAccount: PublicKey;
+    allocatedReceivers: PublicKey[];
+    bundleUnderlyingBalance: BN;
+    maxDepositAmount: BN;
+    withdrawalDelay: BN;
+    performanceFee: number;
+    managementFeeBps: number;
+    depositFee: number;
+    withdrawalFee: number;
+    managerPfeeShares: BN;
+    currentAllocationBps: number;
+    oracleBuffer: BN;
+    totalShares: BN;
+    assetPrecision: BN;
+    assetAddress: PublicKey;
+    assetDecimals: number;
+    withdrawalTMin: BN;
+    withdrawalTMax: BN;
+    withdrawalCurve: number;
+    permissionned: boolean;
+    managerMfeeShares: BN;
+    minDepositAmount: BN;
+    oracleUpdateTimeLimit: BN;
+    oracleMaxAge: BN;
+    withdrawalRedemptionRequestCutoffTs: BN;
+    withdrawalRedemptionUnlockCurrentCycleTs: BN;
+    withdrawalRedemptionUnlockNextCycleTs: BN;
+    padding: number[];
+    static _layout: any;
+    static decode(address: PublicKey, buffer: Buffer): NeutralBundleAccount;
+    getAddress(): PublicKey;
+    get permissioned(): boolean;
+    toView(): NeutralBundleView;
+}
+export declare function getNeutralUserBundlePda(authority: PublicKey, bundle: PublicKey): PublicKey;
+export declare function getNeutralOracleDataPda(bundle: PublicKey): PublicKey;
+export declare function getNeutralBundleTempDataPda(bundle: PublicKey): PublicKey;
+export declare function getNeutralPendingBundleAssetAuthorityPda(bundle: PublicKey): PublicKey;
+export declare function getNeutralPendingDepositTokenAccountPda(pendingBundleAssetAuthority: PublicKey, assetAddress: PublicKey): PublicKey;
+declare class TxBuilder extends BaseTxBuilder<NeutralClient> {
+    setNeutralPolicyIx(policy: NeutralPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
+    setNeutralPolicyTx(policy: NeutralPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    initializeBundleDepositorIx(accounts: InitializeBundleDepositorAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    initializeBundleDepositorTx(accounts: InitializeBundleDepositorAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    initializePermissionedBundleDepositorIx(accounts: InitializeBundleDepositorAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
+    initializePermissionedBundleDepositorTx(accounts: InitializeBundleDepositorAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    requestDepositIx(accounts: RequestDepositAccounts, amount: BN | bigint | number | string, signer?: PublicKey): Promise<TransactionInstruction>;
+    requestDepositTx(accounts: RequestDepositAccounts, amount: BN | bigint | number | string, txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export declare class NeutralClient {
+    readonly base: BaseClient;
+    readonly txBuilder: TxBuilder;
+    constructor(base: BaseClient);
+    baseAccounts(signer?: PublicKey): {
+        glamState: PublicKey;
+        glamVault: PublicKey;
+        glamSigner: PublicKey;
+        integrationAuthority: PublicKey;
+        cpiProgram: PublicKey;
+        glamProtocolProgram: PublicKey;
+        systemProgram: PublicKey;
+    };
+    getIntegrationAuthorityPda(): PublicKey;
+    getUserBundlePda(bundle: PublicKey): PublicKey;
+    getOracleDataPda(bundle: PublicKey): PublicKey;
+    getBundleTempDataPda(bundle: PublicKey): PublicKey;
+    getPendingBundleAssetAuthorityPda(bundle: PublicKey): PublicKey;
+    fetchBundle(bundle: PublicKey): Promise<NeutralBundleAccount>;
+    fetchPolicy(): Promise<NeutralPolicy | null>;
+    setPolicy(policy: NeutralPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    allowlistBundle(bundle: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    initializeBundleDepositor(bundle: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    initializePermissionedBundleDepositor(bundle: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
+    requestDeposit(bundle: PublicKey, amount: BN | bigint | number | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+    requestDepositUiAmount(bundle: PublicKey, amount: number | string, txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export {};

package/src/client/price.d.ts

@@ -7,6 +7,7 @@ import { PkMap, PkSet } from "../utils";
 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.
  *
@@ -52,22 +53,28 @@ 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 bridge: BridgeClient;
+    readonly epi: EpiClient;
     private readonly getJupiterApi;
     private _stateModel;
     private _lookupTables;
     private _kaminoVaults;
     private _priceVaultIxsQueue;
-    constructor(base: BaseClient, klend: KaminoLendingClient, kvaults: KaminoVaultsClient, bridge: BridgeClient, getJupiterApi: () => JupiterApiClient);
+    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.
      *
@@ -104,12 +111,12 @@ export declare class PriceClient {
      * Returns an instruction that prices Kamino obligations.
      * If there are no Kamino obligations, returns null.
      */
-    priceKaminoObligationsIxs(): Promise<TransactionInstruction[]>;
-    priceKaminoVaultSharesIx(): 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.
@@ -117,6 +124,7 @@ export declare class PriceClient {
     priceStakeAccountsIx(): Promise<TransactionInstruction | null>;
     priceVaultIxs(): Promise<TransactionInstruction[]>;
     private enqueuePriceVaultIxs;
+    private priceManagedTransfersIxs;
     private priceEpiValidatedPositionsIx;
     private _priceVaultIxsImpl;
     validateAumIx(): Promise<TransactionInstruction>;
@@ -126,3 +134,4 @@ export declare class PriceClient {
         PublicKey[]
     ]>;
 }
+export {};

package/src/client.d.ts

@@ -16,6 +16,8 @@ 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";
+import { NeutralClient } from "./client/neutral";
 /**
  * Main entrypoint for the GLAM SDK
  *
@@ -40,6 +42,8 @@ export declare class GlamClient extends BaseClient {
     private _cctp?;
     private _bridge?;
     private _epi?;
+    private _loopscale?;
+    private _neutral?;
     constructor(config?: GlamClientConfig);
     get invest(): InvestClient;
     get fees(): FeesClient;
@@ -59,4 +63,6 @@ export declare class GlamClient extends BaseClient {
     get cctp(): CctpClient;
     get bridge(): BridgeClient;
     get epi(): EpiClient;
+    get loopscale(): LoopscaleClient;
+    get neutral(): NeutralClient;
 }

package/src/constants.d.ts

@@ -44,6 +44,8 @@ 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;
+export declare const NTBUNDLE_PROGRAM_ID: PublicKey;
 /**
  * Token ACL (sRFC-37)
  */

package/src/deser/integrationPolicies.d.ts

@@ -43,6 +43,20 @@ 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 NeutralPolicy {
+    bundlesAllowlist: PublicKey[];
+    static _layout: any;
+    constructor(bundlesAllowlist: PublicKey[]);
+    static decode(buffer: Buffer<ArrayBufferLike>): NeutralPolicy;
+    encode(): Buffer;
+}
 export declare class CctpPolicy {
     allowedDestinations: {
         domain: number;