@affluent-org/sdk 0.0.1

package/dist/constants/contracts.d.ts

@@ -0,0 +1,9 @@
+export type ContractInfo = {
+    name: string;
+    type: "wton" | "token" | "pool" | "factory";
+};
+export declare const MAINNET_WTON = "EQDIKEz2BYLnTRWo5W5a6moZ9PXNtyOVOFF7noi8Ufv3axz_";
+export declare const TESTNET_WTON = "EQBrWuWrQGw_xlm5XpImjWWSVsH56WFXfGm-j-VoP2njlC4s";
+export declare const MAINNET_CONTRACTS: Record<string, ContractInfo>;
+export declare const TESTNET_CONTRACTS: Record<string, ContractInfo>;
+export declare function findAddressByType(contracts: Record<string, ContractInfo>, type: ContractInfo["type"]): string | undefined;

package/dist/constants/contracts.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TESTNET_CONTRACTS = exports.MAINNET_CONTRACTS = exports.TESTNET_WTON = exports.MAINNET_WTON = void 0;
+exports.findAddressByType = findAddressByType;
+// WTON addresses
+exports.MAINNET_WTON = "EQDIKEz2BYLnTRWo5W5a6moZ9PXNtyOVOFF7noi8Ufv3axz_";
+exports.TESTNET_WTON = "EQBrWuWrQGw_xlm5XpImjWWSVsH56WFXfGm-j-VoP2njlC4s";
+// Contract registry (address → info)
+exports.MAINNET_CONTRACTS = {
+    [exports.MAINNET_WTON]: { name: "WTON", type: "wton" },
+};
+exports.TESTNET_CONTRACTS = {
+    [exports.TESTNET_WTON]: { name: "WTON", type: "wton" },
+};
+// Helper to find address by type
+function findAddressByType(contracts, type) {
+    return Object.entries(contracts).find(([_, info]) => info.type === type)?.[0];
+}

package/dist/context.d.ts

@@ -0,0 +1,43 @@
+import { Contract, OpenedContract, TonClient } from "@ton/ton";
+import { Address } from "@ton/core";
+import { AddressInput, AddressLike } from "./contracts/common/type";
+import { ShareVault } from "./contracts/vault/share-vault";
+import { StrategyVault } from "./contracts/vault/strategy-vault";
+export type UnderlyingAssetType = {
+    type: "underlying-asset";
+};
+export type ShareVaultType = {
+    type: "share-vault";
+    data: Awaited<ReturnType<typeof ShareVault.parseVaultData>>;
+};
+export type StrategyVaultType = {
+    type: "strategy-vault";
+    data: Awaited<ReturnType<typeof StrategyVault.parseVaultData>>;
+};
+export type AssetType = UnderlyingAssetType | ShareVaultType | StrategyVaultType;
+export type AffluentContextConfig = {
+    client: TonClient;
+    network: "testnet" | "mainnet" | "custom";
+    customWtonAddress?: string;
+    cacheTtl?: number;
+};
+export declare class AffluentContext {
+    private static instance;
+    readonly client: TonClient;
+    readonly network: "testnet" | "mainnet" | "custom";
+    readonly wtonAddress: Address;
+    private readonly cacheTtl;
+    private readonly openedContracts;
+    constructor(config: AffluentContextConfig);
+    static initialize(config: AffluentContextConfig): AffluentContext;
+    static getInstance(): AffluentContext;
+    static isInitialized(): boolean;
+    static reset(): void;
+    isWTON(address: AddressLike): boolean;
+    getByContract<T extends Contract>(contractType: {
+        createFromAddress(address: Address): T;
+        name?: string;
+    }, address: AddressInput): OpenedContract<T>;
+    private open;
+    getAssetType(assetAddress: AddressInput): Promise<AssetType>;
+}

package/dist/context.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AffluentContext = void 0;
+const contracts_1 = require("./constants/contracts");
+const query_cache_1 = require("./lib/query-cache");
+const core_1 = require("@ton/core");
+const utils_1 = require("./contracts/common/utils");
+const share_vault_1 = require("./contracts/vault/share-vault");
+const strategy_vault_1 = require("./contracts/vault/strategy-vault");
+class AffluentContext {
+    static instance = null;
+    client;
+    network;
+    wtonAddress;
+    cacheTtl;
+    openedContracts = new Map();
+    constructor(config) {
+        const { client, network, customWtonAddress, cacheTtl = 2500 } = config;
+        if (network === "custom" && !customWtonAddress) {
+            throw new Error("custom network requires customWtonAddress");
+        }
+        const wtonAddr = customWtonAddress ?? (network === "mainnet" ? contracts_1.MAINNET_WTON : contracts_1.TESTNET_WTON);
+        this.client = client;
+        this.network = network;
+        this.wtonAddress = core_1.Address.parse(wtonAddr);
+        this.cacheTtl = cacheTtl;
+    }
+    static initialize(config) {
+        if (AffluentContext.instance) {
+            throw new Error("AffluentContext already initialized. Call reset() first to reinitialize.");
+        }
+        AffluentContext.instance = new AffluentContext(config);
+        return AffluentContext.instance;
+    }
+    static getInstance() {
+        if (!AffluentContext.instance) {
+            throw new Error("AffluentContext not initialized. Call initialize() first.");
+        }
+        return AffluentContext.instance;
+    }
+    static isInitialized() {
+        return AffluentContext.instance !== null;
+    }
+    static reset() {
+        if (!AffluentContext.instance) {
+            throw new Error("AffluentContext not initialized. Call initialize() first.");
+        }
+        AffluentContext.instance = null;
+    }
+    isWTON(address) {
+        return (0, utils_1.toAddress)(address).equals(this.wtonAddress);
+    }
+    getByContract(contractType, address) {
+        const contract = contractType.createFromAddress((0, utils_1.toAddress)(address));
+        return this.open(contract);
+    }
+    open(contract) {
+        const key = `${contract.constructor.name}_${contract.address.toString()}`;
+        const cached = this.openedContracts.get(key);
+        if (cached) {
+            return cached;
+        }
+        const openedContract = (0, query_cache_1.withQueryCache)(this.client.open(contract), this.cacheTtl);
+        this.openedContracts.set(key, openedContract);
+        return openedContract;
+    }
+    async getAssetType(assetAddress) {
+        const address = (0, utils_1.toAddress)(assetAddress);
+        const state = await this.client.getContractState(address);
+        if (!state.data)
+            throw Error("no data");
+        const dataCell = core_1.Cell.fromBoc(state.data)[0];
+        try {
+            return {
+                type: "share-vault",
+                data: share_vault_1.ShareVault.parseVaultData(dataCell),
+            };
+        }
+        catch (_) { }
+        try {
+            return {
+                type: "strategy-vault",
+                data: strategy_vault_1.StrategyVault.parseVaultData(dataCell),
+            };
+        }
+        catch (_) { }
+        return { type: "underlying-asset" };
+    }
+}
+exports.AffluentContext = AffluentContext;

package/dist/contracts/common/type.d.ts

@@ -0,0 +1,16 @@
+import { Address, Cell } from "@ton/core";
+export type Maybe<T> = T | null | undefined;
+export type AddressLike = string | Address;
+export interface Addressable {
+    address: Address;
+}
+export type AddressInput = Addressable | AddressLike;
+/**
+ * Raw transaction message for sending via provider.send()
+ * Action layer returns this instead of sending directly
+ */
+export type TxMessage = {
+    to: Address;
+    value: bigint;
+    body: Cell;
+};

package/dist/contracts/common/type.js

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

package/dist/contracts/common/utils.d.ts

@@ -0,0 +1,3 @@
+import { Address } from "@ton/core";
+import { AddressInput } from "./type";
+export declare function toAddress(value: AddressInput): Address;

package/dist/contracts/common/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toAddress = toAddress;
+const core_1 = require("@ton/core");
+function toAddress(value) {
+    if (typeof value === "string") {
+        return core_1.Address.parse(value);
+    }
+    if (value instanceof core_1.Address) {
+        return value;
+    }
+    if ("address" in value) {
+        return toAddress(value.address);
+    }
+    throw new Error("Invalid address");
+}

package/dist/contracts/core/account/index.d.ts

@@ -0,0 +1,38 @@
+import { Address, Cell, Contract, ContractProvider, Sender, Slice } from "@ton/core";
+import { AccountAssetState, AccountState } from "./type";
+import { PoolState } from "../pool/type";
+export type AccountConfig = {
+    pool: Address;
+    owner: Address;
+};
+export declare function accountConfigToCell(config: AccountConfig): Cell;
+export declare class Account implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static createFromAddress(address: Address): Account;
+    static createFromConfig(config: AccountConfig, code: Cell, workchain?: number): Account;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    sendDeploy(provider: ContractProvider, via: Sender, value: bigint): Promise<void>;
+    getAccountData(provider: ContractProvider): Promise<AccountState>;
+    static parseAccountData(data: Slice): {
+        pool: Address;
+        owner: Address;
+        status: Record<string, AccountAssetState>;
+    };
+    static haveBorrow(accountData: AccountState): boolean;
+    static haveAssets(accountData: AccountState): string[];
+    static convertShareToAmount(accountData: AccountState, poolData: PoolState): AccountState;
+    static applyDelta(accountData: AccountState, delta: Record<string, AccountAssetState>): {
+        status: Record<string, AccountAssetState>;
+        address: Address;
+        pool: Address;
+        owner: Address;
+    };
+}

package/dist/contracts/core/account/index.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Account = void 0;
+exports.accountConfigToCell = accountConfigToCell;
+const core_1 = require("@ton/core");
+function accountConfigToCell(config) {
+    return (0, core_1.beginCell)()
+        .storeAddress(config.pool)
+        .storeAddress(config.owner)
+        .storeDict(core_1.Dictionary.empty())
+        .storeDict(core_1.Dictionary.empty())
+        .endCell();
+}
+class Account {
+    address;
+    init;
+    constructor(address, init) {
+        this.address = address;
+        this.init = init;
+    }
+    static createFromAddress(address) {
+        return new Account(address);
+    }
+    static createFromConfig(config, code, workchain = 0) {
+        const data = accountConfigToCell(config);
+        const init = { code, data };
+        return new Account((0, core_1.contractAddress)(workchain, init), init);
+    }
+    async getState(provider) {
+        return await provider.getState();
+    }
+    async sendDeploy(provider, via, value) {
+        await provider.internal(via, {
+            value,
+            sendMode: core_1.SendMode.PAY_GAS_SEPARATELY,
+            body: (0, core_1.beginCell)().endCell(),
+        });
+    }
+    async getAccountData(provider) {
+        const state = await provider.getState();
+        if (state.state.type !== "active")
+            throw "not active";
+        if (!state.state.data)
+            throw "not active";
+        const data = core_1.Cell.fromBoc(state.state.data)[0].beginParse();
+        return {
+            address: this.address,
+            ...Account.parseAccountData(data),
+        };
+    }
+    static parseAccountData(data) {
+        const pool = data.loadAddress();
+        const owner = data.loadAddress();
+        const statusDict = data.loadDict(core_1.Dictionary.Keys.Address(), DictioryValueAccountAsset);
+        const status = statusDict.keys().reduce((acc, cur) => {
+            acc[cur.toString()] = {
+                address: cur.toString(),
+                ...statusDict.get(cur),
+            };
+            return acc;
+        }, {});
+        return {
+            pool,
+            owner,
+            status,
+        };
+    }
+    static haveBorrow(accountData) {
+        const found = Object.values(accountData.status).find((item) => item.borrow > 0n);
+        return !!found;
+    }
+    static haveAssets(accountData) {
+        const assets = Object.entries(accountData.status)
+            .filter((item) => item[1].supply > 0n || item[1].borrow > 0n)
+            .map((item) => item[0]);
+        return assets;
+    }
+    static convertShareToAmount(accountData, poolData) {
+        const newStatus = {};
+        Object.entries(accountData.status).forEach(([assetAddress, statusInfo]) => {
+            const assetData = poolData.assets[assetAddress];
+            const supplyAmount = statusInfo.supply > 0n && assetData.totalSupplyShare > 0n
+                ? (statusInfo.supply * assetData.totalSupplyAmount) / assetData.totalSupplyShare
+                : 0n;
+            const borrowAmount = statusInfo.borrow > 0n && assetData.totalBorrowShare > 0n
+                ? (statusInfo.borrow * assetData.totalBorrowAmount) / assetData.totalBorrowShare
+                : 0n;
+            newStatus[assetAddress] = {
+                ...statusInfo,
+                supply: supplyAmount,
+                borrow: borrowAmount,
+            };
+        });
+        return {
+            ...accountData,
+            status: newStatus,
+        };
+    }
+    static applyDelta(accountData, delta) {
+        const newStatus = {
+            ...accountData.status,
+        };
+        Object.entries(delta).forEach(([assetAddress, deltaState]) => {
+            const statusInfo = accountData.status[assetAddress];
+            newStatus[assetAddress] = {
+                address: core_1.Address.parse(assetAddress),
+                supply: (statusInfo?.supply ?? 0n) + deltaState.supply,
+                borrow: (statusInfo?.borrow ?? 0n) + deltaState.borrow,
+            };
+        });
+        return {
+            ...accountData,
+            status: newStatus,
+        };
+    }
+}
+exports.Account = Account;
+const DictioryValueAccountAsset = {
+    serialize: (src, builder) => { },
+    parse: (src) => {
+        const supply = src.loadCoins();
+        const borrow = src.loadCoins();
+        return {
+            supply,
+            borrow,
+        };
+    },
+};

package/dist/contracts/core/account/type.d.ts

@@ -0,0 +1,18 @@
+import { Address } from "@ton/ton";
+export type AccountState = {
+    address: Address;
+    pool: Address;
+    owner: Address;
+    status: Record<string, AccountAssetState>;
+};
+export type AccountAssetState = {
+    address: Address;
+    supply: bigint;
+    borrow: bigint;
+};
+export type AccountAssetStateWithDelta = {
+    address: Address;
+    supply: bigint;
+    borrow: bigint;
+    deltaCoefficient: bigint;
+};

package/dist/contracts/core/account/type.js

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

package/dist/contracts/core/pool/index.d.ts

@@ -0,0 +1,149 @@
+import { Address, Builder, Cell, Contract, ContractProvider, Sender, Slice } from "@ton/core";
+import { LiquidateParams, TransferInParams, TransferOutMsgParams, PoolState, AssetState, PoolGasFee } from "./type";
+/**
+ * Convert pool share to actual amount
+ *
+ * @param share - Share amount
+ * @param totalAmount - Total amount in pool
+ * @param totalShare - Total shares in pool
+ * @returns Actual amount
+ */
+export declare function shareToAmount(share: bigint, totalAmount: bigint, totalShare: bigint): bigint;
+/**
+ * Convert pool share position to actual amounts
+ *
+ * @param position - Share-based position (supply/borrow shares)
+ * @param assetState - Pool asset state with total shares and amounts
+ * @returns Actual amounts (supply/borrow)
+ */
+export declare function positionShareToAmount(position: {
+    supply: bigint;
+    borrow: bigint;
+}, assetState: {
+    totalSupplyAmount: bigint;
+    totalSupplyShare: bigint;
+    totalBorrowAmount: bigint;
+    totalBorrowShare: bigint;
+}): {
+    supply: bigint;
+    borrow: bigint;
+};
+export declare class Pool implements Contract {
+    readonly address: Address;
+    readonly init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined;
+    constructor(address: Address, init?: {
+        code: Cell;
+        data: Cell;
+    } | undefined);
+    static Op: {
+        supply: number;
+        withdraw: number;
+        borrow: number;
+        repay: number;
+        liquidate: number;
+        actionNotification: number;
+        Supply: number;
+        Withdraw: number;
+        Borrow: number;
+        Repay: number;
+        Liquidate: number;
+        ActionNotification: number;
+        ProvideAccountStatusAndLock: number;
+        TakeAsset: number;
+        UpdateAccountStatus: number;
+        ProcessBorrowActionResult: number;
+        ExecuteAction: number;
+        SetIrmConfig: number;
+        SetOwner: number;
+        SetFeeConfigurer: number;
+    };
+    static ErrorCodes: {
+        unauthorized: number;
+        invalidAsset: number;
+        invalidWallet: number;
+        invalidAddress: number;
+        alreadyInitialized: number;
+        notEnoughCash: number;
+        notEnoughShare: number;
+        notEnoughLiquidity: number;
+        notFoundPrice: number;
+        notFoundAccount: number;
+        enoughLiquidity: number;
+        notEnoughProtocolFee: number;
+        notBorrowableAsset: number;
+        alreadyExistAsset: number;
+        lockedAccount: number;
+        notEnoughGas: number;
+        actionTimeout: number;
+        seizeAssetIsRepayAsset: number;
+        unknownOp: number;
+    };
+    static Gas: {
+        baseFee: bigint;
+        forwardFee: bigint;
+        LiquidateionNotificationFee: bigint;
+    };
+    static createFromAddress(address: Address): Pool;
+    static createSupplyPayload(params: TransferInParams): Cell;
+    static createRepayPayload(params: TransferInParams): Cell;
+    static createLiquidatePayload(params: LiquidateParams): Cell;
+    static createWithdrawMsgBody(params: TransferOutMsgParams): Cell;
+    static createBorrowMsgBody(params: TransferOutMsgParams): Cell;
+    sendSetOwner(provider: ContractProvider, via: Sender, value: bigint, opts: {
+        newOwner: Address;
+        queryID?: number;
+    }): Promise<void>;
+    sendWithdraw(provider: ContractProvider, via: Sender, value: bigint, params: TransferOutMsgParams): Promise<Cell>;
+    sendBorrow(provider: ContractProvider, via: Sender, value: bigint, params: TransferOutMsgParams): Promise<Cell>;
+    static createSetIrmConfigMsgBody: (params: {
+        asset: Address;
+        irmConfig: Cell;
+        queryId?: number;
+    }) => Cell;
+    static createSetOwnerMsgBody(opts: {
+        newOwner: Address;
+        queryID?: number;
+    }): Cell;
+    static parseSetOwnerMsgBody(cell: Cell): {
+        op: number;
+        queryID: number;
+        newOwner: Address;
+    };
+    static createSetFeeConfigurerMsgBody: (params: {
+        feeConfigurer: Address;
+        queryId?: number;
+    }) => Cell;
+    static calculateGasFee(actionOp: number, baseFee: bigint, forwardFee: bigint, forwardTonAmount: bigint, useInternalOracle: boolean, useOracle: boolean, gas: PoolGasFee): bigint;
+    getState(provider: ContractProvider): Promise<import("@ton/core").ContractState>;
+    static simulateAccrueInterest(poolState: PoolState, time?: number): PoolState;
+    getPoolData(provider: ContractProvider): Promise<PoolState>;
+    static parsePoolData(data: Slice): {
+        id: bigint;
+        owner: Address | null;
+        feeConfigurer: Address | null;
+        protocolFeeRate: bigint;
+        oracle: Address | null;
+        oracleConfig: Cell | import("../../oracle/redstone-onchain-oracle/type").RedstoneOnchainOracleConfig | import("../../oracle/redstone-oracle/type").RedstonOracleConfig;
+        maxLoanLeverageRatio: bigint;
+        maxLoanVarRatio: bigint;
+        liquidateLeverageRatio: bigint;
+        liquidateVarRatio: bigint;
+        minLiquidateCloseRatio: bigint;
+        maxLiquidateCloseRatio: bigint;
+        assets: Record<string, AssetState>;
+        minimumGasFee: PoolGasFee;
+        oracleConfigRaw: Cell;
+    };
+    getAccountAddress(provider: ContractProvider, owner: Address): Promise<Address>;
+    static Dictionary: {
+        Values: {
+            Asset: () => {
+                serialize: (src: any, builder: Builder) => void;
+                parse: (src: Slice) => Omit<AssetState, "address">;
+            };
+        };
+    };
+}