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

package/package.json

@@ -1,27 +1,47 @@
 {
   "name": "@glamsystems/glam-sdk",
-  "version": "1.1.0-alpha.5",
+  "version": "1.1.0",
   "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-ts.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",
+    "buffer-layout.d.ts",
+    "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"
   },
   "dependencies": {
     "@coral-xyz/anchor": "^0.31.1",
     "@coral-xyz/borsh": "^0.31.1",
-    "@glamsystems/ix-mapper": "0.2.3",
-    "@glamsystems/sanctum-lst-list": "^0.2.54",
+    "@glamsystems/ix-mapper": "0.2.4",
+    "@glamsystems/sanctum-lst-list": "^0.2.55",
     "@marinade.finance/marinade-ts-sdk": "^5.0.15",
     "@solana/spl-stake-pool": "^1.1.5",
     "@solana/spl-token": "^0.4.9",
@@ -37,16 +57,8 @@
     "node": ">=24.0.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

@@ -0,0 +1,39 @@
+import { PublicKey } from "@solana/web3.js";
+import { PkMap } from "./utils/pkmap";
+export declare const STAKE_POOLS: {
+    name: string;
+    symbol: string;
+    mint: string;
+    decimals: number;
+    logoURI: string;
+    tokenProgram: PublicKey;
+    poolState: PublicKey;
+    isMarinade: boolean;
+}[];
+export declare const STAKE_POOLS_MAP: Map<string, {
+    name: string;
+    symbol: string;
+    mint: string;
+    decimals: number;
+    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;
+    oracleSource: string;
+}
+/**
+ * Transforms the LST list into a map of asset metas.
+ *
+ * We use functional prices for LSTs, and the oracle pubkey of a LST
+ * asset is the pool state.
+ */
+export declare const ASSETS_MAINNET: PkMap<AssetMeta>;

package/src/client/access.d.ts

@@ -0,0 +1,57 @@
+import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
+import { BN } from "@coral-xyz/anchor";
+import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
+import { EmergencyAccessUpdateArgs } from "../models";
+declare class TxBuilder extends BaseTxBuilder<AccessClient> {
+    emergencyAccessUpdateIx(args: Partial<EmergencyAccessUpdateArgs>, signer?: PublicKey): Promise<TransactionInstruction>;
+    emergencyAccessUpdateTx(args: Partial<EmergencyAccessUpdateArgs>, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    enableDisableProtocolsIx(integrationProgram: PublicKey, protocolBitmask: number, setEnabled: boolean, glamSigner: PublicKey): Promise<TransactionInstruction>;
+    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>;
+}
+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
+     */
+    emergencyAccessUpdate(args: Partial<EmergencyAccessUpdateArgs>, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Enable protocols for an integration program
+     */
+    enableProtocols(integrationProgram: PublicKey, protocolBitmask: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Disable protocols for an integration program
+     */
+    disableProtocols(integrationProgram: PublicKey, protocolBitmask: number, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Grant delegate permissions for a specific protocol
+     */
+    grantDelegatePermissions(delegate: PublicKey, integrationProgram: PublicKey, protocolBitflag: number, permissionsBitmask: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Revoke delegate permissions for a specific protocol
+     */
+    revokeDelegatePermissions(delegate: PublicKey, integrationProgram: PublicKey, protocolBitflag: number, permissionsBitmask: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
+    /**
+     * Set protocol policy data for an integration
+     */
+    setProtocolPolicy(integrationProgram: PublicKey, protocolBitflag: number, data: Buffer, txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export {};

package/src/client/base.d.ts

@@ -0,0 +1,234 @@
+import * as anchor from "@coral-xyz/anchor";
+import { BN } from "@coral-xyz/anchor";
+import { Wallet } from "@coral-xyz/anchor";
+import { Connection, Keypair, PublicKey, Transaction, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { type LookupTableInput } from "../utils/lookupTables";
+import { ExtBridgeProgram, ExtEpiProgram, ExtCctpProgram, ExtJupiterProgram, ExtKaminoProgram, ExtMarinadeProgram, ExtLoopscaleProgram, ExtPhoenixProgram, ExtOrcaProgram, 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, PhoenixApiClient, PkMap } from "../utils";
+import { AssetMeta } from "../assets";
+export type TxOptions = {
+    signer?: PublicKey;
+    computeUnitLimit?: number;
+    getPriorityFeeMicroLamports?: (tx: VersionedTransaction) => Promise<number>;
+    maxFeeLamports?: number;
+    useMaxFee?: boolean;
+    preInstructions?: TransactionInstruction[];
+    postInstructions?: TransactionInstruction[];
+    lookupTables?: LookupTableInput[];
+    simulate?: boolean;
+};
+export interface ProtocolPolicyTxBuilder<TPolicy> {
+    setPolicyIx(policy: TPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
+    setPolicyTx(policy: TPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+}
+export interface ProtocolPolicyClient<TPolicy> {
+    fetchPolicy(): Promise<TPolicy | null>;
+    setPolicy(policy: TPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
+}
+export type TokenAccount = {
+    owner: PublicKey;
+    pubkey: PublicKey;
+    mint: PublicKey;
+    programId: PublicKey;
+    decimals: number;
+    amount: string;
+    uiAmount: number;
+    frozen: boolean;
+};
+export declare class BaseClient {
+    cluster: ClusterNetwork;
+    provider: anchor.Provider;
+    blockhashWithCache: BlockhashWithCache;
+    jupiterApiKey?: string;
+    jupiterApiClient?: JupiterApiClient;
+    phoenixApiUrl?: string;
+    phoenixApiClient?: PhoenixApiClient;
+    onSentListeners: Set<(sig: string) => void>;
+    readonly staging: boolean;
+    private _protocolProgram?;
+    private _mintProgram?;
+    private _extSplProgram?;
+    private _extKaminoProgram?;
+    private _extMarinadeProgram?;
+    private _extStakePoolProgram?;
+    private _extCctpProgram?;
+    private _extBridgeProgram?;
+    private _extEpiProgram?;
+    private _extLoopscaleProgram?;
+    private _extPhoenixProgram?;
+    private _extJupiterProgram?;
+    private _extOrcaProgram?;
+    private _statePda?;
+    private _globalConfig?;
+    private _globalConfigPromise?;
+    private _assetMetas?;
+    private _assetMetasPromise?;
+    private _defaultLookupTablesPromise?;
+    private _glamLookupTablesPromise?;
+    private _glamLookupTablesCacheKey?;
+    constructor(config?: GlamClientConfig);
+    get protocolProgram(): GlamProtocolProgram;
+    get mintProgram(): GlamMintProgram;
+    get extSplProgram(): ExtSplProgram;
+    get extKaminoProgram(): ExtKaminoProgram;
+    get extMarinadeProgram(): ExtMarinadeProgram;
+    get extStakePoolProgram(): ExtStakePoolProgram;
+    get extCctpProgram(): ExtCctpProgram;
+    get extBridgeProgram(): ExtBridgeProgram;
+    get extEpiProgram(): ExtEpiProgram;
+    get extLoopscaleProgram(): ExtLoopscaleProgram;
+    get extPhoenixProgram(): ExtPhoenixProgram;
+    get extJupiterProgram(): ExtJupiterProgram;
+    get extOrcaProgram(): ExtOrcaProgram;
+    get isVaultConnected(): boolean;
+    get statePda(): PublicKey;
+    set statePda(statePda: PublicKey);
+    /**
+     * Mainnet-only default lookup tables (Kamino lending, Loopscale).
+     * Cached for the session; safe to assume static contents.
+     */
+    private getDefaultLookupTables;
+    /**
+     * Discovers GLAM ALTs for the connected vault and caches the result for the
+     * session.
+     *
+     * Call `invalidateGlamLookupTablesCache()` after creating or extending an ALT
+     * to force a re-discovery on the next tx.
+     */
+    private getGlamLookupTablesCached;
+    invalidateGlamLookupTablesCache(): void;
+    private warmupGlamLookupTables;
+    get isMainnet(): boolean;
+    /**
+     * Converts a legacy transaction into a versioned transaction.
+     */
+    intoVersionedTransaction(tx: Transaction, { lookupTables, signer, computeUnitLimit, getPriorityFeeMicroLamports, maxFeeLamports, useMaxFee, simulate, }: TxOptions): Promise<VersionedTransaction>;
+    /**
+     * Signs, sends, and confirms a transaction.
+     *
+     * Legacy transactions receive missing fee-payer/blockhash values here and
+     * extra signers are applied with `partialSign` before wallet signing.
+     * Versioned transactions are expected to be fully built by the caller; extra
+     * signers are applied after wallet signing so this remains compatible with
+     * transactions created by another `@solana/web3.js` package instance.
+     *
+     * Transactions are sent with preflight disabled because callers commonly
+     * simulate while building compute-budget instructions.
+     */
+    sendAndConfirm(tx: VersionedTransaction | Transaction, additionalSigners?: Keypair[]): Promise<TransactionSignature>;
+    private confirmTransaction;
+    get connection(): Connection;
+    get signer(): PublicKey;
+    get wallet(): Wallet;
+    get vaultPda(): PublicKey;
+    get mintPda(): PublicKey;
+    get escrowPda(): PublicKey;
+    get extraMetasPda(): PublicKey;
+    get requestQueuePda(): PublicKey;
+    /**
+     * Returns SOL and token balances of the given owner pubkey
+     */
+    getSolAndTokenBalances(owner: PublicKey): Promise<{
+        balanceLamports: number;
+        uiAmount: number;
+        tokenAccounts: TokenAccount[];
+    }>;
+    /**
+     * Returns user's token account for the given mint and token program ID
+     */
+    getAta(mint: PublicKey, owner: PublicKey, tokenProgram?: anchor.web3.PublicKey): PublicKey;
+    /**
+     * Returns glam vault's token account for the given mint and token program ID
+     */
+    getVaultAta(mint: PublicKey, tokenProgramId?: PublicKey): PublicKey;
+    /**
+     * Returns user's glam mint token account
+     */
+    getMintAta(user?: PublicKey): PublicKey;
+    /**
+     * Returns glam vault's SOL balance
+     */
+    getVaultBalance(): Promise<number>;
+    /**
+     * Returns glam vault's SOL balance in lamports
+     */
+    getVaultLamports(): Promise<number>;
+    /**
+     * Returns glam vault's token balance for the given mint
+     */
+    getVaultTokenBalance(mintPubkey: PublicKey): Promise<{
+        amount: BN;
+        uiAmount: number;
+    }>;
+    /**
+     * Returns user's glam mint token balance
+     */
+    getMintTokenBalance(owner?: PublicKey): Promise<{
+        amount: BN;
+        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>;
+    private getMintProgramIdForStateAccount;
+    private getMintProgramForStateAccount;
+    fetchRequestQueue(requestQueuePda?: PublicKey, mintProgram?: GlamMintProgram): Promise<RequestQueue>;
+    /**
+     * Builds a StateModel from onchain accounts (state, mint, etc)
+     *
+     * @param statePda Optional state PDA
+     */
+    fetchStateModel(statePda?: PublicKey): Promise<StateModel>;
+    /**
+     * Fetches glam state models and applies filters
+     *
+     * @param filterOptions Filter options
+     */
+    fetchGlamStates(filterOptions?: {
+        owner?: PublicKey;
+        delegate?: PublicKey;
+        type?: string;
+    }): Promise<StateModel[]>;
+    fetchProtocolPolicy<T>(integProgramId: PublicKey, protocolBitflag: number, policyClass: {
+        decode(buffer: Buffer, staging?: boolean): T;
+    }): Promise<T | null>;
+}
+/**
+ * Base transaction builder for sub-clients
+ */
+export declare class BaseTxBuilder<T extends {
+    base: BaseClient;
+}> {
+    readonly client: T;
+    constructor(client: T);
+    clearProtocolPolicyIx(integrationProgram: PublicKey, protocolBitflag: number, signer?: PublicKey): Promise<TransactionInstruction>;
+    clearProtocolPolicyTx(integrationProgram: PublicKey, protocolBitflag: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    /**
+     * Build a legacy transaction with the given instructions.
+     * Pre and post instructions in txOptions are preserved.
+     */
+    build(ixs: TransactionInstruction[], txOptions?: TxOptions): Transaction;
+    /**
+     * Build a versioned transaction that is ready to be sent.
+     */
+    buildVersionedTx(ixs: TransactionInstruction[], txOptions?: TxOptions): Promise<VersionedTransaction>;
+}

package/src/client/bridge.d.ts

@@ -0,0 +1,205 @@
+import { BN } from "@coral-xyz/anchor";
+import { Keypair, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
+import { BaseClient, BaseTxBuilder, ProtocolPolicyClient, ProtocolPolicyTxBuilder, TxOptions } from "./base";
+import { LayerzeroOftRouteProfile } from "./bridgeRegistry";
+import { LayerzeroOftPolicy, LayerzeroOftRoute, RouteManagementMode } from "../deser/integrationPolicies";
+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> implements ProtocolPolicyTxBuilder<LayerzeroOftPolicy> {
+    setPolicyIx(policy: LayerzeroOftPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
+    setPolicyTx(policy: LayerzeroOftPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
+    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
+    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
+    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 implements ProtocolPolicyClient<LayerzeroOftPolicy> {
+    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;
+    fetchPolicy(): Promise<LayerzeroOftPolicy | null>;
+    fetchLayerzeroOftPolicy(): Promise<LayerzeroOftPolicy | null>;
+    setPolicy(policy: LayerzeroOftPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
+    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
+    fetchRegistry(): Promise<{
+        glamState: PublicKey;
+        managedTransferCount: number;
+        reserved: number[];
+        transfers: {
+            transferId: PublicKey;
+            sourceMint: PublicKey;
+            destinationRecipient: PublicKey;
+            providerProgram: PublicKey;
+            providerConfig: PublicKey;
+            providerEmitter: PublicKey;
+            sourceAmount: BN;
+            quotedOutAmount: BN;
+            providerSequence: BN;
+            committedSlot: BN;
+            protocol: number;
+            destinationChain: number;
+            sourceDecimals: number;
+            status: number;
+            reserved: number[];
+        }[];
+    } | 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;