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

package/src/client/loopscale/lend.d.ts

@@ -1,123 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { Commitment, Keypair, PublicKey, TransactionInstruction, TransactionSignature } from "@solana/web3.js";
-import { BaseClient, type ProtocolPolicyClient, type TxOptions } from "../base";
-import { LoopscaleLendingPolicy } from "../../deser/integrationPolicies";
-import { LoopscaleLoan, LoopscaleMarketInformation, LoopscaleStrategy } from "../../deser";
-import { CloseStrategyAccounts, CreateStrategyParams, DepositStrategyAccounts, LoopscaleApiCollateralTermUpdate, LoopscaleApiUpdateStrategyParams, LoopscaleCoreClient, LoopscaleLendTxBuilder, LoopscaleMappedTransaction, LoopscaleMultiCollateralTermsUpdateParams, LoopscaleSellLedgerTerms, LoopscaleStrategyWithMarket, PriceStrategiesAccounts, SellLedgerAccounts, SellLedgerParams, WithdrawStrategyAccounts } from "./core";
-export type CreateStrategyResult = {
-    nonce: PublicKey;
-    strategy: PublicKey;
-    signature: TransactionSignature;
-    signatures: TransactionSignature[];
-};
-export type PriceStrategiesParams = {
-    commitment?: Commitment;
-    solUsdOracle?: PublicKey;
-    baseAssetOracle?: PublicKey;
-};
-export declare class LoopscaleLendClient implements ProtocolPolicyClient<LoopscaleLendingPolicy> {
-    private readonly core;
-    readonly txBuilder: LoopscaleLendTxBuilder;
-    constructor(core: LoopscaleCoreClient);
-    get base(): BaseClient;
-    get programId(): PublicKey;
-    get integrationAuthorityPda(): PublicKey;
-    getEventAuthorityPda(): PublicKey;
-    getStrategyPda(nonce: PublicKey): PublicKey;
-    getStrategyTokenAta(strategy: PublicKey, mint: PublicKey, tokenProgram?: PublicKey): PublicKey;
-    fetchPolicy(): Promise<LoopscaleLendingPolicy | null>;
-    setPolicy(policy: LoopscaleLendingPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-    fetchMarketInformation(marketInformation: PublicKey): Promise<LoopscaleMarketInformation>;
-    fetchStrategy(strategy: PublicKey): Promise<LoopscaleStrategy>;
-    fetchOwnedStrategy(strategy: PublicKey, lender?: PublicKey): Promise<LoopscaleStrategy>;
-    fetchRegisteredStrategies(commitment?: Commitment): Promise<LoopscaleStrategy[]>;
-    fetchStrategyMarket(strategy: PublicKey | LoopscaleStrategy): Promise<LoopscaleMarketInformation>;
-    fetchOwnedStrategyWithMarket(strategy: PublicKey, lender?: PublicKey): Promise<LoopscaleStrategyWithMarket>;
-    assertStrategyClosable(strategy: LoopscaleStrategy): void;
-    resolveSellLedgerMarketAccounts(params: {
-        loan: PublicKey | LoopscaleLoan;
-        ledgerIndex: number;
-        newStrategy: PublicKey | LoopscaleStrategy;
-    }): Promise<LoopscaleSellLedgerTerms>;
-    buildApiSellLedgerIxs(params: {
-        loan: PublicKey;
-        oldStrategy: PublicKey;
-        newStrategy: PublicKey;
-        ledgerIndex: number;
-        expectedSalePrice: BN;
-        assetIndexGuidance: number[];
-    }): Promise<TransactionInstruction[]>;
-    buildApiDepositStrategyIxs(params: {
-        strategy: PublicKey;
-        amount: BN;
-    }): Promise<TransactionInstruction[]>;
-    buildApiWithdrawStrategyIxs(params: {
-        strategy: PublicKey;
-        principalMint?: PublicKey;
-        amount: BN;
-        withdrawAll: boolean;
-    }): Promise<TransactionInstruction[]>;
-    buildApiCloseStrategyIxs(params: {
-        strategy: PublicKey;
-    }): Promise<TransactionInstruction[]>;
-    buildApiUpdateStrategyTxs(params: {
-        strategy: PublicKey;
-        collateralTerms?: LoopscaleApiCollateralTermUpdate;
-        updateParams?: LoopscaleApiUpdateStrategyParams;
-    }): Promise<LoopscaleMappedTransaction[]>;
-    buildApiCreateStrategyTxs(params: CreateStrategyParams & {
-        amount: BN;
-        collateralTerms: LoopscaleMultiCollateralTermsUpdateParams[];
-    }, accounts: {
-        marketInformation: PublicKey;
-        principalMint: PublicKey;
-        nonce: Keypair;
-    }): Promise<{
-        nonce: Keypair;
-        strategy: PublicKey;
-        txs: LoopscaleMappedTransaction[];
-    }>;
-    private replaceApiCreateStrategyAccounts;
-    /**
-     * Creates a strategy account using local ix builder
-     *
-     * @param params
-     * @param accounts
-     * @param txOptions
-     * @returns
-     */
-    createStrategy(params: CreateStrategyParams, accounts: {
-        marketInformation: PublicKey;
-        principalMint: PublicKey;
-        nonce?: Keypair;
-    }, txOptions?: TxOptions): Promise<CreateStrategyResult>;
-    /**
-     * Creates a strategy account and deposits initial principal using API
-     *
-     * @param params
-     * @param accounts
-     * @param txOptions
-     * @returns
-     */
-    createAndDepositStrategy(params: CreateStrategyParams & {
-        amount: BN;
-        collateralTerms: LoopscaleMultiCollateralTermsUpdateParams[];
-    }, accounts: {
-        marketInformation: PublicKey;
-        principalMint: PublicKey;
-        nonce?: Keypair;
-    }, txOptions?: TxOptions): Promise<CreateStrategyResult>;
-    depositStrategy(amount: BN, accounts: DepositStrategyAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    updateStrategy(params: {
-        strategy: PublicKey;
-        collateralTerms?: LoopscaleApiCollateralTermUpdate;
-        updateParams?: LoopscaleApiUpdateStrategyParams;
-    }, txOptions?: TxOptions): Promise<TransactionSignature[]>;
-    withdrawStrategy(amount: BN, withdrawAll: boolean, accounts: WithdrawStrategyAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    closeStrategy(accounts: CloseStrategyAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    sellLedger(params: SellLedgerParams, accounts: SellLedgerAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    priceStrategiesIx(params?: PriceStrategiesParams): Promise<TransactionInstruction | null>;
-    priceStrategies(params?: PriceStrategiesParams, txOptions?: TxOptions): Promise<TransactionSignature | null>;
-    getPriceStrategiesAccounts(commitment?: Commitment): Promise<PriceStrategiesAccounts | null>;
-}

package/src/client/loopscale/vault.d.ts

@@ -1,43 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { Commitment, Keypair, PublicKey, TransactionSignature } from "@solana/web3.js";
-import { BaseClient, type ProtocolPolicyClient, type TxOptions } from "../base";
-import { LoopscaleVault } from "../../deser";
-import { LoopscaleVaultPolicy } from "../../deser/integrationPolicies";
-import { ClaimVaultRewardsAccounts, DepositWithdrawUserVaultAccounts, LoopscaleCoreClient, PriceVaultsAccounts, LoopscaleVaultStakeParams, LoopscaleVaultTxBuilder, LoopscaleVaultUnstakeParams, StakeUserVaultLpAccounts, UnstakeUserVaultLpAccounts } from "./core";
-export type LoopscaleVaultDepositWithdrawAmounts = {
-    amountIn: BN;
-    minAmountOut: BN;
-} | {
-    amountOut: BN;
-    maxAmountIn: BN;
-};
-export type LoopscaleVaultData = {
-    lpDecimals: number;
-    principalDecimals: number;
-    accounts: DepositWithdrawUserVaultAccounts;
-};
-export declare class LoopscaleVaultClient implements ProtocolPolicyClient<LoopscaleVaultPolicy> {
-    private readonly core;
-    readonly txBuilder: LoopscaleVaultTxBuilder;
-    constructor(core: LoopscaleCoreClient);
-    get base(): BaseClient;
-    get programId(): PublicKey;
-    get integrationAuthorityPda(): PublicKey;
-    getEventAuthorityPda(): PublicKey;
-    getVaultPda(vaultNonce: PublicKey): PublicKey;
-    getVaultStrategyPda(vault: PublicKey): PublicKey;
-    getVaultRewardsInfoPda(vault: PublicKey): PublicKey;
-    getVaultStakePda(stakeNonce: PublicKey, vault: PublicKey): PublicKey;
-    getUserRewardsInfoPda(vaultStake: PublicKey): PublicKey;
-    fetchVault(vault: PublicKey): Promise<LoopscaleVault>;
-    resolveVaultData(vault: PublicKey): Promise<LoopscaleVaultData>;
-    fetchPolicy(): Promise<LoopscaleVaultPolicy | null>;
-    setPolicy(policy: LoopscaleVaultPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-    depositUserVault(amounts: LoopscaleVaultDepositWithdrawAmounts, accounts: DepositWithdrawUserVaultAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    withdrawUserVault(amounts: LoopscaleVaultDepositWithdrawAmounts, accounts: DepositWithdrawUserVaultAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    stakeUserVaultLp(params: LoopscaleVaultStakeParams, accounts: StakeUserVaultLpAccounts, txOptions?: TxOptions, additionalSigners?: Keypair[]): Promise<TransactionSignature>;
-    unstakeUserVaultLp(params: LoopscaleVaultUnstakeParams, accounts: UnstakeUserVaultLpAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    claimVaultRewards(mints: PublicKey[], accounts: ClaimVaultRewardsAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    getPriceVaultsAccounts(commitment?: Commitment): Promise<PriceVaultsAccounts | null>;
-}

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,143 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { Connection, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, TokenAccount, type TxOptions } from "./base";
-import { PriceClient } from "./price";
-import { MintIdlModel, RequestType, StateAccountType } from "../models";
-import { MintPolicy } from "../deser/integrationPolicies";
-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> implements ProtocolPolicyTxBuilder<MintPolicy> {
-    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>;
-    setPolicyIx(policy: MintPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
-    setMintPolicyIx(policy: MintPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
-    setPolicyTx(policy: MintPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    setMintPolicyTx(policy: MintPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
-    clearMintPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
-    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    clearMintPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-}
-export declare class MintClient implements ProtocolPolicyClient<MintPolicy> {
-    readonly base: BaseClient;
-    private readonly getPrice?;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient, getPrice?: (() => PriceClient) | undefined);
-    get price(): PriceClient;
-    fetchPolicy(): Promise<MintPolicy | null>;
-    fetchMintPolicy(): Promise<MintPolicy | null>;
-    setPolicy(policy: MintPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    setMintPolicy(policy: MintPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-    clearMintPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-    /**
-     * Fetches token holders of the GLAM mint using helius RPC. Falls back to
-     * getHolders if helius API key is not provided or cluster is not mainnet.
-     */
-    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 {};

package/src/client/orca.d.ts

@@ -1,255 +0,0 @@
-import { BN } from "@coral-xyz/anchor";
-import { AccountMeta, PublicKey, TransactionInstruction, TransactionSignature, VersionedTransaction } from "@solana/web3.js";
-import { BaseClient, BaseTxBuilder, type ProtocolPolicyClient, type ProtocolPolicyTxBuilder, type TxOptions } from "./base";
-import { WhirlpoolsPolicy } from "../deser/integrationPolicies";
-type Numeric = BN | bigint | number;
-export declare const ORCA_POSITION_METADATA_UPDATE_AUTHORITY: PublicKey;
-export type OrcaAccountsType = {
-    transferHookA: Record<string, never>;
-} | {
-    transferHookB: Record<string, never>;
-} | {
-    transferHookReward: Record<string, never>;
-} | {
-    transferHookInput: Record<string, never>;
-} | {
-    transferHookIntermediate: Record<string, never>;
-} | {
-    transferHookOutput: Record<string, never>;
-} | {
-    supplementalTickArrays: Record<string, never>;
-} | {
-    supplementalTickArraysOne: Record<string, never>;
-} | {
-    supplementalTickArraysTwo: Record<string, never>;
-} | {
-    transferHookDepositA: Record<string, never>;
-} | {
-    transferHookDepositB: Record<string, never>;
-} | {
-    transferHookWithdrawalA: Record<string, never>;
-} | {
-    transferHookWithdrawalB: Record<string, never>;
-};
-export type OrcaRemainingAccountsInfo = {
-    slices: Array<{
-        accountsType: OrcaAccountsType;
-        length: number;
-    }>;
-};
-export type OrcaPriceDeviationAccounts = {
-    glamConfig?: PublicKey;
-    tokenMintAOracle: PublicKey;
-    tokenMintBOracle: PublicKey;
-    solUsdOracle?: PublicKey;
-    kaminoReserves?: PublicKey[];
-};
-export type OrcaPriceDeviationRemainingAccounts = {
-    priceDeviationAccounts?: OrcaPriceDeviationAccounts;
-};
-export type OrcaV2RemainingAccounts = {
-    remainingAccountsInfo?: OrcaRemainingAccountsInfo | null;
-    remainingAccounts?: AccountMeta[];
-};
-export type OpenOrcaPositionWithTokenExtensionsParams = {
-    tickLowerIndex: number;
-    tickUpperIndex: number;
-    withTokenMetadataExtension?: boolean;
-};
-export type OpenOrcaPositionWithTokenExtensionsAccounts = {
-    whirlpool: PublicKey;
-    positionMint: PublicKey;
-    position?: PublicKey;
-    positionTokenAccount?: PublicKey;
-    metadataUpdateAuth?: PublicKey;
-};
-export type InitializeOrcaTickArrayParams = {
-    startTickIndex: number;
-};
-export type IncreaseOrcaLiquidityV2Params = OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
-    liquidityAmount: Numeric;
-    tokenMaxA: Numeric;
-    tokenMaxB: Numeric;
-};
-export type DecreaseOrcaLiquidityV2Params = OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
-    liquidityAmount: Numeric;
-    tokenMinA: Numeric;
-    tokenMinB: Numeric;
-};
-export type IncreaseOrcaLiquidityByTokenAmountsMethod = {
-    byTokenAmounts: {
-        tokenMaxA: Numeric;
-        tokenMaxB: Numeric;
-        minSqrtPrice: Numeric;
-        maxSqrtPrice: Numeric;
-    };
-};
-export type IncreaseOrcaLiquidityByTokenAmountsV2Params = OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
-    method: IncreaseOrcaLiquidityByTokenAmountsMethod;
-};
-export type RepositionOrcaLiquidityMethod = {
-    byLiquidity: {
-        newLiquidityAmount: Numeric;
-        existingRangeTokenMinA: Numeric;
-        existingRangeTokenMinB: Numeric;
-        newRangeTokenMaxA: Numeric;
-        newRangeTokenMaxB: Numeric;
-    };
-};
-export type RepositionOrcaLiquidityV2Params = OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
-    newTickLowerIndex: number;
-    newTickUpperIndex: number;
-    method: RepositionOrcaLiquidityMethod;
-};
-export type OrcaPositionAccounts = {
-    whirlpool: PublicKey;
-    position: PublicKey;
-    positionMint: PublicKey;
-    positionTokenAccount?: PublicKey;
-};
-export type OrcaUpdateFeesAndRewardsAccounts = {
-    whirlpool: PublicKey;
-    position: PublicKey;
-    tickArrayLower: PublicKey;
-    tickArrayUpper: PublicKey;
-};
-export type OrcaLiquidityV2Accounts = OrcaPositionAccounts & OrcaV2RemainingAccounts & OrcaPriceDeviationRemainingAccounts & {
-    tokenMintA: PublicKey;
-    tokenMintB: PublicKey;
-    tokenVaultA: PublicKey;
-    tokenVaultB: PublicKey;
-    tickArrayLower: PublicKey;
-    tickArrayUpper: PublicKey;
-    tokenOwnerAccountA?: PublicKey;
-    tokenOwnerAccountB?: PublicKey;
-    tokenProgramA?: PublicKey;
-    tokenProgramB?: PublicKey;
-    memoProgram?: PublicKey;
-};
-export type InitializeOrcaTickArrayAccounts = {
-    whirlpool: PublicKey;
-    tickArray?: PublicKey;
-};
-export type RepositionOrcaLiquidityV2Accounts = Omit<OrcaLiquidityV2Accounts, "tickArrayLower" | "tickArrayUpper"> & {
-    existingTickArrayLower: PublicKey;
-    existingTickArrayUpper: PublicKey;
-    newTickArrayLower: PublicKey;
-    newTickArrayUpper: PublicKey;
-};
-export type CollectOrcaFeesV2Accounts = OrcaPositionAccounts & OrcaV2RemainingAccounts & {
-    tokenMintA: PublicKey;
-    tokenMintB: PublicKey;
-    tokenOwnerAccountA?: PublicKey;
-    tokenOwnerAccountB?: PublicKey;
-    tokenVaultA: PublicKey;
-    tokenVaultB: PublicKey;
-    tokenProgramA?: PublicKey;
-    tokenProgramB?: PublicKey;
-    memoProgram?: PublicKey;
-};
-export type CollectOrcaRewardV2Accounts = OrcaPositionAccounts & OrcaV2RemainingAccounts & {
-    rewardMint: PublicKey;
-    rewardVault: PublicKey;
-    rewardOwnerAccount?: PublicKey;
-    rewardTokenProgram?: PublicKey;
-    memoProgram?: PublicKey;
-};
-export type ParsedOrcaPosition = {
-    whirlpool: PublicKey;
-    positionMint: PublicKey;
-    liquidity: bigint;
-    tickLowerIndex: number;
-    tickUpperIndex: number;
-    rewardInfos: Array<{
-        growthInsideCheckpoint: bigint;
-        amountOwed: bigint;
-    }>;
-    rewardAmountsOwed: bigint[];
-};
-export type ParsedOrcaWhirlpool = {
-    tokenMintA: PublicKey;
-    tokenMintB: PublicKey;
-    tickSpacing: number;
-    liquidity: bigint;
-    tickCurrentIndex: number;
-    rewardLastUpdatedTimestamp: bigint;
-    rewardInfos: Array<{
-        mint: PublicKey;
-        emissionsPerSecondX64: bigint;
-        growthGlobalX64: bigint;
-    }>;
-};
-export type ParsedOrcaTick = {
-    rewardGrowthsOutside: bigint[];
-};
-export type OrcaWhirlpoolPricingAccounts = {
-    numPositions: number;
-    remainingAccounts: AccountMeta[];
-    kaminoReserves: PublicKey[];
-};
-export declare function getOrcaPositionPda(positionMint: PublicKey, programId?: PublicKey): [PublicKey, number];
-export declare function getOrcaTickArrayPda(whirlpool: PublicKey, startTickIndex: number, programId?: PublicKey): [PublicKey, number];
-export declare function parseOrcaPosition(data: Buffer): ParsedOrcaPosition;
-export declare function parseOrcaWhirlpool(data: Buffer): ParsedOrcaWhirlpool;
-export declare function parseOrcaTickArrayTick(data: Buffer, expectedWhirlpool: PublicKey, expectedStartTickIndex: number, tickIndex: number, tickSpacing: number): ParsedOrcaTick;
-export declare function getOrcaTickArrayStartIndex(tickIndex: number, tickSpacing: number): number;
-export declare function deriveTickArrayForPosition(whirlpool: PublicKey, tickIndex: number, tickSpacing: number): PublicKey;
-declare class TxBuilder extends BaseTxBuilder<OrcaWhirlpoolsClient> implements ProtocolPolicyTxBuilder<WhirlpoolsPolicy> {
-    setPolicyIx(policy: WhirlpoolsPolicy, signer?: PublicKey): Promise<TransactionInstruction>;
-    setPolicyTx(policy: WhirlpoolsPolicy, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    clearPolicyIx(signer?: PublicKey): Promise<TransactionInstruction>;
-    clearPolicyTx(txOptions?: TxOptions): Promise<VersionedTransaction>;
-    openPositionWithTokenExtensionsIx(params: OpenOrcaPositionWithTokenExtensionsParams, accounts: OpenOrcaPositionWithTokenExtensionsAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    openPositionWithTokenExtensionsTx(params: OpenOrcaPositionWithTokenExtensionsParams, accounts: OpenOrcaPositionWithTokenExtensionsAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    initializeTickArrayIx(params: InitializeOrcaTickArrayParams, accounts: InitializeOrcaTickArrayAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    initializeTickArrayTx(params: InitializeOrcaTickArrayParams, accounts: InitializeOrcaTickArrayAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    increaseLiquidityV2Ix(params: IncreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    increaseLiquidityV2Tx(params: IncreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    increaseLiquidityByTokenAmountsV2Ix(params: IncreaseOrcaLiquidityByTokenAmountsV2Params, accounts: OrcaLiquidityV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    increaseLiquidityByTokenAmountsV2Tx(params: IncreaseOrcaLiquidityByTokenAmountsV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    decreaseLiquidityV2Ix(params: DecreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    decreaseLiquidityV2Tx(params: DecreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    repositionLiquidityV2Ix(params: RepositionOrcaLiquidityV2Params, accounts: RepositionOrcaLiquidityV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    repositionLiquidityV2Tx(params: RepositionOrcaLiquidityV2Params, accounts: RepositionOrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    updateFeesAndRewardsIx(accounts: OrcaUpdateFeesAndRewardsAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    updateFeesAndRewardsTx(accounts: OrcaUpdateFeesAndRewardsAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    collectFeesV2Ix(accounts: CollectOrcaFeesV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    collectFeesV2Tx(accounts: CollectOrcaFeesV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    collectRewardV2Ix(rewardIndex: number, accounts: CollectOrcaRewardV2Accounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    collectRewardV2Tx(rewardIndex: number, accounts: CollectOrcaRewardV2Accounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    closePositionWithTokenExtensionsIx(accounts: OrcaPositionAccounts, signer?: PublicKey): Promise<TransactionInstruction>;
-    closePositionWithTokenExtensionsTx(accounts: OrcaPositionAccounts, txOptions?: TxOptions): Promise<VersionedTransaction>;
-    private sharedBaseAccounts;
-    private liquidityV2Accounts;
-    private tokenPrograms;
-    private tokenProgramForMint;
-    private withRemainingAccounts;
-    private priceDeviationAccountMetas;
-    private withKaminoReserveRefreshTxOptions;
-    private fetchAndParseKaminoReserves;
-    private refreshKaminoReservesBatchIx;
-}
-export declare class OrcaWhirlpoolsClient implements ProtocolPolicyClient<WhirlpoolsPolicy> {
-    readonly base: BaseClient;
-    readonly txBuilder: TxBuilder;
-    constructor(base: BaseClient);
-    getIntegrationAuthorityPda(): PublicKey;
-    getPositionPda(positionMint: PublicKey): [PublicKey, number];
-    getTickArrayPda(whirlpool: PublicKey, startTickIndex: number): [PublicKey, number];
-    getPositionTokenAta(positionMint: PublicKey): PublicKey;
-    remainingAccountsForPricingWhirlpoolPositions(orcaPositions: PublicKey[]): Promise<OrcaWhirlpoolPricingAccounts | null>;
-    fetchPolicy(): Promise<WhirlpoolsPolicy | null>;
-    setPolicy(policy: WhirlpoolsPolicy, txOptions?: TxOptions): Promise<TransactionSignature>;
-    clearPolicy(txOptions?: TxOptions): Promise<TransactionSignature>;
-    openPositionWithTokenExtensions(params: OpenOrcaPositionWithTokenExtensionsParams, accounts: OpenOrcaPositionWithTokenExtensionsAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    initializeTickArray(params: InitializeOrcaTickArrayParams, accounts: InitializeOrcaTickArrayAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    increaseLiquidityV2(params: IncreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    increaseLiquidityByTokenAmountsV2(params: IncreaseOrcaLiquidityByTokenAmountsV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    decreaseLiquidityV2(params: DecreaseOrcaLiquidityV2Params, accounts: OrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    repositionLiquidityV2(params: RepositionOrcaLiquidityV2Params, accounts: RepositionOrcaLiquidityV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    updateFeesAndRewards(accounts: OrcaUpdateFeesAndRewardsAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    collectFeesV2(accounts: CollectOrcaFeesV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    collectRewardV2(rewardIndex: number, accounts: CollectOrcaRewardV2Accounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-    closePositionWithTokenExtensions(accounts: OrcaPositionAccounts, txOptions?: TxOptions): Promise<TransactionSignature>;
-}
-export {};