@affluent-org/sdk 0.0.1

package/dist/services/pool/index.d.ts

@@ -0,0 +1,94 @@
+import { Address } from "@ton/core";
+import { AffluentContext } from "../../context";
+import { AddressInput, AddressLike } from "../../contracts/common/type";
+import { AddressSender } from "../../types/sender";
+import { PoolState } from "../../contracts/core/pool/type";
+import { AccountState } from "../../contracts/core/account/type";
+import * as computation from "./computation";
+import * as query from "./query";
+import * as oracle from "./oracle";
+import * as owner from "./owner";
+import * as user from "./user";
+export { sendMsg } from "../../lib/send-msg";
+export * from "./owner/types";
+export * from "./user/types";
+export * from "./computation";
+export { computation, query, oracle, owner, user };
+export declare class PoolServiceV1 {
+    private ctx;
+    constructor(ctx?: AffluentContext);
+    getPool(poolAddress: AddressInput): import("@ton/core").OpenedContract<import("../..").Pool>;
+    getPoolData(poolAddress: AddressInput): Promise<PoolState>;
+    getAccountAddress(poolAddress: AddressInput, userAddress: AddressLike): Promise<Address>;
+    getAccount(poolAddress: AddressInput, userAddress: AddressLike): Promise<import("@ton/core").OpenedContract<import("../..").Account>>;
+    getAccountData(poolAddress: AddressInput, userAddress: AddressLike): Promise<AccountState>;
+    getPricesAndCompositions(poolAddress: AddressInput): Promise<{
+        prices: import("../composite-oracle").Prices;
+        vaultCompositions: import("../composite-oracle").VaultCompositions;
+    }>;
+    isHealthy(poolAddress: AddressInput, ownerAddress: AddressLike): Promise<computation.HealthResult>;
+    getOracleParams(poolAddress: AddressInput, actorAddress: AddressLike, executeAssetAddress: AddressLike): Promise<import("@ton/core").Cell | null>;
+    static simulateAccrueInterest(poolData: PoolState, time?: number): PoolState;
+    static convertShareToAmount(accountData: AccountState, poolData: PoolState): AccountState;
+    static haveBorrow(accountData: AccountState): boolean;
+    static haveAssets(accountData: AccountState): string[];
+    sendSetOwner(sender: AddressSender, params: owner.SetOwnerParams, value?: bigint): Promise<{
+        newOwner: Address;
+        queryID: number | undefined;
+    }>;
+    sendSetIrmConfig(sender: AddressSender, params: owner.SetIrmConfigParams, value?: bigint): Promise<{
+        asset: Address;
+        irmConfig: import("@ton/core").Cell;
+        queryId: number | undefined;
+    }>;
+    sendSetFeeConfigurer(sender: AddressSender, params: owner.SetFeeConfigurerParams, value?: bigint): Promise<{
+        feeConfigurer: Address;
+        queryId: number | undefined;
+    }>;
+    sendSupply(sender: AddressSender, params: user.SupplyParams, value?: bigint): Promise<{
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: import("@ton/core").Cell;
+        queryId: bigint | undefined;
+    }>;
+    sendWithdraw(sender: AddressSender, params: user.WithdrawParams, value?: bigint): Promise<{
+        asset: Address;
+        isShare: boolean;
+        amount: bigint;
+        recipient: Address;
+        response: Address;
+        jettonForwardTonAmount: bigint;
+        jettonForwardPayload: import("@ton/core").Cell | null;
+        oracleParams: import("@ton/core").Cell | null;
+        queryId: bigint | undefined;
+    }>;
+    sendBorrow(sender: AddressSender, params: user.BorrowParams, value?: bigint): Promise<{
+        asset: Address;
+        isShare: boolean;
+        amount: bigint;
+        recipient: Address;
+        response: Address;
+        jettonForwardTonAmount: bigint;
+        jettonForwardPayload: import("@ton/core").Cell | null;
+        oracleParams: import("@ton/core").Cell | null;
+        queryId: bigint | undefined;
+    }>;
+    sendRepay(sender: AddressSender, params: user.RepayParams, value?: bigint): Promise<{
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: import("@ton/core").Cell;
+        queryId: bigint | undefined;
+    }>;
+    sendLiquidate(sender: AddressSender, params: user.LiquidateParams, value?: bigint): Promise<{
+        recipient: Address;
+        amount: bigint;
+        response: Address;
+        forwardTonAmount: bigint;
+        forwardPayload: import("@ton/core").Cell;
+        queryId: bigint | undefined;
+    }>;
+}

package/dist/services/pool/index.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PoolServiceV1 = exports.user = exports.owner = exports.oracle = exports.query = exports.computation = exports.sendMsg = void 0;
+const context_1 = require("../../context");
+const send_msg_1 = require("../../lib/send-msg");
+const computation = __importStar(require("./computation"));
+exports.computation = computation;
+const query = __importStar(require("./query"));
+exports.query = query;
+const oracle = __importStar(require("./oracle"));
+exports.oracle = oracle;
+const owner = __importStar(require("./owner"));
+exports.owner = owner;
+const user = __importStar(require("./user"));
+exports.user = user;
+// Re-exports
+var send_msg_2 = require("../../lib/send-msg");
+Object.defineProperty(exports, "sendMsg", { enumerable: true, get: function () { return send_msg_2.sendMsg; } });
+__exportStar(require("./owner/types"), exports);
+__exportStar(require("./user/types"), exports);
+__exportStar(require("./computation"), exports); // Types and pure computation functions
+class PoolServiceV1 {
+    ctx;
+    constructor(ctx = context_1.AffluentContext.getInstance()) {
+        this.ctx = ctx;
+    }
+    // ============================================================
+    // Query (Data Fetching)
+    // ============================================================
+    getPool(poolAddress) {
+        return query.getPool(this.ctx, poolAddress);
+    }
+    async getPoolData(poolAddress) {
+        return query.getPoolData(this.ctx, poolAddress);
+    }
+    async getAccountAddress(poolAddress, userAddress) {
+        return query.getAccountAddress(this.ctx, poolAddress, userAddress);
+    }
+    async getAccount(poolAddress, userAddress) {
+        return query.getAccount(this.ctx, poolAddress, userAddress);
+    }
+    async getAccountData(poolAddress, userAddress) {
+        return query.getAccountData(this.ctx, poolAddress, userAddress);
+    }
+    async getPricesAndCompositions(poolAddress) {
+        return query.getPricesAndCompositions(this.ctx, poolAddress);
+    }
+    async isHealthy(poolAddress, ownerAddress) {
+        return query.isHealthy(this.ctx, poolAddress, ownerAddress);
+    }
+    // ============================================================
+    // Oracle
+    // ============================================================
+    async getOracleParams(poolAddress, actorAddress, executeAssetAddress) {
+        return oracle.getOracleParams(this.ctx, poolAddress, actorAddress, executeAssetAddress);
+    }
+    // ============================================================
+    // Static Computation (no context needed)
+    // ============================================================
+    static simulateAccrueInterest(poolData, time) {
+        return computation.simulateAccrueInterest(poolData, time);
+    }
+    static convertShareToAmount(accountData, poolData) {
+        return computation.convertShareToAmount(accountData, poolData);
+    }
+    static haveBorrow(accountData) {
+        return computation.haveBorrow(accountData);
+    }
+    static haveAssets(accountData) {
+        return computation.haveAssets(accountData);
+    }
+    // ============================================================
+    // Owner
+    // ============================================================
+    async sendSetOwner(sender, params, value) {
+        return (0, send_msg_1.sendMsg)(sender, owner.createSetOwnerMsg(this.ctx, params, value));
+    }
+    async sendSetIrmConfig(sender, params, value) {
+        return (0, send_msg_1.sendMsg)(sender, owner.createSetIrmConfigMsg(this.ctx, params, value));
+    }
+    async sendSetFeeConfigurer(sender, params, value) {
+        return (0, send_msg_1.sendMsg)(sender, owner.createSetFeeConfigurerMsg(this.ctx, params, value));
+    }
+    // ============================================================
+    // User
+    // ============================================================
+    async sendSupply(sender, params, value) {
+        return (0, send_msg_1.sendMsg)(sender, user.createSupplyMsg(this.ctx, sender, params, value));
+    }
+    async sendWithdraw(sender, params, value) {
+        return (0, send_msg_1.sendMsg)(sender, user.createWithdrawMsg(this.ctx, sender, params, value));
+    }
+    async sendBorrow(sender, params, value) {
+        return (0, send_msg_1.sendMsg)(sender, user.createBorrowMsg(this.ctx, sender, params, value));
+    }
+    async sendRepay(sender, params, value) {
+        return (0, send_msg_1.sendMsg)(sender, user.createRepayMsg(this.ctx, sender, params, value));
+    }
+    async sendLiquidate(sender, params, value) {
+        return (0, send_msg_1.sendMsg)(sender, user.createLiquidateMsg(this.ctx, sender, params, value));
+    }
+}
+exports.PoolServiceV1 = PoolServiceV1;

package/dist/services/pool/oracle.d.ts

@@ -0,0 +1,20 @@
+import { Cell } from "@ton/core";
+import { AffluentContext } from "../../context";
+import { AddressInput, AddressLike } from "../../contracts/common/type";
+import { PoolState } from "../../contracts/core/pool/type";
+import { VaultPositions } from "../composite-oracle/types";
+/**
+ * Build oracle params Cell from pre-fetched vault positions
+ * Pure computation - no network calls
+ */
+export declare function buildOracleParamsCellFromData(assets: string[], oracleConfig: any, vaultPositions: VaultPositions): Promise<Cell>;
+/**
+ * Get oracle params for a pool operation
+ * Fetches account data and builds oracle params
+ */
+export declare function getOracleParams(ctx: AffluentContext, poolAddress: AddressInput, actorAddress: AddressLike, executeAssetAddress: AddressLike): Promise<Cell | null>;
+/**
+ * Build oracle params Cell for pool operations
+ * Fetches vault positions and builds params
+ */
+export declare function buildOracleParams(ctx: AffluentContext, assets: string[], poolData: PoolState): Promise<Cell>;

package/dist/services/pool/oracle.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildOracleParamsCellFromData = buildOracleParamsCellFromData;
+exports.getOracleParams = getOracleParams;
+exports.buildOracleParams = buildOracleParams;
+const core_1 = require("@ton/core");
+const utils_1 = require("../../contracts/common/utils");
+const pool_1 = require("../../contracts/core/pool");
+const account_1 = require("../../contracts/core/account");
+const query_1 = require("../composite-oracle/query");
+const computation_1 = require("../composite-oracle/computation");
+const computation_2 = require("../composite-oracle/computation");
+const query_2 = require("./query");
+// ============================================================
+// Pure Computation (no I/O)
+// ============================================================
+/**
+ * Build oracle params Cell from pre-fetched vault positions
+ * Pure computation - no network calls
+ */
+function buildOracleParamsCellFromData(assets, oracleConfig, vaultPositions) {
+    const { assets: pureAssets, vaultAssets } = (0, computation_1.separateAssets)(assets, oracleConfig);
+    const exposures = (0, computation_1.getExposures)(vaultPositions);
+    const allAssets = [...new Set([...pureAssets, ...exposures.assets])];
+    return (0, computation_2.buildOracleParamsCell)(allAssets, oracleConfig, exposures.pools, vaultAssets);
+}
+// ============================================================
+// Orchestration (fetch + compute)
+// ============================================================
+/**
+ * Get oracle params for a pool operation
+ * Fetches account data and builds oracle params
+ */
+async function getOracleParams(ctx, poolAddress, actorAddress, executeAssetAddress) {
+    const pool = ctx.getByContract(pool_1.Pool, (0, utils_1.toAddress)(poolAddress));
+    const poolData = await pool.getPoolData();
+    const accountAddress = await (0, query_2.getAccountAddress)(ctx, poolAddress, actorAddress);
+    const account = ctx.getByContract(account_1.Account, accountAddress);
+    let accountData;
+    try {
+        accountData = await account.getAccountData();
+    }
+    catch {
+        return null;
+    }
+    const userAssets = [...new Set([...account_1.Account.haveAssets(accountData), (0, utils_1.toAddress)(executeAssetAddress).toString()])];
+    return buildOracleParams(ctx, userAssets, poolData);
+}
+/**
+ * Build oracle params Cell for pool operations
+ * Fetches vault positions and builds params
+ */
+async function buildOracleParams(ctx, assets, poolData) {
+    const oracleConfig = poolData.oracleConfig;
+    const { vaultAssets } = (0, computation_1.separateAssets)(assets, oracleConfig);
+    // Fetch
+    const fetcher = new query_1.CompositeOracleFetcher(ctx);
+    const vaultPositions = await fetcher.fetchVaultPositions(vaultAssets.map((v) => core_1.Address.parse(v)));
+    // Compute
+    return buildOracleParamsCellFromData(assets, oracleConfig, vaultPositions);
+}

package/dist/services/pool/owner/index.d.ts

@@ -0,0 +1,37 @@
+import { AffluentContext } from "../../../context";
+import { SetOwnerParams, SetIrmConfigParams, SetFeeConfigurerParams } from "./types";
+export * from "./types";
+export declare function createSetOwnerMsg(ctx: AffluentContext, params: SetOwnerParams, value?: bigint): Promise<{
+    opts: {
+        newOwner: import("@ton/core").Address;
+        queryID: number | undefined;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetIrmConfigMsg(ctx: AffluentContext, params: SetIrmConfigParams, value?: bigint): Promise<{
+    opts: {
+        asset: import("@ton/core").Address;
+        irmConfig: import("@ton/core").Cell;
+        queryId: number | undefined;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;
+export declare function createSetFeeConfigurerMsg(ctx: AffluentContext, params: SetFeeConfigurerParams, value?: bigint): Promise<{
+    opts: {
+        feeConfigurer: import("@ton/core").Address;
+        queryId: number | undefined;
+    };
+    input: {
+        to: import("@ton/core").Address;
+        value: bigint;
+        body: import("@ton/core").Cell;
+    };
+}>;

package/dist/services/pool/owner/index.js

@@ -0,0 +1,76 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSetOwnerMsg = createSetOwnerMsg;
+exports.createSetIrmConfigMsg = createSetIrmConfigMsg;
+exports.createSetFeeConfigurerMsg = createSetFeeConfigurerMsg;
+const core_1 = require("@ton/core");
+const utils_1 = require("../../../contracts/common/utils");
+const pool_1 = require("../../../contracts/core/pool");
+__exportStar(require("./types"), exports);
+const DEFAULT_VALUE = (0, core_1.toNano)(0.1);
+// ============================================================
+// Owner Operations
+// ============================================================
+async function createSetOwnerMsg(ctx, params, value) {
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const pool = ctx.getByContract(pool_1.Pool, poolAddress);
+    const opts = {
+        newOwner: (0, utils_1.toAddress)(params.newOwner),
+        queryID: params.queryId ? Number(params.queryId) : undefined,
+    };
+    return {
+        opts,
+        input: {
+            to: pool.address,
+            value: value ?? DEFAULT_VALUE,
+            body: pool_1.Pool.createSetOwnerMsgBody(opts),
+        },
+    };
+}
+async function createSetIrmConfigMsg(ctx, params, value) {
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const pool = ctx.getByContract(pool_1.Pool, poolAddress);
+    const opts = {
+        asset: (0, utils_1.toAddress)(params.assetAddress),
+        irmConfig: params.irmConfig,
+        queryId: params.queryId ? Number(params.queryId) : undefined,
+    };
+    return {
+        opts,
+        input: {
+            to: pool.address,
+            value: value ?? DEFAULT_VALUE,
+            body: pool_1.Pool.createSetIrmConfigMsgBody(opts),
+        },
+    };
+}
+async function createSetFeeConfigurerMsg(ctx, params, value) {
+    const poolAddress = (0, utils_1.toAddress)(params.poolAddress);
+    const pool = ctx.getByContract(pool_1.Pool, poolAddress);
+    const opts = {
+        feeConfigurer: (0, utils_1.toAddress)(params.feeConfigurer),
+        queryId: params.queryId ? Number(params.queryId) : undefined,
+    };
+    return {
+        opts,
+        input: {
+            to: pool.address,
+            value: value ?? DEFAULT_VALUE,
+            body: pool_1.Pool.createSetFeeConfigurerMsgBody(opts),
+        },
+    };
+}

package/dist/services/pool/owner/types.d.ts

@@ -0,0 +1,18 @@
+import { Cell } from "@ton/core";
+import { AddressInput, AddressLike } from "../../../contracts/common/type";
+export type SetOwnerParams = {
+    poolAddress: AddressInput;
+    newOwner: AddressLike;
+    queryId?: bigint;
+};
+export type SetIrmConfigParams = {
+    poolAddress: AddressInput;
+    assetAddress: AddressLike;
+    irmConfig: Cell;
+    queryId?: bigint;
+};
+export type SetFeeConfigurerParams = {
+    poolAddress: AddressInput;
+    feeConfigurer: AddressLike;
+    queryId?: bigint;
+};

package/dist/services/pool/owner/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/services/pool/query.d.ts

@@ -0,0 +1,64 @@
+import { Address } from "@ton/core";
+import { AffluentContext } from "../../context";
+import { AddressInput, AddressLike } from "../../contracts/common/type";
+import { Pool } from "../../contracts/core/pool";
+import { PoolState } from "../../contracts/core/pool/type";
+import { Account } from "../../contracts/core/account";
+import { AccountState, AccountAssetState } from "../../contracts/core/account/type";
+import { VaultCompositions, Prices } from "../composite-oracle/types";
+import { HealthResult, MaxBorrowableResult, MaxWithdrawableResult } from "./computation";
+/**
+ * Get Pool contract instance
+ */
+export declare function getPool(ctx: AffluentContext, poolAddress: AddressInput): import("@ton/core").OpenedContract<Pool>;
+/**
+ * Get Pool data
+ */
+export declare function getPoolData(ctx: AffluentContext, poolAddress: AddressInput): Promise<PoolState>;
+/**
+ * Get Account address for a user in a pool
+ */
+export declare function getAccountAddress(ctx: AffluentContext, poolAddress: AddressInput, userAddress: AddressLike): Promise<Address>;
+/**
+ * Get Account contract instance
+ */
+export declare function getAccount(ctx: AffluentContext, poolAddress: AddressInput, userAddress: AddressLike): Promise<import("@ton/core").OpenedContract<Account>>;
+/**
+ * Get Account data for a user in a pool
+ */
+export declare function getAccountData(ctx: AffluentContext, poolAddress: AddressInput, userAddress: AddressLike): Promise<AccountState>;
+/**
+ * Get prices and vault compositions for all assets in a pool
+ */
+export declare function getPricesAndCompositions(ctx: AffluentContext, poolAddress: AddressInput): Promise<{
+    prices: Prices;
+    vaultCompositions: VaultCompositions;
+}>;
+/**
+ * Get prices for all assets in a pool
+ * @deprecated Use getPricesAndCompositions instead
+ */
+export declare function getPrices(ctx: AffluentContext, poolAddress: AddressInput): Promise<Prices>;
+/**
+ * Check if account is healthy
+ * Fetches pool data, account data, and prices, then calculates health
+ */
+export declare function isHealthy(ctx: AffluentContext, poolAddress: AddressInput, ownerAddress: AddressLike, delta?: Record<string, AccountAssetState>): Promise<HealthResult>;
+/**
+ * Calculate maximum borrowable amount for an asset
+ */
+export declare function calculateMaxBorrowableAmount(ctx: AffluentContext, params: {
+    borrowerAddress: Address;
+    poolAddress: Address;
+    tokenAddress: string;
+    BUFFER?: bigint;
+}): Promise<MaxBorrowableResult>;
+/**
+ * Calculate maximum withdrawable amount for an asset
+ */
+export declare function calculateMaxWithdrawableAmount(ctx: AffluentContext, params: {
+    withdrawerAddress: Address;
+    poolAddress: Address;
+    tokenAddress: string;
+    BUFFER?: bigint;
+}): Promise<MaxWithdrawableResult>;