@affluent-org/sdk 0.0.5 → 0.0.7

package/dist/affluent.d.ts

@@ -1,13 +1,13 @@
 import { PoolServiceV1 as PoolV1 } from "./services/pool";
 import { ShareVaultServiceV1 as ShareVaultV1 } from "./services/share-vault";
-import { StrategyVaultV1 } from "./services/strategy-vault";
+import { StrategyVaultServiceV1 } from "./services/strategy-vault";
 import { RFQAuctionServiceV1 } from "./services/rfq-auction";
 import { RFQBatchServiceV1 } from "./services/rfq-batch";
-export { PoolV1, ShareVaultV1, StrategyVaultV1, RFQAuctionServiceV1 as RFQAuctionV1, RFQBatchServiceV1 as RFQBatchV1 };
+export { PoolV1, ShareVaultV1, StrategyVaultServiceV1, RFQAuctionServiceV1 as RFQAuctionV1, RFQBatchServiceV1 as RFQBatchV1 };
 declare const _default: {
     PoolV1: typeof PoolV1;
     ShareVaultV1: typeof ShareVaultV1;
-    StrategyVaultV1: typeof StrategyVaultV1;
+    StrategyVaultV1: typeof StrategyVaultServiceV1;
     RFQAuctionV1: typeof RFQAuctionServiceV1;
     RFQBatchV1: typeof RFQBatchServiceV1;
 };

package/dist/affluent.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RFQBatchV1 = exports.RFQAuctionV1 = exports.StrategyVaultV1 = exports.ShareVaultV1 = exports.PoolV1 = void 0;
+exports.RFQBatchV1 = exports.RFQAuctionV1 = exports.StrategyVaultServiceV1 = exports.ShareVaultV1 = exports.PoolV1 = void 0;
 const pool_1 = require("./services/pool");
 Object.defineProperty(exports, "PoolV1", { enumerable: true, get: function () { return pool_1.PoolServiceV1; } });
 const share_vault_1 = require("./services/share-vault");
 Object.defineProperty(exports, "ShareVaultV1", { enumerable: true, get: function () { return share_vault_1.ShareVaultServiceV1; } });
 const strategy_vault_1 = require("./services/strategy-vault");
-Object.defineProperty(exports, "StrategyVaultV1", { enumerable: true, get: function () { return strategy_vault_1.StrategyVaultV1; } });
+Object.defineProperty(exports, "StrategyVaultServiceV1", { enumerable: true, get: function () { return strategy_vault_1.StrategyVaultServiceV1; } });
 const rfq_auction_1 = require("./services/rfq-auction");
 Object.defineProperty(exports, "RFQAuctionV1", { enumerable: true, get: function () { return rfq_auction_1.RFQAuctionServiceV1; } });
 const rfq_batch_1 = require("./services/rfq-batch");
@@ -14,7 +14,7 @@ Object.defineProperty(exports, "RFQBatchV1", { enumerable: true, get: function (
 exports.default = {
     PoolV1: pool_1.PoolServiceV1,
     ShareVaultV1: share_vault_1.ShareVaultServiceV1,
-    StrategyVaultV1: strategy_vault_1.StrategyVaultV1,
+    StrategyVaultV1: strategy_vault_1.StrategyVaultServiceV1,
     RFQAuctionV1: rfq_auction_1.RFQAuctionServiceV1,
     RFQBatchV1: rfq_batch_1.RFQBatchServiceV1,
 };

package/dist/common/computation.d.ts

@@ -0,0 +1,6 @@
+import { IAmountPosition, SyntheticCompositions, VaultCompositions } from "./types";
+/**
+ * Try to decompose a synthetic/vault asset to its underlying assets
+ * Returns null if asset is native (no decomposition needed)
+ */
+export declare function tryNativeDecomposeAsset(asset: string, position: IAmountPosition, syntheticCompositions: SyntheticCompositions, vaultCompositions: VaultCompositions): Record<string, IAmountPosition>;

package/dist/common/computation.js

@@ -0,0 +1,54 @@
+"use strict";
+// ============================================================
+// Position Decomposition Helpers
+// ============================================================
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tryNativeDecomposeAsset = tryNativeDecomposeAsset;
+const types_1 = require("./types");
+const helper_1 = require("./helper");
+/**
+ * Try to decompose a synthetic/vault asset to its underlying assets
+ * Returns null if asset is native (no decomposition needed)
+ */
+function tryNativeDecomposeAsset(asset, position, syntheticCompositions, vaultCompositions) {
+    const data = syntheticCompositions[asset];
+    const result = {};
+    const vault = vaultCompositions[asset];
+    if (vault) {
+        // VAULT: Strategy Vault - uses decomposed positions
+        const vaultAmountCTX = vault.amountContext;
+        result;
+        Object.entries(vaultAmountCTX.decompose())
+            .forEach(([addr, pos]) => {
+            const vaultDecomposed = tryNativeDecomposeAsset(addr, position.cross(pos, vaultAmountCTX.totalSupply), syntheticCompositions, vaultCompositions);
+            (0, helper_1.applyPositions)(result, vaultDecomposed);
+        });
+    }
+    else if (data?.assetType === types_1.CompositeAssetType.SYNTHETIC1 &&
+        "underlyingReserve" in data &&
+        data.underlyingReserve &&
+        data.totalSupply) {
+        // SYNTHETIC1: single underlying asset (e.g. stTON, tsTON)
+        const ratio = data.underlyingReserve;
+        const total = data.totalSupply;
+        const decomposed = tryNativeDecomposeAsset(data.underlyingAddress.toString(), position.muldiv(ratio, total), syntheticCompositions, vaultCompositions);
+        (0, helper_1.applyPositions)(result, decomposed);
+    }
+    else if (data?.assetType === types_1.CompositeAssetType.SYNTHETIC2 &&
+        "underlying0Reserve" in data &&
+        data.underlying0Reserve &&
+        data.underlying1Reserve &&
+        data.totalSupply) {
+        // SYNTHETIC2: two underlying assets (e.g. LP tokens)
+        const total = data.totalSupply;
+        const decomposed0 = tryNativeDecomposeAsset(data.underlying0Address.toString(), position.muldiv(data.underlying0Reserve, total), syntheticCompositions, vaultCompositions);
+        const decomposed1 = tryNativeDecomposeAsset(data.underlying1Address.toString(), position.muldiv(data.underlying1Reserve, total), syntheticCompositions, vaultCompositions);
+        (0, helper_1.applyPositions)(result, decomposed0);
+        (0, helper_1.applyPositions)(result, decomposed1);
+    }
+    else {
+        // NATIVE: native asset (e.g. TON, USDT)
+        result[asset] = position.addPosition(result[asset]);
+    }
+    return result;
+}

package/dist/common/helper.d.ts

@@ -0,0 +1,5 @@
+import { IPosition } from "./types";
+export declare function copyPositions<P extends IPosition>(src: Record<string, P>): Record<string, P>;
+export declare function applyPositions<P extends IPosition>(dst: Record<string, P>, src: Record<string, P>): void;
+export declare function mergePositions<P extends IPosition>(a: Record<string, P>, b: Record<string, P>): void;
+export declare function mapPositions<A extends string, P extends IPosition, R>(src: Record<A, P>, mapFn: (asset: A, position: P) => R): Record<A, R>;

package/dist/common/helper.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.copyPositions = copyPositions;
+exports.applyPositions = applyPositions;
+exports.mergePositions = mergePositions;
+exports.mapPositions = mapPositions;
+function copyPositions(src) {
+    const result = {};
+    Object.entries(src)
+        .forEach(([asset, position]) => {
+        result[asset] = position.clone();
+    });
+    return result;
+}
+function applyPositions(dst, src) {
+    Object.entries(src)
+        .forEach(([asset, position]) => {
+        dst[asset] = position.addPosition(dst[asset]);
+    });
+}
+function mergePositions(a, b) {
+    return applyPositions(copyPositions(a), b);
+}
+function mapPositions(src, mapFn) {
+    const result = {};
+    Object.entries(copyPositions(src))
+        .forEach(([asset, position]) => result[asset] = mapFn(asset, position));
+    return result;
+}

package/dist/common/service.d.ts

@@ -1,14 +1,20 @@
 import { Contract, OpenedContract, TonClient } from "@ton/ton";
 import { ContractCache } from "./cache";
 import { Address, Sender } from "@ton/core";
-import { AddressInput } from "../contracts/common/type";
+import { AddressInput, AddressLike } from "../contracts/common/type";
+import { AssetType } from "./type";
+import { ContractVersions } from "./versions";
+import { AssetPriceInfo, OnchainDataInfo } from "../contracts/oracle/redstone-onchain-oracle/type";
 export declare class ServiceBaseV1 {
     readonly client: TonClient;
     readonly network: "testnet" | "mainnet" | "custom";
+    static assetTypes: Record<string, AssetType>;
     contracts: Record<string, string>;
     readonly contractCache: ContractCache;
-    readonly cache_ttl: number;
+    cache_ttl: number;
+    contractVersion: ContractVersions;
     constructor(client: TonClient, network: "testnet" | "mainnet" | "custom", custom_contracts?: Record<string, string>, cache_ttl?: number);
+    isWTON(address: AddressLike): boolean;
     getByContract<T extends Contract>(contractType: {
         createFromAddress(address: Address): T;
         name?: string;
@@ -17,4 +23,6 @@ export declare class ServiceBaseV1 {
     getWalletSeq(address: Address): Promise<number>;
     waitWalletSeq(address: Address, nextSeqno: number, sleepInterval?: number): Promise<number>;
     deployWTONWallet(sender: Sender, owner: AddressInput): Promise<number>;
+    getAssetType(assetAddress: AddressInput): Promise<AssetType>;
+    updateOnchainInternalData(prices: AssetPriceInfo, onchainData: OnchainDataInfo): AssetPriceInfo;
 }

package/dist/common/service.js

@@ -6,13 +6,20 @@ const cache_1 = require("./cache");
 const core_1 = require("@ton/core");
 const utils_1 = require("../contracts/common/utils");
 const jetton_minter_1 = require("../contracts/wton/jetton-minter");
+const share_vault_1 = require("../contracts/vault/share-vault");
+const strategy_vault_1 = require("../contracts/vault/strategy-vault");
+const versions_1 = require("./versions");
+const type_1 = require("../contracts/oracle/redstone-onchain-oracle/type");
+const redstone_onchain_oracle_1 = require("../contracts/oracle/redstone-onchain-oracle");
 class ServiceBaseV1 {
     client;
     network;
+    static assetTypes = {};
     contracts;
     contractCache;
-    cache_ttl = 2500;
-    constructor(client, network, custom_contracts, cache_ttl) {
+    cache_ttl;
+    contractVersion;
+    constructor(client, network, custom_contracts, cache_ttl = 2500) {
         this.client = client;
         this.network = network;
         if (network === "custom" && !custom_contracts)
@@ -24,7 +31,11 @@ class ServiceBaseV1 {
                     ? contracts_1.TESTNET_CONTRACTS
                     : custom_contracts;
         this.contractCache = cache_1.ContractCache.getInstance();
-        this.cache_ttl = cache_ttl || this.cache_ttl;
+        this.cache_ttl = cache_ttl;
+        this.contractVersion = new versions_1.ContractVersions();
+    }
+    isWTON(address) {
+        return (0, utils_1.toAddress)(address).toString() === this.contracts.WTON;
     }
     getByContract(contractType, address_) {
         const address = (0, utils_1.toAddress)(address_);
@@ -65,5 +76,47 @@ class ServiceBaseV1 {
         });
         return this.waitWalletSeq(sender.address, lastSeqno + 1);
     }
+    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 {
+            const assetInfo = {
+                type: "share-vault",
+                data: share_vault_1.ShareVault.parseVaultData(dataCell),
+            };
+            ServiceBaseV1.assetTypes[address.toString()] = assetInfo;
+            return assetInfo;
+        }
+        catch (_) { }
+        try {
+            const assetInfo = {
+                type: "strategy-vault",
+                data: strategy_vault_1.StrategyVault.parseVaultData(dataCell),
+            };
+            ServiceBaseV1.assetTypes[address.toString()] = assetInfo;
+            return assetInfo;
+        }
+        catch (_) { }
+        const assetInfo = {
+            type: "underlying-asset",
+        };
+        ServiceBaseV1.assetTypes[address.toString()] = assetInfo;
+        return assetInfo;
+    }
+    updateOnchainInternalData(prices, onchainData) {
+        for (const [asset, data] of Object.entries(onchainData)) {
+            if (data.sourceType === redstone_onchain_oracle_1.RedstoneOnchainOracle.SourceType.internal) {
+                prices[asset] = {
+                    type: type_1.AssetType.Native,
+                    price: data.price,
+                    timestamp: Date.now(),
+                };
+            }
+        }
+        return prices;
+    }
 }
 exports.ServiceBaseV1 = ServiceBaseV1;

package/dist/common/trace-action.d.ts

@@ -0,0 +1,92 @@
+import { Address, Cell } from "@ton/core";
+import { MessageHash } from "../utils/external-message-hash";
+import { ToncenterTraceRaw } from "../utils/toncenter/type";
+import { ToncenterV3Client } from "../utils/pending-tracker/v3-client";
+export type Step = {
+    from: Address;
+    to: Address;
+    op?: number;
+    description?: string;
+};
+export declare function findStepTx(trace: ToncenterTraceRaw, step: Step): import("../utils/toncenter/type").ToncenterTransactionRaw | undefined;
+export declare function getOpAndQueryId(body: Cell): {
+    op: number;
+    queryId: bigint;
+};
+export type JettonSendParams = {
+    isWTON: boolean;
+    actor: Address;
+    actorWallet: Address;
+    targetWallet: Address;
+    target: Address;
+    description?: string;
+};
+export type JettonReceiveParams = {
+    isWTON: boolean;
+    sourceWallet: Address;
+    actorWallet: Address;
+    description?: string;
+};
+export type BurnParams = {
+    actor: Address;
+    actorWallet: Address;
+    minter: Address;
+    description?: string;
+};
+export type MintParams = {
+    minter: Address;
+    actorWallet: Address;
+    description?: string;
+};
+export declare function createJettonSendSteps(params: JettonSendParams): Step[];
+/**
+ * Starts from InternalTransfer (skips Transfer to avoid order issues with multi-destination sends)
+ * WTON: adds UnwrapNotification when actor is provided
+ */
+export declare function createJettonReceiveSteps(params: JettonReceiveParams & {
+    actor?: Address;
+}): Step[];
+export declare function createBurnSteps(params: BurnParams): Step[];
+export declare function createMintSteps(params: MintParams): Step[];
+export declare abstract class TracerBase<T> {
+    protected toncenterClient: ToncenterV3Client;
+    readonly extHash: MessageHash;
+    readonly type: T;
+    readonly queryId: bigint;
+    readonly steps: Step[];
+    readonly failStep?: Step | undefined;
+    static Progress: {
+        Pending: number;
+        Completed: number;
+        Failed: number;
+        Unknown: number;
+    };
+    static WaitConfig: {
+        MaxRetries: number;
+        IntervalMs: number;
+    };
+    protected waitingStep: number;
+    protected done: boolean;
+    constructor(toncenterClient: ToncenterV3Client, extHash: MessageHash, type: T, queryId: bigint, steps: Step[], failStep?: Step | undefined);
+    setToncenterClient(toncenterClient: ToncenterV3Client): this;
+    update(trace?: ToncenterTraceRaw): Promise<void>;
+    getWaitingStep(): {
+        progress: number;
+        description: string | undefined;
+    };
+    isTerminal(): boolean;
+    wait(): Promise<{
+        progress: number;
+        description: string | undefined;
+    }>;
+}
+export type SimpleTracerParams = {
+    extHash: MessageHash;
+    queryId: bigint;
+    actor: Address;
+    target: Address;
+    op: number;
+};
+export declare class SimpleTracer extends TracerBase<"simple"> {
+    constructor(toncenterClient: ToncenterV3Client, params: SimpleTracerParams);
+}

package/dist/common/trace-action.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SimpleTracer = exports.TracerBase = void 0;
+exports.findStepTx = findStepTx;
+exports.getOpAndQueryId = getOpAndQueryId;
+exports.createJettonSendSteps = createJettonSendSteps;
+exports.createJettonReceiveSteps = createJettonReceiveSteps;
+exports.createBurnSteps = createBurnSteps;
+exports.createMintSteps = createMintSteps;
+const core_1 = require("@ton/core");
+const jetton_wallet_1 = require("../contracts/jetton/jetton-wallet");
+const jetton_wallet_2 = require("../contracts/wton/jetton-wallet");
+function findStepTx(trace, step) {
+    return Object.values(trace.transactions).find(tx => {
+        if (tx.in_msg) {
+            return (step.op ? Number(tx.in_msg.opcode) === step.op : true)
+                && step.from.equals(core_1.Address.parse(tx.in_msg.source))
+                && step.to.equals(core_1.Address.parse(tx.in_msg.destination));
+        }
+        return false;
+    });
+}
+function getOpAndQueryId(body) {
+    const slice = body.beginParse();
+    const op = slice.loadUint(32);
+    const queryId = slice.loadUintBig(64);
+    return { op, queryId };
+}
+function createJettonSendSteps(params) {
+    const { isWTON, actor, actorWallet, targetWallet, target, description } = params;
+    if (isWTON) {
+        return [
+            { op: jetton_wallet_2.WTONWallet.Op.ExternalTransfer, from: actor, to: targetWallet, description },
+            { op: jetton_wallet_2.WTONWallet.Op.TransferNotification, from: targetWallet, to: target, description },
+        ];
+    }
+    return [
+        { op: jetton_wallet_1.JettonWallet.Op.Transfer, from: actor, to: actorWallet, description },
+        { op: jetton_wallet_1.JettonWallet.Op.InternalTransfer, from: actorWallet, to: targetWallet, description },
+        { op: jetton_wallet_1.JettonWallet.Op.TransferNotification, from: targetWallet, to: target, description },
+    ];
+}
+/**
+ * Starts from InternalTransfer (skips Transfer to avoid order issues with multi-destination sends)
+ * WTON: adds UnwrapNotification when actor is provided
+ */
+function createJettonReceiveSteps(params) {
+    const { isWTON, sourceWallet, actorWallet, actor, description } = params;
+    const Op = isWTON ? jetton_wallet_2.WTONWallet.Op : jetton_wallet_1.JettonWallet.Op;
+    const steps = [
+        { op: Op.InternalTransfer, from: sourceWallet, to: actorWallet, description },
+    ];
+    if (isWTON && actor) {
+        steps.push({ op: jetton_wallet_2.WTONWallet.Op.UnwrapNotification, from: actorWallet, to: actor, description: "Unwrapping WTON" });
+    }
+    return steps;
+}
+function createBurnSteps(params) {
+    const { actor, actorWallet, minter, description } = params;
+    return [
+        { op: jetton_wallet_1.JettonWallet.Op.Burn, from: actor, to: actorWallet, description },
+        { op: jetton_wallet_1.JettonWallet.Op.BurnNotification, from: actorWallet, to: minter, description },
+    ];
+}
+function createMintSteps(params) {
+    const { minter, actorWallet, description } = params;
+    return [
+        { op: jetton_wallet_1.JettonWallet.Op.InternalTransfer, from: minter, to: actorWallet, description },
+    ];
+}
+// ============================================================
+// TracerBase
+// ============================================================
+class TracerBase {
+    toncenterClient;
+    extHash;
+    type;
+    queryId;
+    steps;
+    failStep;
+    static Progress = {
+        Pending: 0,
+        Completed: 1,
+        Failed: -1,
+        Unknown: -2,
+    };
+    static WaitConfig = {
+        MaxRetries: 30,
+        IntervalMs: 2000,
+    };
+    waitingStep;
+    done;
+    constructor(toncenterClient, extHash, type, queryId, steps, failStep) {
+        this.toncenterClient = toncenterClient;
+        this.extHash = extHash;
+        this.type = type;
+        this.queryId = queryId;
+        this.steps = steps;
+        this.failStep = failStep;
+        this.waitingStep = 0;
+        this.done = false;
+    }
+    setToncenterClient(toncenterClient) {
+        this.toncenterClient = toncenterClient;
+        return this;
+    }
+    async update(trace) {
+        trace ??= await this.toncenterClient.pollDetailedTrace(this.extHash.base64);
+        if (trace?.trace_info?.trace_state === 'complete')
+            this.done = true;
+        if (this.waitingStep < 0)
+            return;
+        if (this.waitingStep >= this.steps.length)
+            return;
+        const step = this.steps[this.waitingStep];
+        const stepTx = findStepTx(trace, step);
+        if (stepTx) {
+            this.waitingStep++;
+            this.update(trace);
+        }
+        if (this.failStep && findStepTx(trace, this.failStep)) {
+            this.waitingStep = TracerBase.Progress.Failed;
+            return;
+        }
+        if (trace.trace_info?.trace_state === 'complete' && this.waitingStep < this.steps.length) {
+            this.waitingStep = TracerBase.Progress.Unknown;
+            return;
+        }
+    }
+    getWaitingStep() {
+        if (this.done && this.waitingStep === this.steps.length)
+            return {
+                progress: TracerBase.Progress.Completed,
+                description: "Completed"
+            };
+        if (this.waitingStep === TracerBase.Progress.Failed)
+            return {
+                progress: TracerBase.Progress.Failed,
+                description: this.failStep?.description
+            };
+        if (this.waitingStep === TracerBase.Progress.Unknown)
+            return {
+                progress: TracerBase.Progress.Unknown,
+                description: "Unknown error"
+            };
+        return {
+            progress: this.waitingStep / this.steps.length,
+            description: this.steps[this.waitingStep].description,
+        };
+    }
+    isTerminal() {
+        return this.done || this.waitingStep < 0;
+    }
+    async wait() {
+        const { MaxRetries, IntervalMs } = TracerBase.WaitConfig;
+        for (let i = 0; i < MaxRetries; i++) {
+            await this.update();
+            if (this.isTerminal()) {
+                const result = this.getWaitingStep();
+                console.log(result);
+                return result;
+            }
+            ;
+            await new Promise(r => setTimeout(r, IntervalMs));
+        }
+        const result = this.getWaitingStep();
+        console.log(result);
+        return result;
+    }
+}
+exports.TracerBase = TracerBase;
+class SimpleTracer extends TracerBase {
+    constructor(toncenterClient, params) {
+        const { extHash, queryId, actor, target, op } = params;
+        const steps = [
+            { op, from: actor, to: target, description: "Executing" },
+        ];
+        const failStep = {
+            op: 0xffffffff,
+            from: target,
+            to: actor,
+            description: "Bounced",
+        };
+        super(toncenterClient, extHash, "simple", queryId, steps, failStep);
+    }
+}
+exports.SimpleTracer = SimpleTracer;

package/dist/common/transform.d.ts

@@ -2,14 +2,16 @@ import { Address, Cell } from "@ton/core";
 import { PoolState } from "../contracts/core/pool/type";
 import { ShareVaultState } from "../contracts/vault/share-vault";
 import { StrategyVaultState } from "../contracts/vault/strategy-vault";
-import { Prices, IPosition, ISharePosition, IValuePosition, IAmountPosition, IPoolAsset, IPoolContext, IVaultStateContext, IVaultAmountContext, IVaultValueContext, IPoolAmountPositions, IPoolValuePositions, IPoolSharePositions, IPoolContexts, IAmountPositionWithAddress } from "./types";
+import { Prices, IPosition, ISharePosition, IValuePosition, IAmountPosition, IPoolAsset, IPoolContext, IVaultStateContext, IVaultAmountContext, IVaultValueContext, IPoolAmountPositions, IPoolValuePositions, IPoolSharePositions, IPoolContexts } from "./types";
 export declare class Position implements IPosition {
-    supply: bigint;
-    borrow: bigint;
+    readonly supply: bigint;
+    readonly borrow: bigint;
     constructor(supply?: bigint, borrow?: bigint);
-    apply(supply: bigint, borrow: bigint): this;
-    applyPosition(position: typeof this): this;
+    add(supply: bigint, borrow: bigint): this;
+    addPosition(position?: typeof this): this;
+    muldiv(numerator: bigint, denominator: bigint): this;
     clone(): this;
+    cross(other: typeof this, denominator: bigint): this;
 }
 export declare class SharePosition extends Position implements ISharePosition {
     readonly _brand: 'SharePosition';
@@ -26,15 +28,6 @@ export declare class AmountPosition extends Position implements IAmountPosition
     toValuePosition(price: bigint): ValuePosition;
     net(): bigint;
 }
-export declare class AmountPositionWithAddress extends AmountPosition implements IAmountPositionWithAddress {
-    address: Address;
-    constructor(address: Address, supply: bigint, borrow: bigint);
-    static from(data: {
-        address: Address;
-        supply: bigint;
-        borrow: bigint;
-    }): AmountPositionWithAddress;
-}
 export declare class PoolAsset implements IPoolAsset {
     amount: AmountPosition;
     share: SharePosition;
@@ -65,22 +58,24 @@ export declare class VaultAmountContext implements IVaultAmountContext {
     readonly assets: Record<string, IAmountPosition>;
     readonly pools: IPoolAmountPositions;
     constructor(address: string, totalSupply: bigint, assets: Record<string, IAmountPosition>, pools: IPoolAmountPositions);
-    static fromVaultStateContext(VaultStateContext: VaultStateContext, poolContexts: IPoolContexts): VaultAmountContext;
+    static fromVaultStateContext(VaultStateContext: IVaultStateContext, poolContexts: IPoolContexts): VaultAmountContext;
     toValueContext(prices: Prices): VaultValueContext;
-    net(): Record<string, IAmountPosition>;
+    decompose(): Record<string, IAmountPosition>;
+    nativeDecompose(prices: Prices): VaultNativeAmountDecomposedContext;
 }
 export declare class VaultValueContext implements IVaultValueContext {
     readonly address: string;
+    readonly totalSupply: bigint;
     readonly assets: Record<string, IValuePosition>;
     readonly pools: IPoolValuePositions;
-    constructor(address: string, assets: Record<string, IValuePosition>, pools: IPoolValuePositions);
+    constructor(address: string, totalSupply: bigint, assets: Record<string, IValuePosition>, pools: IPoolValuePositions);
     static fromAmountContext(amountContext: VaultAmountContext, prices: Prices): VaultValueContext;
     get totalValue(): bigint;
-    net(): Record<string, IValuePosition>;
+    get price(): bigint;
+    decompose(): Record<string, IValuePosition>;
 }
 export declare class VaultNativeValueDecomposedContext extends VaultValueContext {
     static fromValueContext(valueContext: VaultValueContext, prices: Prices): VaultNativeValueDecomposedContext;
-    static decomposeContext(valueContext: Record<string, IValuePosition>, prices: Prices, nativeAssets: Record<string, IValuePosition>): Record<string, IValuePosition>;
     net(): Record<string, IValuePosition>;
 }
 export declare class VaultNativeAmountDecomposedContext {
@@ -88,6 +83,5 @@ export declare class VaultNativeAmountDecomposedContext {
     readonly totalSupply: bigint;
     readonly assets: Record<string, IAmountPosition>;
     constructor(address: string, totalSupply: bigint, assets: Record<string, IAmountPosition>);
-    net(): Record<string, IAmountPosition>;
-    static fromDecomposedValueContext(decomposedValueContext: VaultValueContext, prices: Prices): VaultNativeAmountDecomposedContext;
+    static fromAmountContext(valueContext: VaultAmountContext, prices: Prices): VaultNativeAmountDecomposedContext;
 }