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

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

@@ -0,0 +1,123 @@
+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

@@ -0,0 +1,43 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,143 @@
+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

@@ -0,0 +1,255 @@
+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 {};