@huma-finance/soroban-pool-manager 0.0.11-beta.17 → 0.0.15-beta.20

package/dist/cjs/index.d.ts

@@ -0,0 +1,786 @@
+/// <reference types="node" />
+import { Buffer } from "buffer";
+import { AssembledTransaction, ContractClient, ContractClientOptions } from "@stellar/stellar-sdk/lib/contract_client/index.js";
+import type { u32, u64, u128, Option } from "@stellar/stellar-sdk/lib/contract_client";
+export * from "@stellar/stellar-sdk";
+export * from "@stellar/stellar-sdk/lib/contract_client/index.js";
+export * from "@stellar/stellar-sdk/lib/rust_types/index.js";
+export declare const networks: {
+    readonly testnet: {
+        readonly networkPassphrase: "Test SDF Network ; September 2015";
+        readonly contractId: "CDPNNXOD6LVIXD2VYAH6CKQ6TPQYDITGJ4END7LFLR7OIZNHLCWLF347";
+    };
+};
+export type ClientDataKey = {
+    tag: "HumaConfig";
+    values: void;
+} | {
+    tag: "PoolStorage";
+    values: void;
+} | {
+    tag: "Pool";
+    values: void;
+};
+export interface PoolManagerAddressesChangedEvent {
+    pool: string;
+    pool_storage: string;
+}
+export interface PoolStorageAddressesChangedEvent {
+    credit: string;
+    pool: string;
+    pool_manager: string;
+}
+export interface PoolOperatorAddedEvent {
+    operator: string;
+}
+export interface PoolOperatorRemovedEvent {
+    operator: string;
+}
+export interface HumaConfigChangedEvent {
+    huma_config: string;
+    huma_owner: string;
+    is_protocol_on: boolean;
+    sentinel: string;
+}
+export interface TrancheAddressesChangedEvent {
+    junior_addr: string;
+    senior_addr: string;
+}
+/**
+ * Event indicating that a new epoch has started.
+ * # Fields:
+ * * `epoch_id` - The ID of the epoch that just started.
+ * * `end_time` - The time when the current epoch should end.
+ */
+export interface NewEpochStartedEvent {
+    end_time: u64;
+    epoch_id: u64;
+}
+/**
+ * Event indicating that the current epoch has closed.
+ * # Fields:
+ * * `epoch_id` - The ID of the epoch that just closed.
+ */
+export interface EpochClosedEvent {
+    epoch_id: u64;
+}
+/**
+ * Event indicating that the epoch has been processed after the pool is closed.
+ * # Fields:
+ * * `epoch_id` - The ID of the epoch that has been processed.
+ */
+export interface EpochProcessedAfterPoolClosureEvent {
+    epoch_id: u64;
+}
+/**
+ * Event indicating that pending redemption requests have been processed.
+ * # Fields:
+ * * `senior_tranche_assets` - The total amount of assets in the senior tranche.
+ * * `senior_tranche_price` - The LP token price of the senior tranche.
+ * * `junior_tranche_assets` - The total amount of assets in the junior tranche.
+ * * `junior_tranche_price` - The LP token price of the junior tranche.
+ * * `unprocessed_amount` - The amount of assets requested for redemption but not fulfilled.
+ */
+export interface RedemptionRequestsProcessedEvent {
+    junior_tranche_assets: u128;
+    junior_tranche_price: u128;
+    senior_tranche_assets: u128;
+    senior_tranche_price: u128;
+    unprocessed_amount: u128;
+}
+export declare const Errors: {
+    301: {
+        message: string;
+    };
+    302: {
+        message: string;
+    };
+    303: {
+        message: string;
+    };
+    304: {
+        message: string;
+    };
+    305: {
+        message: string;
+    };
+    306: {
+        message: string;
+    };
+    307: {
+        message: string;
+    };
+    308: {
+        message: string;
+    };
+    309: {
+        message: string;
+    };
+};
+/**
+ * Event indicating that the pool has been enabled.
+ * # Fields:
+ * * `by` - The address that enabled the pool.
+ */
+export interface PoolEnabledEvent {
+    by: string;
+}
+/**
+ * Event indicating that the pool has been disabled.
+ * # Fields:
+ * * `by` - The address that disabled the pool.
+ */
+export interface PoolDisabledEvent {
+    by: string;
+}
+/**
+ * Event indicating that the pool has been closed.
+ * # Fields:
+ * * `by` - The address that closed the pool.
+ */
+export interface PoolClosedEvent {
+    by: string;
+}
+export interface PoolOwnerChangedEvent {
+    pool_owner: string;
+}
+export interface PoolOwnerTreasuryChangedEvent {
+    treasury: string;
+}
+export interface EvaluationAgentChangedEvent {
+    ea: string;
+}
+export interface TranchesPolicyTypeChangedEvent {
+    policy_type: TranchesPolicyType;
+}
+export interface PoolSettingsChangedEvent {
+    default_grace_period_days: u32;
+    late_payment_grace_period_days: u32;
+    max_credit_line: u128;
+    min_deposit_amount: u128;
+    pay_period_duration: PayPeriodDuration;
+    principal_only_payment_allowed: boolean;
+}
+export interface LPConfigChangedEvent {
+    fixed_senior_yield_bps: u32;
+    liquidity_cap: u128;
+    max_senior_junior_ratio: u32;
+    tranches_risk_adjustment_bps: u32;
+    withdrawal_lockout_period_days: u32;
+}
+export interface FeeStructureChangedEvent {
+    front_loading_fee_bps: u32;
+    front_loading_fee_flat: u128;
+    late_fee_bps: u32;
+    yield_bps: u32;
+}
+export interface AdminRnRChangedEvent {
+    ea_liquidity_rate: u32;
+    ea_reward_rate: u32;
+    pool_owner_liquidity_rate: u32;
+    pool_owner_reward_rate: u32;
+}
+export interface PoolNameChangedEvent {
+    name: string;
+}
+export interface ProtocolRewardsWithdrawnEvent {
+    amount: u128;
+    receiver: string;
+}
+export interface PoolRewardsWithdrawnEvent {
+    amount: u128;
+    receiver: string;
+}
+export interface EvaluationAgentRewardsWithdrawnEvent {
+    amount: u128;
+    receiver: string;
+}
+export type PayPeriodDuration = {
+    tag: "Monthly";
+    values: void;
+} | {
+    tag: "Quarterly";
+    values: void;
+} | {
+    tag: "SemiAnnually";
+    values: void;
+};
+export type TranchesPolicyType = {
+    tag: "FixedSeniorYield";
+    values: void;
+} | {
+    tag: "RiskAdjusted";
+    values: void;
+};
+export interface PoolSettings {
+    default_grace_period_days: u32;
+    late_payment_grace_period_days: u32;
+    max_credit_line: u128;
+    min_deposit_amount: u128;
+    pay_period_duration: PayPeriodDuration;
+    principal_only_payment_allowed: boolean;
+}
+export interface LPConfig {
+    fixed_senior_yield_bps: u32;
+    liquidity_cap: u128;
+    max_senior_junior_ratio: u32;
+    tranches_risk_adjustment_bps: u32;
+    withdrawal_lockout_period_days: u32;
+}
+export interface FeeStructure {
+    front_loading_fee_bps: u32;
+    front_loading_fee_flat: u128;
+    late_fee_bps: u32;
+    yield_bps: u32;
+}
+export type PoolStatus = {
+    tag: "Off";
+    values: void;
+} | {
+    tag: "On";
+    values: void;
+} | {
+    tag: "Closed";
+    values: void;
+};
+export interface Epoch {
+    end_time: u64;
+    id: u64;
+}
+export interface AdminRnR {
+    liquidity_rate_bps_ea: u32;
+    liquidity_rate_bps_pool_owner: u32;
+    reward_rate_bps_ea: u32;
+    reward_rate_bps_pool_owner: u32;
+}
+export interface TrancheAddresses {
+    addrs: Array<Option<string>>;
+}
+export interface TrancheAssets {
+    assets: Array<u128>;
+}
+export interface EpochRedemptionSummary {
+    epoch_id: u64;
+    total_amount_processed: u128;
+    total_shares_processed: u128;
+    total_shares_requested: u128;
+}
+export interface Client {
+    /**
+     * Construct and simulate a initialize transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    initialize: ({ pool_name, huma_config, pool_storage, pool, }: {
+        pool_name: string;
+        huma_config: string;
+        pool_storage: string;
+        pool: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_huma_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_huma_config: ({ huma_config }: {
+        huma_config: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_contract_addrs transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_contract_addrs: ({ pool_storage, pool }: {
+        pool_storage: string;
+        pool: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_storage_contract_addrs transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_storage_contract_addrs: ({ pool, pool_manager, credit, }: {
+        pool: string;
+        pool_manager: string;
+        credit: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_pool_name transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_pool_name: ({ caller, name }: {
+        caller: string;
+        name: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_pool_owner transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_pool_owner: ({ caller, addr }: {
+        caller: string;
+        addr: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_pool_owner_treasury transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_pool_owner_treasury: ({ caller, addr }: {
+        caller: string;
+        addr: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_evaluation_agent transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_evaluation_agent: ({ caller, addr }: {
+        caller: string;
+        addr: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_tranche_addresses transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_tranche_addresses: ({ caller, junior_addr, senior_addr, }: {
+        caller: string;
+        junior_addr: string;
+        senior_addr: Option<string>;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_admin_rnr transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_admin_rnr: ({ caller, pool_owner_reward_rate, pool_owner_liquidity_rate, ea_reward_rate, ea_liquidity_rate, }: {
+        caller: string;
+        pool_owner_reward_rate: u32;
+        pool_owner_liquidity_rate: u32;
+        ea_reward_rate: u32;
+        ea_liquidity_rate: u32;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_pool_settings transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_pool_settings: ({ caller, max_credit_line, min_deposit_amount, pay_period_duration, late_payment_grace_period_days, default_grace_period_days, principal_only_payment_allowed, }: {
+        caller: string;
+        max_credit_line: u128;
+        min_deposit_amount: u128;
+        pay_period_duration: PayPeriodDuration;
+        late_payment_grace_period_days: u32;
+        default_grace_period_days: u32;
+        principal_only_payment_allowed: boolean;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_lp_config transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_lp_config: ({ caller, liquidity_cap, max_senior_junior_ratio, fixed_senior_yield_bps, tranches_risk_adjustment_bps, withdrawal_lockout_period_days, }: {
+        caller: string;
+        liquidity_cap: u128;
+        max_senior_junior_ratio: u32;
+        fixed_senior_yield_bps: u32;
+        tranches_risk_adjustment_bps: u32;
+        withdrawal_lockout_period_days: u32;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_fee_structure transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_fee_structure: ({ caller, yield_bps, late_fee_bps, front_loading_fee_flat, front_loading_fee_bps, }: {
+        caller: string;
+        yield_bps: u32;
+        late_fee_bps: u32;
+        front_loading_fee_flat: u128;
+        front_loading_fee_bps: u32;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a set_tranches_policy_type transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    set_tranches_policy_type: ({ caller, policy_type, }: {
+        caller: string;
+        policy_type: TranchesPolicyType;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a add_pool_operator transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    add_pool_operator: ({ addr }: {
+        addr: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a remove_pool_operator transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    remove_pool_operator: ({ addr }: {
+        addr: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a enable_pool transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    enable_pool: ({ caller }: {
+        caller: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a disable_pool transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    disable_pool: ({ caller }: {
+        caller: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a close_pool transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    close_pool: ({ caller }: {
+        caller: string;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a close_epoch transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    close_epoch: (options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a withdraw_protocol_fees transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    withdraw_protocol_fees: ({ amount }: {
+        amount: u128;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a withdraw_pool_owner_fees transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    withdraw_pool_owner_fees: ({ amount }: {
+        amount: u128;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a withdraw_ea_fees transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    withdraw_ea_fees: ({ caller, amount }: {
+        caller: string;
+        amount: u128;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+    /**
+     * Construct and simulate a upgrade transaction. Returns an `AssembledTransaction` object which will have a `result` field containing the result of the simulation. If this transaction changes contract state, you will need to call `signAndSend()` on the returned object.
+     */
+    upgrade: ({ new_wasm_hash }: {
+        new_wasm_hash: Buffer;
+    }, options?: {
+        /**
+         * The fee to pay for the transaction. Default: BASE_FEE
+         */
+        fee?: number;
+        /**
+         * The maximum amount of time to wait for the transaction to complete. Default: DEFAULT_TIMEOUT
+         */
+        timeoutInSeconds?: number;
+        /**
+         * Whether to automatically simulate the transaction when constructing the AssembledTransaction. Default: true
+         */
+        simulate?: boolean;
+    }) => Promise<AssembledTransaction<null>>;
+}
+export declare class Client extends ContractClient {
+    readonly options: ContractClientOptions;
+    constructor(options: ContractClientOptions);
+    readonly fromJSON: {
+        initialize: (json: string) => AssembledTransaction<null>;
+        set_huma_config: (json: string) => AssembledTransaction<null>;
+        set_contract_addrs: (json: string) => AssembledTransaction<null>;
+        set_storage_contract_addrs: (json: string) => AssembledTransaction<null>;
+        set_pool_name: (json: string) => AssembledTransaction<null>;
+        set_pool_owner: (json: string) => AssembledTransaction<null>;
+        set_pool_owner_treasury: (json: string) => AssembledTransaction<null>;
+        set_evaluation_agent: (json: string) => AssembledTransaction<null>;
+        set_tranche_addresses: (json: string) => AssembledTransaction<null>;
+        set_admin_rnr: (json: string) => AssembledTransaction<null>;
+        set_pool_settings: (json: string) => AssembledTransaction<null>;
+        set_lp_config: (json: string) => AssembledTransaction<null>;
+        set_fee_structure: (json: string) => AssembledTransaction<null>;
+        set_tranches_policy_type: (json: string) => AssembledTransaction<null>;
+        add_pool_operator: (json: string) => AssembledTransaction<null>;
+        remove_pool_operator: (json: string) => AssembledTransaction<null>;
+        enable_pool: (json: string) => AssembledTransaction<null>;
+        disable_pool: (json: string) => AssembledTransaction<null>;
+        close_pool: (json: string) => AssembledTransaction<null>;
+        close_epoch: (json: string) => AssembledTransaction<null>;
+        withdraw_protocol_fees: (json: string) => AssembledTransaction<null>;
+        withdraw_pool_owner_fees: (json: string) => AssembledTransaction<null>;
+        withdraw_ea_fees: (json: string) => AssembledTransaction<null>;
+        upgrade: (json: string) => AssembledTransaction<null>;
+    };
+}