@affluent-org/sdk 0.0.1

package/dist/services/strategy-vault/oracle.d.ts

@@ -0,0 +1,66 @@
+import { Cell } from "@ton/core";
+import { AffluentContext } from "../../context";
+import { AddressInput, AddressLike } from "../../contracts/common/type";
+import { StrategyVaultState } from "../../contracts/vault/strategy-vault";
+import { PoolState } from "../../contracts/core/pool/type";
+import { OracleExposures } from "../composite-oracle/computation";
+import { VaultPositions } from "../composite-oracle/types";
+export { OracleExposures, createOracleExposures } from "../composite-oracle/computation";
+/**
+ * Build oracle params Cell from pre-fetched data
+ * Pure computation - no network calls
+ */
+export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: VaultPositions, extraPools?: string[]): Promise<Cell>;
+/**
+ * Build oracle params with bucket from pre-fetched data
+ * Pure computation - no network calls
+ */
+export declare function buildOracleParamsWithBucketFromData(assets: string[], oracleConfig: any, vaultPositions: VaultPositions, initialBucket?: OracleExposures, extraPools?: string[]): {
+    oracleParamsPromise: Promise<Cell>;
+    bucket: OracleExposures;
+};
+/**
+ * Get oracle params for a strategy vault
+ */
+export declare function getOracleParams(ctx: AffluentContext, vaultAddress: AddressLike, vaultData?: StrategyVaultState, extraAssets?: {
+    assets: string[];
+    vaultAssets: string[];
+}): Promise<Cell>;
+/**
+ * Get oracle params with bucket information (for gas calculation)
+ */
+export declare function getOracleParamsWithBucket(ctx: AffluentContext, vaultAddress: AddressLike, vaultData?: StrategyVaultState, bucket?: OracleExposures, extraAssets?: string[]): Promise<{
+    oracleParams: Cell;
+    bucket: OracleExposures;
+}>;
+/**
+ * Get oracle params for pool (used in factorial pool operations)
+ */
+export declare function getOracleParamsForPool(ctx: AffluentContext, poolAddress: AddressInput, anyAssets?: string[]): Promise<Cell>;
+/**
+ * Oracle helper class for strategy vault operations
+ */
+export declare class OracleHelper {
+    private ctx;
+    private fetcher;
+    constructor(ctx?: AffluentContext);
+    /**
+     * Get oracle params for strategy vault with bucket
+     */
+    getOracleParamsForStrategyVaultV2(vaultData: StrategyVaultState, additionalAssets?: string[]): Promise<{
+        oracleParams: Cell;
+        bucket: OracleExposures;
+    }>;
+    /**
+     * Get oracle params for pool
+     */
+    getOracleParamsForPool(poolData: PoolState, anyAssets?: string[]): Promise<Cell>;
+    /**
+     * Get oracle params for strategy vault by address with bucket
+     */
+    getOracleParamsForStrategyVault(vaultAddressOrData: AddressLike | StrategyVaultState, vaultDataOrBucket?: StrategyVaultState | OracleExposures, bucket?: OracleExposures): Promise<{
+        oracleParams: Cell;
+        bucket: OracleExposures;
+    }>;
+    private getOracleParamsForStrategyVaultWithAddress;
+}

package/dist/services/strategy-vault/oracle.js

@@ -0,0 +1,162 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OracleHelper = exports.createOracleExposures = void 0;
+exports.buildOracleParamsCellFromData = buildOracleParamsCellFromData;
+exports.buildOracleParamsWithBucketFromData = buildOracleParamsWithBucketFromData;
+exports.getOracleParams = getOracleParams;
+exports.getOracleParamsWithBucket = getOracleParamsWithBucket;
+exports.getOracleParamsForPool = getOracleParamsForPool;
+const core_1 = require("@ton/core");
+const context_1 = require("../../context");
+const utils_1 = require("../../contracts/common/utils");
+const strategy_vault_1 = require("../../contracts/vault/strategy-vault");
+const pool_1 = require("../../contracts/core/pool");
+const query_1 = require("../composite-oracle/query");
+const computation_1 = require("../composite-oracle/computation");
+const computation_2 = require("../composite-oracle/computation");
+// Re-export for backward compatibility
+var computation_3 = require("../composite-oracle/computation");
+Object.defineProperty(exports, "createOracleExposures", { enumerable: true, get: function () { return computation_3.createOracleExposures; } });
+// ============================================================
+// Pure Computation (no I/O)
+// ============================================================
+/**
+ * Build oracle params Cell from pre-fetched data
+ * Pure computation - no network calls
+ */
+function buildOracleParamsCellFromData(assets, oracleConfig, vaultPositions, extraPools) {
+    const { assets: pureAssets, vaultAssets } = (0, computation_1.separateAssets)(assets, oracleConfig);
+    const exposures = (0, computation_1.getExposures)(vaultPositions);
+    const allAssets = [...new Set([...pureAssets, ...exposures.assets])];
+    const allPools = [...new Set([...exposures.pools, ...(extraPools ?? [])])];
+    return (0, computation_2.buildOracleParamsCell)(allAssets, oracleConfig, allPools, vaultAssets);
+}
+/**
+ * Build oracle params with bucket from pre-fetched data
+ * Pure computation - no network calls
+ */
+function buildOracleParamsWithBucketFromData(assets, oracleConfig, vaultPositions, initialBucket, extraPools) {
+    const bucket = initialBucket ?? (0, computation_2.createOracleExposures)();
+    const { assets: pureAssets, vaultAssets } = (0, computation_1.separateAssets)(assets, oracleConfig);
+    const exposures = (0, computation_1.getExposures)(vaultPositions);
+    // Populate bucket
+    [...new Set([...pureAssets, ...exposures.assets])].forEach((a) => bucket.assets.add(a));
+    exposures.pools.forEach((p) => bucket.pools.add(p));
+    (extraPools ?? []).forEach((p) => bucket.pools.add(p));
+    vaultAssets.forEach((v) => bucket.vaults.add(v));
+    const oracleParamsPromise = (0, computation_2.buildOracleParamsCell)([...bucket.assets], oracleConfig, [...bucket.pools], [...bucket.vaults]);
+    return { oracleParamsPromise, bucket };
+}
+// ============================================================
+// Orchestration (fetch + compute)
+// ============================================================
+/**
+ * Get oracle params for a strategy vault
+ */
+async function getOracleParams(ctx, vaultAddress, vaultData, extraAssets) {
+    const fetcher = new query_1.CompositeOracleFetcher(ctx);
+    const oracleCtx = await fetcher.getOracleContext(vaultAddress, vaultData, extraAssets);
+    return (0, computation_2.buildOracleParamsCell)(oracleCtx.allRequiredAssets, oracleCtx.oracleConfig, oracleCtx.exposures.pools, oracleCtx.vaultAssets);
+}
+/**
+ * Get oracle params with bucket information (for gas calculation)
+ */
+async function getOracleParamsWithBucket(ctx, vaultAddress, vaultData, bucket, extraAssets) {
+    const fetcher = new query_1.CompositeOracleFetcher(ctx);
+    const vault = ctx.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(vaultAddress));
+    vaultData = vaultData ?? (await vault.getVaultData());
+    const oracleConfig = vaultData.oracleConfig;
+    let { assets, vaultAssets } = (0, computation_1.separateAssets)(Object.keys(vaultData.assets), oracleConfig);
+    if (extraAssets) {
+        const separated = (0, computation_1.separateAssets)(extraAssets, oracleConfig);
+        assets = [...new Set([...assets, ...separated.assets])];
+        vaultAssets = [...new Set([...vaultAssets, ...separated.vaultAssets])];
+    }
+    // Fetch
+    const vaultPositions = await fetcher.fetchVaultPositions([...vaultAssets, vault.address]);
+    // Compute
+    const allAssets = [...new Set([...Object.keys(vaultData.assets), ...(extraAssets ?? [])])];
+    const result = buildOracleParamsWithBucketFromData(allAssets, oracleConfig, vaultPositions, bucket);
+    return { oracleParams: await result.oracleParamsPromise, bucket: result.bucket };
+}
+/**
+ * Get oracle params for pool (used in factorial pool operations)
+ */
+async function getOracleParamsForPool(ctx, poolAddress, anyAssets = []) {
+    const fetcher = new query_1.CompositeOracleFetcher(ctx);
+    const pool = ctx.getByContract(pool_1.Pool, (0, utils_1.toAddress)(poolAddress));
+    const poolData = await pool.getPoolData();
+    const oracleConfig = poolData.oracleConfig;
+    const allAssets = [...new Set([...Object.keys(poolData.assets), ...anyAssets])];
+    const { vaultAssets } = (0, computation_1.separateAssets)(allAssets, oracleConfig);
+    // Fetch
+    const vaultPositions = await fetcher.fetchVaultPositions(vaultAssets.map((v) => core_1.Address.parse(v)));
+    // Compute
+    return buildOracleParamsCellFromData(allAssets, oracleConfig, vaultPositions);
+}
+// ============================================================
+// OracleHelper Class
+// ============================================================
+/**
+ * Oracle helper class for strategy vault operations
+ */
+class OracleHelper {
+    ctx;
+    fetcher;
+    constructor(ctx = context_1.AffluentContext.getInstance()) {
+        this.ctx = ctx;
+        this.fetcher = new query_1.CompositeOracleFetcher(ctx);
+    }
+    /**
+     * Get oracle params for strategy vault with bucket
+     */
+    async getOracleParamsForStrategyVaultV2(vaultData, additionalAssets = []) {
+        const oracleConfig = vaultData.oracleConfig;
+        const allAssets = [...Object.keys(vaultData.assets), ...additionalAssets];
+        const { vaultAssets } = (0, computation_1.separateAssets)(allAssets, oracleConfig);
+        // Fetch
+        const vaultPositions = await this.fetcher.fetchVaultPositions(vaultAssets);
+        // Compute
+        const result = buildOracleParamsWithBucketFromData(allAssets, oracleConfig, vaultPositions);
+        return { oracleParams: await result.oracleParamsPromise, bucket: result.bucket };
+    }
+    /**
+     * Get oracle params for pool
+     */
+    async getOracleParamsForPool(poolData, anyAssets = []) {
+        const oracleConfig = poolData.oracleConfig;
+        const allAssets = [...new Set([...Object.keys(poolData.assets), ...anyAssets])];
+        const { vaultAssets } = (0, computation_1.separateAssets)(allAssets, oracleConfig);
+        // Fetch
+        const vaultPositions = await this.fetcher.fetchVaultPositions(vaultAssets.map((v) => core_1.Address.parse(v)));
+        // Compute
+        return buildOracleParamsCellFromData(allAssets, oracleConfig, vaultPositions);
+    }
+    /**
+     * Get oracle params for strategy vault by address with bucket
+     */
+    async getOracleParamsForStrategyVault(vaultAddressOrData, vaultDataOrBucket, bucket) {
+        if (typeof vaultAddressOrData === "object" && "oracleConfig" in vaultAddressOrData) {
+            const vaultData = vaultAddressOrData;
+            const additionalAssets = Array.isArray(vaultDataOrBucket) ? vaultDataOrBucket : [];
+            return this.getOracleParamsForStrategyVaultV2(vaultData, additionalAssets);
+        }
+        const vaultAddress = vaultAddressOrData;
+        const vaultData = vaultDataOrBucket;
+        return this.getOracleParamsForStrategyVaultWithAddress(vaultAddress, vaultData, bucket);
+    }
+    async getOracleParamsForStrategyVaultWithAddress(vaultAddress, vaultData, bucket) {
+        const vault = this.ctx.getByContract(strategy_vault_1.StrategyVault, (0, utils_1.toAddress)(vaultAddress));
+        vaultData = vaultData ?? (await vault.getVaultData());
+        const oracleConfig = vaultData.oracleConfig;
+        const allAssets = Object.keys(vaultData.assets);
+        const { vaultAssets } = (0, computation_1.separateAssets)(allAssets, oracleConfig);
+        const extraPools = Object.keys(vaultData.factorialPools);
+        // Fetch
+        const vaultPositions = await this.fetcher.fetchVaultPositions(vaultAssets);
+        // Compute
+        const result = buildOracleParamsWithBucketFromData(allAssets, oracleConfig, vaultPositions, bucket, extraPools);
+        return { oracleParams: await result.oracleParamsPromise, bucket: result.bucket };
+    }
+}
+exports.OracleHelper = OracleHelper;

package/dist/services/strategy-vault/owner/index.d.ts

@@ -0,0 +1,277 @@
+import { Dictionary } from "@ton/core";
+import { AffluentContext } from "../../../context";
+import { StrategyVault } from "../../../contracts/vault/strategy-vault";
+import { SetOwnerParams, SetGuardianAddressParams, SetManagerParams, SetPrivateVaultParams, SetWhitelistedMintersParams, SetMaxLeverageRatioParams, ExecuteOwnerActionParams, RevertOwnerActionParams, SetTimelockParams, SetManagementFeeRecipientAddressParams, SetProtocolFeeRatePerYearParams, SetProtocolFeeManagerAddressParams, SetFactorialPoolConfigParams, SetAssetConfigParams, SetRFQConfigParams, SetManagementFeeRatePerYearParams, SetDepositCloseTimestampParams, SetWithdrawOpenTimestampParams, SetGasConfigParams, SetOracleConfigParams, SetWalletCodeParams, SetDataAggregatorCodeParams, SetRFQCodeParams, SetContentParams, UpgradeCodeParams, CollectProtocolFeeParams, ClaimManagementFeeParams } from "./types";
+export * from "./types";
+export declare function createSetOwnerMsg(ctx: AffluentContext, params: SetOwnerParams): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetGuardianAddressMsg(ctx: AffluentContext, params: SetGuardianAddressParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetManagerMsg(ctx: AffluentContext, params: SetManagerParams): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetPrivateVaultMsg(ctx: AffluentContext, params: SetPrivateVaultParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetWhitelistedMintersMsg(ctx: AffluentContext, params: SetWhitelistedMintersParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+        mintersDict: Dictionary<import("@ton/core").Address, any>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetMaxLeverageRatioMsg(ctx: AffluentContext, params: SetMaxLeverageRatioParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createExecuteOwnerActionMsg(ctx: AffluentContext, params: ExecuteOwnerActionParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createRevertOwnerActionMsg(ctx: AffluentContext, params: RevertOwnerActionParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetTimelockMsg(ctx: AffluentContext, params: SetTimelockParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetManagementFeeRecipientAddressMsg(ctx: AffluentContext, params: SetManagementFeeRecipientAddressParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetProtocolFeeRatePerYearMsg(ctx: AffluentContext, params: SetProtocolFeeRatePerYearParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetProtocolFeeManagerAddressMsg(ctx: AffluentContext, params: SetProtocolFeeManagerAddressParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetFactorialPoolConfigMsg(ctx: AffluentContext, params: SetFactorialPoolConfigParams): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+        factorialPoolConfig: import("@ton/core").Cell;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetAssetConfigMsg(ctx: AffluentContext, params: SetAssetConfigParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetRFQConfigMsg(ctx: AffluentContext, params: SetRFQConfigParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetManagementFeeRatePerYearMsg(ctx: AffluentContext, params: SetManagementFeeRatePerYearParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetDepositCloseTimestampMsg(ctx: AffluentContext, params: SetDepositCloseTimestampParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetWithdrawOpenTimestampMsg(ctx: AffluentContext, params: SetWithdrawOpenTimestampParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetGasConfigMsg(ctx: AffluentContext, params: SetGasConfigParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetOracleConfigMsg(ctx: AffluentContext, params: SetOracleConfigParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetWalletCodeMsg(ctx: AffluentContext, params: SetWalletCodeParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetDataAggregatorCodeMsg(ctx: AffluentContext, params: SetDataAggregatorCodeParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetRFQCodeMsg(ctx: AffluentContext, params: SetRFQCodeParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetContentMsg(ctx: AffluentContext, params: SetContentParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createUpgradeCodeMsg(ctx: AffluentContext, params: UpgradeCodeParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createCollectProtocolFeeMsg(ctx: AffluentContext, params: CollectProtocolFeeParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createClaimManagementFeeMsg(ctx: AffluentContext, params: ClaimManagementFeeParams, value?: bigint): Promise<{
+    opts: {
+        vault: import("@ton/core").OpenedContract<StrategyVault>;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;