@glamsystems/glam-sdk 1.1.0-alpha.0 → 1.1.0-alpha.2

package/src/client/invest.d.ts

@@ -1,37 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { PendingRequest } from "../models";
-declare class TxBuilder extends BaseTxBuilder<InvestClient> {
-    subscribeIxs(amount: BN, signer: PublicKey): Promise<TransactionInstruction[]>;
-    subscribeTx(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    queuedSubscribeIxs(amount: BN, signer: PublicKey): Promise<TransactionInstruction[]>;
-    queuedSubscribeTx(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    queuedRedeemIx(amount: BN, signer: PublicKey): Promise<TransactionInstruction>;
-    queuedRedeemTx(amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    cancelIx(pubkey: PublicKey | null, signer: PublicKey): Promise<TransactionInstruction>;
-    cancelTx(pubkey: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    fulfillIx(limit: number | null, signer: PublicKey): Promise<TransactionInstruction>;
-    fulfillTx(limit: number | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    claimIxs(user: PublicKey | null, signer: PublicKey): Promise<TransactionInstruction[]>;
-    claimTx(user: PublicKey | null, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class InvestClient {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    subscribe(amount: BN, queued?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    queuedRedeem(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancel(txOptions?: TxOptions): Promise<TransactionSignature>;
-    cancelForUser(user: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    fulfill(limit: number | null, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Claims the pending request for the signer.
-     * @param txOptions
-     * @returns
-     */
-    claim(txOptions?: TxOptions): Promise<TransactionSignature>;
-    claimForUser(user: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    fetchPendingRequest(user?: PublicKey): Promise<PendingRequest | null>;
-}
-export {};

package/src/client/jupiter.d.ts

@@ -1,45 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { VaultClient } from "./vault";
-import { JupiterApiClient, JupiterInstruction, QuoteParams, QuoteResponse, SwapInstructions } from "../utils/jupiterApi";
-import { KaminoLendingClient } from "./kamino";
-export type JupiterSwapOptions = {
-    quoteParams?: QuoteParams;
-    quoteResponse?: QuoteResponse;
-    swapInstructions?: SwapInstructions;
-    trackingAccount?: PublicKey;
-};
-export type JupiterSwapV2OracleAccounts = {
-    solUsdOracle?: PublicKey;
-    inputTokenOracle?: PublicKey;
-    outputTokenOracle?: PublicKey;
-    kaminoReservesToRefresh: PublicKey[];
-};
-export type JupiterSwapV2Options = JupiterSwapOptions & {
-    skipQuotePriceCheck?: boolean;
-};
-declare class TxBuilder extends BaseTxBuilder<JupiterSwapClient> {
-    private resolveSwapInstructionContext;
-    getSwapV2OracleAccounts(inputMint: PublicKey, outputMint: PublicKey, skipQuotePriceCheck: boolean): Promise<JupiterSwapV2OracleAccounts>;
-    /**
-     * Returns the instructions for a Jupiter swap and the lookup tables
-     */
-    swapIxs(options: JupiterSwapOptions, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
-    swapV2Ixs(options: JupiterSwapV2Options, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey[]]>;
-    swapTx(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    swapV2Tx(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    getPreInstructions(signer: PublicKey, inputMint: PublicKey, outputMint: PublicKey, amount: BN, outputTokenProgram?: PublicKey): Promise<TransactionInstruction[]>;
-    toTransactionInstruction: (ix: JupiterInstruction) => TransactionInstruction;
-}
-export declare class JupiterSwapClient {
-    readonly base: BaseClient;
-    readonly vault: VaultClient;
-    readonly klend: KaminoLendingClient;
-    readonly txBuilder: TxBuilder;
-    readonly jupApi: JupiterApiClient;
-    constructor(base: BaseClient, vault: VaultClient, klend: KaminoLendingClient);
-    swap(options: JupiterSwapOptions, txOptions?: TxOptions): Promise<TransactionSignature>;
-    swapV2(options: JupiterSwapV2Options, txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

package/src/client/kamino/farm.d.ts

@@ -1,39 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "../base";
-import { PkMap } from "../../utils";
-import { KaminoLendingClient } from "./lending";
-import { ParsedFarmState, ParsedFarmUser } from "./types";
-declare class TxBuilder extends BaseTxBuilder<KaminoFarmClient> {
-    stakeTx(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    unstakeTx(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    harvestTx(farmUserStates: PublicKey[], txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class KaminoFarmClient {
-    readonly base: BaseClient;
-    readonly kaminoLending: KaminoLendingClient;
-    txBuilder: TxBuilder;
-    constructor(base: BaseClient, kaminoLending: KaminoLendingClient);
-    /**
-     * Finds and parses farm states for the given owner
-     */
-    findAndParseFarmUserStates(owner: PublicKey): Promise<ParsedFarmUser[]>;
-    parseFarmState(data: Buffer): Promise<ParsedFarmState>;
-    fetchAndParseFarmStates(farms: PublicKey[]): Promise<PkMap<ParsedFarmState>>;
-    farmVaultTokenAccount: (farm: PublicKey, mint: PublicKey) => PublicKey;
-    farmVaultsAuthority: (farm: PublicKey) => PublicKey;
-    rewardsTreasuryVault: (globalConfig: PublicKey, mint: PublicKey) => PublicKey;
-    /**
-     * Harvest rewards from Kamino farms
-     */
-    harvest(vaultFarmStates: PublicKey[], txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Stake tokens to a farm
-     */
-    stake(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Unstake tokens from a farm
-     */
-    unstake(amount: BN, farmState: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};

package/src/client/kamino/index.d.ts

@@ -1,4 +0,0 @@
-export * from "./types";
-export * from "./lending";
-export * from "./farm";
-export * from "./vaults";

package/src/client/kamino/lending.d.ts

@@ -1,86 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "../base";
-import { Reserve, Obligation } from "../../deser/kaminoLayouts";
-import { VaultClient } from "../vault";
-import { RefreshObligationAccounts, RefreshReserveAccounts, RefreshObligationFarmsForReserveArgs, RefreshObligationFarmsForReserveAccounts } from "./types";
-declare class TxBuilder extends BaseTxBuilder<KaminoLendingClient> {
-    refreshObligationIx(accounts: RefreshObligationAccounts): TransactionInstruction;
-    refreshReserveIx(accounts: RefreshReserveAccounts): TransactionInstruction;
-    refreshObligationFarmsForReserveIx(args: RefreshObligationFarmsForReserveArgs, accounts: RefreshObligationFarmsForReserveAccounts): TransactionInstruction;
-    refreshReservesBatchIx(reserves: Reserve[], skipPriceUpdates: boolean): TransactionInstruction;
-    refreshReservesIxs(reserves: Reserve[]): TransactionInstruction[];
-    refreshObligationCollateralFarmsForReservesIxs(obligation: PublicKey, reserves: Reserve[]): TransactionInstruction[];
-    refreshObligationDebtFarmsForReservesIxs(obligation: PublicKey, reserves: Reserve[]): TransactionInstruction[];
-    /**
-     * Returns two instructions that refresh reserves in batch and refresh obligation
-     */
-    refreshReservesAndObligationIxs(obligation: PublicKey, targetReserve: Reserve): Promise<TransactionInstruction[]>;
-    /**
-     * Returns an instruction to initialize obligation farm user if it doesn't exist
-     *
-     * @param mode 0 collateral farm, 1 debt farm
-     */
-    initObligationFarmUserForReserveIx(obligation: PublicKey, reserve: Reserve, mode: 0 | 1, signer?: PublicKey): Promise<{
-        farmUser: null;
-        initIx: null;
-    } | {
-        farmUser: PublicKey;
-        initIx: TransactionInstruction | null;
-    }>;
-    initUserMetadataTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    depositIxs(market: PublicKey, asset: PublicKey, amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    depositTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdrawIxs(market: PublicKey, asset: PublicKey, amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    withdrawTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    borrowIxs(market: PublicKey, asset: PublicKey, amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    borrowTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    requestElevationGroupIxs(lendingMarket: PublicKey, elevationGroup: number, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    requestElevationGroupTx(lendingMarket: PublicKey, elevationGroup: number, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    repayIxs(market: PublicKey, asset: PublicKey, amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    repayTx(market: PublicKey, asset: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class KaminoLendingClient {
-    readonly base: BaseClient;
-    readonly vault: VaultClient;
-    private reserves;
-    private obligations;
-    txBuilder: TxBuilder;
-    constructor(base: BaseClient, vault: VaultClient);
-    /**
-     * Initializes Kamino user metadata
-     */
-    initUserMetadata(txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Deposits asset to the lending market.
-     */
-    deposit(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Withdraws asset from the lending market.
-     */
-    withdraw(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Borrows asset from the lending market.
-     */
-    borrow(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Requests an elevation group for an obligation.
-     */
-    requestElevationGroup(market: PublicKey | string, elevationGroup: number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Repays asset to the lending market.
-     */
-    repay(market: PublicKey | string, asset: PublicKey | string, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    getUserMetadataPda(owner: PublicKey): PublicKey;
-    getObligationPda(owner: PublicKey, market: PublicKey, args?: {
-        tag: number;
-        id: number;
-    }): PublicKey;
-    getFarmUserState(farmUser: PublicKey, farm: PublicKey): PublicKey;
-    getMarketAuthority(market: PublicKey): PublicKey;
-    fetchAndParseObligation(obligation: PublicKey): Promise<Obligation>;
-    fetchAndParseReserves(reserves: PublicKey[]): Promise<Reserve[]>;
-    findAndParseReserve(market: PublicKey, asset: PublicKey): Promise<Reserve>;
-    findAndParseObligations(owner: PublicKey, market?: PublicKey): Promise<Obligation[]>;
-}
-export {};

package/src/client/kamino/types.d.ts

@@ -1,56 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey } from "@solana/web3.js";
-export declare const DEFAULT_OBLIGATION_ARGS: {
-    tag: number;
-    id: number;
-};
-export declare const KAMINO_VAULTS_EVENT_AUTHORITY: PublicKey;
-export interface RefreshObligationAccounts {
-    lendingMarket: PublicKey;
-    obligation: PublicKey;
-    reserves: PublicKey[];
-}
-export interface RefreshReserveAccounts {
-    reserve: PublicKey;
-    lendingMarket: PublicKey;
-    pythOracle: PublicKey;
-    switchboardPriceOracle: PublicKey;
-    switchboardTwapOracle: PublicKey;
-    scopePrices: PublicKey;
-}
-export interface RefreshObligationFarmsForReserveArgs {
-    mode: number;
-}
-export interface RefreshObligationFarmsForReserveAccounts {
-    crank: PublicKey;
-    baseAccounts: {
-        obligation: PublicKey;
-        lendingMarketAuthority: PublicKey;
-        reserve: PublicKey;
-        reserveFarmState: PublicKey;
-        obligationFarmUserState: PublicKey;
-        lendingMarket: PublicKey;
-    };
-    farmsProgram: PublicKey;
-    rent: PublicKey;
-    systemProgram: PublicKey;
-}
-export interface ParsedFarmState {
-    globalConfig: PublicKey;
-    farmTokenMint: PublicKey;
-    farmTokenDecimals: BN;
-    farmTokenProgram: PublicKey;
-    farmVault: PublicKey;
-    rewards: {
-        index: number;
-        mint: PublicKey;
-        minClaimDurationSeconds: BN;
-        tokenProgram: PublicKey;
-        rewardsVault: PublicKey;
-    }[];
-}
-export interface ParsedFarmUser {
-    pubkey: PublicKey;
-    farmState: PublicKey;
-    unclaimedRewards: BN[];
-}

package/src/client/kamino/vaults.d.ts

@@ -1,31 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, AccountMeta, Commitment } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, TxOptions } from "../base";
-import { KVaultAllocation, KVaultState } from "../../deser/kaminoLayouts";
-import { KaminoLendingClient } from "./lending";
-declare class TxBuilder extends BaseTxBuilder<KaminoVaultsClient> {
-    depositTx(vault: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    withdrawTx(vault: PublicKey, amount: BN, txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class KaminoVaultsClient {
-    readonly base: BaseClient;
-    readonly kaminoLending: KaminoLendingClient;
-    private vaultStates;
-    private shareMintToVaultPdaMap;
-    txBuilder: TxBuilder;
-    constructor(base: BaseClient, kaminoLending: KaminoLendingClient);
-    /**
-     * Deposit to a Kamino vault
-     */
-    deposit(vault: PublicKey, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Withdraw from a Kamino vault
-     */
-    withdraw(vault: PublicKey, amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    findAndParseKaminoVaults(commitment?: Commitment): Promise<KVaultState[]>;
-    get globalConfigPda(): PublicKey;
-    getVaultPdasByShareMints(mints: PublicKey[]): Promise<PublicKey[]>;
-    fetchAndParseVaultState(vault: PublicKey): Promise<KVaultState>;
-    composeRemainingAccounts(allocations: KVaultAllocation[], pricingMode?: boolean): Promise<AccountMeta[]>;
-}
-export {};

package/src/client/loopscale.d.ts

@@ -1,84 +0,0 @@
-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/marinade.d.ts

@@ -1,42 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { PublicKey, VersionedTransaction, TransactionSignature, TransactionInstruction, Keypair } from "@solana/web3.js";
-import { MarinadeState } from "@marinade.finance/marinade-ts-sdk";
-import { BaseClient, BaseTxBuilder, TxOptions } from "./base";
-import { StakeAccountInfo } from "../utils/accounts";
-import { StakeClient } from "./stake";
-export type Ticket = {
-    address: PublicKey;
-    lamports: number;
-    createdEpoch: number;
-    isDue: boolean;
-    isClaimable: boolean;
-};
-declare class TxBuilder extends BaseTxBuilder<MarinadeClient> {
-    depositIxs(amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    depositTx(amount: BN, txOptions: TxOptions): Promise<VersionedTransaction>;
-    depositNativeIxs(amount: BN, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    depositNativeTx(amount: BN, txOptions: TxOptions): Promise<any>;
-    depositStakeAccountIx(stakeAccount: PublicKey, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    depositStakeAccountTx(stakeAccount: PublicKey, txOptions: TxOptions): Promise<VersionedTransaction>;
-    withdrawStakeAccountIxs(amount: BN, deactivate: boolean | undefined, glamSigner: PublicKey): Promise<[TransactionInstruction[], Keypair]>;
-    withdrawStakeAccountTx(amount: BN, deactivate: boolean | undefined, txOptions: TxOptions): Promise<[VersionedTransaction, Keypair]>;
-}
-export declare class MarinadeClient {
-    readonly base: BaseClient;
-    readonly stake: StakeClient;
-    private marinadeState;
-    txBuilder: TxBuilder;
-    constructor(base: BaseClient, stake: StakeClient);
-    deposit(amount: BN | number, txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositNative(amount: BN, txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositStakeAccount(stakeAccount: PublicKey, txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdrawStakeAccount(amount: BN, deactivate?: boolean, txOptions?: TxOptions): Promise<TransactionSignature>;
-    fetchMarinadeState(): Promise<MarinadeState>;
-    getParsedStakeAccountInfo(stakeAccount: PublicKey): Promise<any>;
-    parseAccountList(data: Buffer, itemSize: number): PublicKey[];
-    getIndexes(stakeAccount: StakeAccountInfo, stakeList: any, validatorList: any): Promise<{
-        stakeIndex: number;
-        validatorIndex: number;
-    }>;
-}
-export {};

package/src/client/mint.d.ts

@@ -1,127 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-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";
-import { UpdateStateParams } from "./state";
-export type InitMintParams = {
-    accountType: StateAccountType;
-    name: number[];
-    symbol: string;
-    uri: string;
-    baseAssetMint: PublicKey;
-    decimals?: number;
-} & Partial<MintIdlModel>;
-export type UpdateMintParams = {
-    permanentDelegate?: PublicKey;
-    defaultAccountStateFrozen?: boolean;
-    lockupPeriod?: number;
-    maxCap?: BN;
-    minSubscription?: BN;
-    minRedemption?: BN;
-    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>;
-    createTokenAccountIxs(owner: PublicKey, setFrozen: boolean, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    createTokenAccountTx(owner: PublicKey, setFrozen?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    mintIxs(recipient: PublicKey, amount: BN, forceThaw: boolean | undefined, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    mintTx(recipient: PublicKey, amount: BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    burnIxs(from: PublicKey, amount: BN, forceThaw: boolean, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    burnTx(from: PublicKey, amount: BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    forceTransferIxs(from: PublicKey, to: PublicKey, amount: BN, forceThaw: boolean, glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    forceTransferTx(from: PublicKey, to: PublicKey, amount: BN, forceThaw?: boolean, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    initializeIxs(initMintParams: InitMintParams, stateParams: UpdateStateParams | null, glamSigner: PublicKey): Promise<[TransactionInstruction[], PublicKey]>;
-    initializeTx(initMintParams: InitMintParams, stateParams: UpdateStateParams | null, txOptions?: TxOptions): Promise<[VersionedTransaction, PublicKey]>;
-    crystallizeFeesIxs(glamSigner: PublicKey): Promise<TransactionInstruction[]>;
-    updateIx(mintModel: Partial<MintIdlModel>, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    updateTx(mintModel: Partial<MintIdlModel>, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    emergencyUpdateIx(requestType: RequestType, setPaused: boolean, glamSigner: PublicKey): Promise<TransactionInstruction>;
-    pauseSubscriptionTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    unpauseSubscriptionTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    pauseRedemptionTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    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;
-    private readonly getPrice?;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient, getPrice?: (() => PriceClient) | undefined);
-    get price(): PriceClient;
-    /**
-     * Fetches token holders of the GLAM mint using helius RPC
-     */
-    fetchTokenHolders(showZeroBalance?: boolean): Promise<TokenAccount[]>;
-    getHolders(showZeroBalance?: boolean): Promise<TokenAccount[]>;
-    initialize(initMintParams: InitMintParams, txOptions?: TxOptions): Promise<string>;
-    initializeWithStateParams(initMintParams: InitMintParams, stateParams: UpdateStateParams, txOptions?: TxOptions): Promise<string>;
-    update(mintModel: Partial<MintIdlModel>, txOptions?: TxOptions): Promise<string>;
-    pauseSubscription(txOptions?: TxOptions): Promise<string>;
-    unpauseSubscription(txOptions?: TxOptions): Promise<string>;
-    pauseRedemption(txOptions?: TxOptions): Promise<string>;
-    unpauseRedemption(txOptions?: TxOptions): Promise<string>;
-    close(txOptions?: TxOptions): Promise<string>;
-    mint(to: PublicKey, amount: BN | number, unfreeze?: boolean, txOptions?: TxOptions): Promise<string>;
-    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 {};