aftermath-ts-sdk 0.0.162 → 0.0.164

package/dist/packages/staking/api/stakingApiHelpers.js

@@ -1,400 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StakingApiHelpers = void 0;
-const sui_js_1 = require("@mysten/sui.js");
-const eventsApiHelpers_1 = require("../../../general/api/eventsApiHelpers");
-const aftermathApi_1 = require("../../../general/providers/aftermathApi");
-const types_1 = require("../../../types");
-const coin_1 = require("../../coin/coin");
-const utils_1 = require("../../../general/utils");
-class StakingApiHelpers {
-    /////////////////////////////////////////////////////////////////////
-    //// Constructor
-    /////////////////////////////////////////////////////////////////////
-    constructor(Provider) {
-        this.Provider = Provider;
-        /////////////////////////////////////////////////////////////////////
-        //// Move Calls
-        /////////////////////////////////////////////////////////////////////
-        /////////////////////////////////////////////////////////////////////
-        //// Transaction Creation
-        /////////////////////////////////////////////////////////////////////
-        this.addStakeCommandToTransaction = (inputs) => {
-            const { tx, suiCoin } = inputs;
-            return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTransactionTarget(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.interface, "request_add_stake"),
-                typeArguments: [],
-                arguments: [
-                    tx.object(this.addresses.objects.staking),
-                    typeof suiCoin === "string" ? tx.object(suiCoin) : suiCoin,
-                    tx.pure(inputs.validatorAddress, "address"),
-                ],
-            });
-        };
-        this.addUnstakeCommandToTransaction = (inputs) => {
-            const { tx, afSuiCoin } = inputs;
-            return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTransactionTarget(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.interface, "request_unstake"),
-                typeArguments: [],
-                arguments: [
-                    tx.object(this.addresses.objects.staking),
-                    typeof afSuiCoin === "string"
-                        ? tx.object(afSuiCoin)
-                        : afSuiCoin,
-                ],
-            });
-        };
-        this.addGetAfSuiSupplyCommandToTransaction = (inputs) => {
-            const { tx } = inputs;
-            return tx.moveCall({
-                target: utils_1.Helpers.transactions.createTransactionTarget(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.staking, "afsui_supply"),
-                typeArguments: [],
-                arguments: [tx.object(this.addresses.objects.staking)],
-            });
-        };
-        this.addGetStakedSuiTvlCommandToTransaction = (inputs) => {
-            const { tx } = inputs;
-            return tx.moveCall({
-                target: aftermathApi_1.AftermathApi.helpers.transactions.createTransactionTarget(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.staking, "total_sui_amount"),
-                typeArguments: [],
-                arguments: [tx.object(this.addresses.objects.staking)],
-            });
-        };
-        /////////////////////////////////////////////////////////////////////
-        //// Transaction Builders
-        /////////////////////////////////////////////////////////////////////
-        this.fetchBuildStakeTransaction = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { referrer } = inputs;
-            const tx = new sui_js_1.TransactionBlock();
-            tx.setSender(inputs.walletAddress);
-            if (referrer)
-                this.Provider.ReferralVault().Helpers.addUpdateReferrerCommandToTransaction({
-                    tx,
-                    referrer,
-                });
-            const suiCoin = yield this.Provider.Coin().Helpers.fetchCoinWithAmountTx({
-                tx,
-                walletAddress: inputs.walletAddress,
-                coinType: coin_1.Coin.constants.suiCoinType,
-                coinAmount: inputs.suiStakeAmount,
-            });
-            this.addStakeCommandToTransaction(Object.assign(Object.assign({ tx }, inputs), { suiCoin }));
-            return tx;
-        });
-        this.fetchBuildUnstakeTransaction = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { referrer } = inputs;
-            const tx = new sui_js_1.TransactionBlock();
-            tx.setSender(inputs.walletAddress);
-            if (referrer)
-                this.Provider.ReferralVault().Helpers.addUpdateReferrerCommandToTransaction({
-                    tx,
-                    referrer,
-                });
-            const afSuiCoin = yield this.Provider.Coin().Helpers.fetchCoinWithAmountTx({
-                tx,
-                walletAddress: inputs.walletAddress,
-                coinType: this.coinTypes.afSui,
-                coinAmount: inputs.afSuiUnstakeAmount,
-            });
-            this.addUnstakeCommandToTransaction(Object.assign(Object.assign({ tx }, inputs), { afSuiCoin }));
-            return tx;
-        });
-        /////////////////////////////////////////////////////////////////////
-        //// Events
-        /////////////////////////////////////////////////////////////////////
-        // TODO: add and filtering once available
-        this.fetchStakeRequestEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.Provider.Events().fetchCastEventsWithCursor({
-                // And: [
-                // 	{
-                MoveEventType: this.eventTypes.stakeRequest,
-                // 	},
-                // 	{
-                // 		Sender: inputs.walletAddress,
-                // 	},
-                // ],
-            }, utils_1.Casting.staking.stakeRequestEventFromOnChain, inputs.cursor, inputs.limit);
-        });
-        this.fetchUnstakeRequestEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.Provider.Events().fetchCastEventsWithCursor({
-                // And: [
-                // 	{
-                MoveEventType: this.eventTypes.unstakeRequest,
-                // 	},
-                // 	{
-                // 		Sender: inputs.walletAddress,
-                // 	},
-                // ],
-            }, utils_1.Casting.staking.unstakeRequestEventFromOnChain, inputs.cursor, inputs.limit);
-        });
-        this.fetchStakeSuccessEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.Provider.Events().fetchCastEventsWithCursor({
-                // And: [
-                // 	{
-                MoveEventType: this.eventTypes.stakeSuccess,
-                // 	},
-                // 	{
-                // 		Sender: inputs.walletAddress,
-                // 	},
-                // ],
-            }, utils_1.Casting.staking.stakeSuccessEventFromOnChain, inputs.cursor, inputs.limit);
-        });
-        this.fetchUnstakeSuccessEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.Provider.Events().fetchCastEventsWithCursor({
-                // And: [
-                // 	{
-                MoveEventType: this.eventTypes.unstakeSuccess,
-                // 	},
-                // 	{
-                // 		Sender: inputs.walletAddress,
-                // 	},
-                // ],
-            }, utils_1.Casting.staking.unstakeSuccessEventFromOnChain, inputs.cursor, inputs.limit);
-        });
-        this.fetchStakeFailedEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.Provider.Events().fetchCastEventsWithCursor({
-                // And: [
-                // 	{
-                MoveEventType: this.eventTypes.stakeFailed,
-                // 	},
-                // 	{
-                // 		Sender: inputs.walletAddress,
-                // 	},
-                // ],
-            }, utils_1.Casting.staking.stakeFailedEventFromOnChain, inputs.cursor, inputs.limit);
-        });
-        this.fetchAfSuiMintedEvents = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            return yield this.Provider.Events().fetchCastEventsWithCursor({
-                // And: [
-                // 	{
-                MoveEventType: this.eventTypes.afSuiMinted,
-                // 	},
-                // 	{
-                // 		Sender: inputs.walletAddress,
-                // 	},
-                // ],
-            }, utils_1.Casting.staking.afSuiMintedEventFromOnChain, inputs.cursor, inputs.limit);
-        });
-        /////////////////////////////////////////////////////////////////////
-        //// Positions
-        /////////////////////////////////////////////////////////////////////
-        this.fetchAllUnstakePositions = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { walletAddress } = inputs;
-            const [successEvents, requestEvents] = yield Promise.all([
-                // unstake success
-                (yield this.Provider.Events().fetchAllEvents((cursor, limit) => this.fetchUnstakeSuccessEvents({
-                    cursor,
-                    limit,
-                    walletAddress,
-                }))).filter((event) => event.staker === inputs.walletAddress),
-                // unstake request
-                (yield this.Provider.Events().fetchAllEvents((cursor, limit) => this.fetchUnstakeRequestEvents({
-                    cursor,
-                    limit,
-                    walletAddress,
-                }))).filter((event) => event.staker === inputs.walletAddress),
-            ]);
-            const positions = requestEvents.map((request) => {
-                const foundIndex = successEvents.findIndex((success) => success.afSuiWrapperId === request.afSuiWrapperId);
-                if (foundIndex >= 0)
-                    return Object.assign(Object.assign({}, successEvents[foundIndex]), { state: "SUCCESS", epoch: request.epoch });
-                return Object.assign({ state: "REQUEST" }, request);
-            });
-            return positions;
-        });
-        this.fetchAllStakePositions = (inputs) => __awaiter(this, void 0, void 0, function* () {
-            const { walletAddress } = inputs;
-            const [mintedEvents, successEvents, failedEvents, requestEvents] = yield Promise.all([
-                // afSui mint
-                (yield this.Provider.Events().fetchAllEvents((cursor, limit) => this.fetchAfSuiMintedEvents({
-                    cursor,
-                    limit,
-                    walletAddress,
-                }))).filter((event) => event.staker === inputs.walletAddress),
-                // stake success
-                (yield this.Provider.Events().fetchAllEvents((cursor, limit) => this.fetchStakeSuccessEvents({
-                    cursor,
-                    limit,
-                    walletAddress,
-                }))).filter((event) => event.staker === inputs.walletAddress),
-                // stake fail
-                (yield this.Provider.Events().fetchAllEvents((cursor, limit) => this.fetchStakeFailedEvents({
-                    cursor,
-                    limit,
-                    walletAddress,
-                }))).filter((event) => event.staker === inputs.walletAddress),
-                // stake request
-                (yield this.Provider.Events().fetchAllEvents((cursor, limit) => this.fetchStakeRequestEvents({
-                    cursor,
-                    limit,
-                    walletAddress,
-                }))).filter((event) => event.staker === inputs.walletAddress),
-            ]);
-            const positions = requestEvents.map((request) => {
-                const foundMintIndex = mintedEvents.findIndex((mint) => mint.suiWrapperId === request.suiWrapperId);
-                if (foundMintIndex >= 0)
-                    return Object.assign(Object.assign({}, mintedEvents[foundMintIndex]), { state: "AFSUI_MINTED", validatorAddress: request.validatorAddress, epoch: request.epoch });
-                const foundSuccessIndex = successEvents.findIndex((mint) => mint.suiWrapperId === request.suiWrapperId);
-                if (foundSuccessIndex >= 0)
-                    return Object.assign(Object.assign({}, successEvents[foundSuccessIndex]), { state: "SUCCESS", afSuiMintAmount: undefined, epoch: request.epoch });
-                const foundFailedIndex = failedEvents.findIndex((mint) => mint.suiWrapperId === request.suiWrapperId);
-                if (foundFailedIndex >= 0)
-                    return Object.assign(Object.assign({}, failedEvents[foundFailedIndex]), { state: "FAILED", afSuiMintAmount: undefined, epoch: request.epoch });
-                return Object.assign({ state: "REQUEST", afSuiMintAmount: undefined }, request);
-            });
-            return positions;
-        });
-        /////////////////////////////////////////////////////////////////////
-        //// Calculations
-        /////////////////////////////////////////////////////////////////////
-        this.calcLiquidStakingApy = (inputs) => {
-            const { delegatedStakes, validatorApys } = inputs;
-            const totalStakeAmount = utils_1.Helpers.sumBigInt(delegatedStakes.map((stake) => utils_1.Helpers.sumBigInt(stake.stakes.map((innerStake) => BigInt(innerStake.principal)))));
-            const weightedAverageApy = delegatedStakes.reduce((acc, stake) => {
-                var _b;
-                const apy = (_b = validatorApys.apys.find((apy) => apy.address === stake.validatorAddress)) === null || _b === void 0 ? void 0 : _b.apy;
-                if (apy === undefined)
-                    return acc;
-                const weight = Number(utils_1.Helpers.sumBigInt(stake.stakes.map((innerStake) => BigInt(innerStake.principal)))) / Number(totalStakeAmount);
-                const weightedApy = apy * weight;
-                return acc + weightedApy;
-            }, 0);
-            return weightedAverageApy;
-        };
-        /////////////////////////////////////////////////////////////////////
-        //// Private Methods
-        /////////////////////////////////////////////////////////////////////
-        /////////////////////////////////////////////////////////////////////
-        //// Event Types
-        /////////////////////////////////////////////////////////////////////
-        this.stakeRequestEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.actions, StakingApiHelpers.constants.eventNames.stakeRequest);
-        this.unstakeRequestEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.actions, StakingApiHelpers.constants.eventNames.unstakeRequest);
-        this.stakeFailedEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.actions, StakingApiHelpers.constants.eventNames.stakeFailed);
-        this.stakeSuccessEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.actions, StakingApiHelpers.constants.eventNames.stakeSuccess);
-        this.unstakeSuccessEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.actions, StakingApiHelpers.constants.eventNames.unstakeSuccess);
-        this.afSuiMintedEventType = () => eventsApiHelpers_1.EventsApiHelpers.createEventType(this.addresses.packages.lsd, StakingApiHelpers.constants.modules.actions, StakingApiHelpers.constants.eventNames.afSuiMinted);
-        this.fetchAfSuiSupply = () => __awaiter(this, void 0, void 0, function* () {
-            const tx = new sui_js_1.TransactionBlock();
-            this.addGetAfSuiSupplyCommandToTransaction({ tx });
-            const bytes = yield this.Provider.Inspections().fetchFirstBytesFromTxOutput(tx);
-            return utils_1.Casting.bigIntFromBytes(bytes);
-        });
-        const addresses = this.Provider.addresses.staking;
-        if (!addresses)
-            throw new Error("not all required addresses have been set in provider");
-        this.Provider = Provider;
-        this.addresses = addresses;
-        this.coinTypes = {
-            afSui: `${addresses.packages.afsui}::afsui::AFSUI`,
-        };
-        this.eventTypes = {
-            stakeRequest: this.stakeRequestEventType(),
-            unstakeRequest: this.unstakeRequestEventType(),
-            stakeSuccess: this.stakeSuccessEventType(),
-            unstakeSuccess: this.unstakeSuccessEventType(),
-            stakeFailed: this.stakeFailedEventType(),
-            afSuiMinted: this.afSuiMintedEventType(),
-        };
-    }
-}
-exports.StakingApiHelpers = StakingApiHelpers;
-_a = StakingApiHelpers;
-/////////////////////////////////////////////////////////////////////
-//// Constants
-/////////////////////////////////////////////////////////////////////
-StakingApiHelpers.constants = {
-    modules: {
-        interface: "interface",
-        actions: "actions",
-        staking: "staking",
-    },
-    eventNames: {
-        stakeRequest: "StakeWasRequestedEvent",
-        unstakeRequest: "WithdrawWasRequestedEvent",
-        stakeSuccess: "StakeSucceededEvent",
-        unstakeSuccess: "WithdrawSucceededEvent",
-        stakeFailed: "StakeWasFailedSUIReturnedEvent",
-        afSuiMinted: "AFSUIWasMintedToStakerAccountEvent",
-    },
-};
-/////////////////////////////////////////////////////////////////////
-//// Staking Positions Updating
-/////////////////////////////////////////////////////////////////////
-StakingApiHelpers.updateStakingPositionsFromEvent = (inputs) => {
-    const positions = inputs.stakingPositions;
-    const event = inputs.event;
-    let newPositions = [];
-    const unstakePositions = positions.filter(types_1.isUnstakePosition);
-    const newUnstakes = (0, types_1.isUnstakeEvent)(event)
-        ? _a.updateUnstakePositionsFromEvent({
-            event,
-            unstakePositions,
-        })
-        : unstakePositions;
-    const stakePositions = positions.filter(types_1.isStakePosition);
-    const newStakes = (0, types_1.isStakeEvent)(event)
-        ? _a.updateStakePositionsFromEvent({
-            event,
-            stakePositions,
-        })
-        : stakePositions;
-    newPositions = [...newUnstakes, ...newStakes];
-    return newPositions.sort((a, b) => { var _b, _c; return ((_b = b.timestamp) !== null && _b !== void 0 ? _b : 0) - ((_c = a.timestamp) !== null && _c !== void 0 ? _c : 0); });
-};
-/////////////////////////////////////////////////////////////////////
-//// Staking Positions Updating
-/////////////////////////////////////////////////////////////////////
-StakingApiHelpers.updateStakePositionsFromEvent = (inputs) => {
-    const foundPositionIndex = inputs.stakePositions.findIndex((pos) => pos.suiWrapperId === inputs.event.suiWrapperId);
-    if (foundPositionIndex < 0) {
-        if (inputs.event.type.includes(_a.constants.eventNames.stakeRequest))
-            return [
-                Object.assign(Object.assign({}, inputs.event), { state: "REQUEST", afSuiMintAmount: undefined }),
-                ...inputs.stakePositions,
-            ];
-        return inputs.stakePositions;
-    }
-    const foundStakePosition = inputs.stakePositions[foundPositionIndex];
-    let position = undefined;
-    if (inputs.event.type.includes(_a.constants.eventNames.afSuiMinted))
-        position = Object.assign(Object.assign({}, inputs.event), { state: "AFSUI_MINTED", validatorAddress: foundStakePosition.validatorAddress, epoch: foundStakePosition.epoch });
-    if (inputs.event.type.includes(_a.constants.eventNames.stakeSuccess))
-        position = Object.assign(Object.assign({}, inputs.event), { state: "SUCCESS", afSuiMintAmount: undefined, epoch: foundStakePosition.epoch });
-    if (inputs.event.type.includes(_a.constants.eventNames.stakeFailed))
-        position = Object.assign(Object.assign({}, inputs.event), { state: "FAILED", afSuiMintAmount: undefined, epoch: foundStakePosition.epoch });
-    if (!position)
-        return inputs.stakePositions;
-    let newStakePositions = [...inputs.stakePositions];
-    newStakePositions[foundPositionIndex] = position;
-    return newStakePositions;
-};
-StakingApiHelpers.updateUnstakePositionsFromEvent = (inputs) => {
-    const foundPositionIndex = inputs.unstakePositions.findIndex((pos) => pos.afSuiWrapperId === inputs.event.afSuiWrapperId);
-    if (foundPositionIndex < 0) {
-        if (inputs.event.type.includes(_a.constants.eventNames.unstakeRequest))
-            return [
-                Object.assign(Object.assign({}, inputs.event), { state: "REQUEST" }),
-                ...inputs.unstakePositions,
-            ];
-        return inputs.unstakePositions;
-    }
-    const foundPosition = inputs.unstakePositions[foundPositionIndex];
-    let position = undefined;
-    if (inputs.event.type.includes(_a.constants.eventNames.unstakeSuccess))
-        position = Object.assign(Object.assign({}, inputs.event), { state: "SUCCESS", epoch: foundPosition.epoch });
-    if (!position)
-        return inputs.unstakePositions;
-    let newPositions = [...inputs.unstakePositions];
-    newPositions[foundPositionIndex] = position;
-    return newPositions;
-};

package/dist/packages/sui/api/suiApiCasting.d.ts

@@ -1,3 +0,0 @@
-export declare class SuiApiCasting {
-}
-//# sourceMappingURL=suiApiCasting.d.ts.map

package/dist/packages/sui/api/suiApiCasting.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"suiApiCasting.d.ts","sourceRoot":"","sources":["../../../../src/packages/sui/api/suiApiCasting.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAa;CAAG"}

package/dist/packages/sui/api/suiApiCasting.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SuiApiCasting = void 0;
-class SuiApiCasting {
-}
-exports.SuiApiCasting = SuiApiCasting;

package/dist/packages/sui/api/suiApiCastingTypes.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=suiApiCastingTypes.d.ts.map

package/dist/packages/sui/api/suiApiCastingTypes.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"suiApiCastingTypes.d.ts","sourceRoot":"","sources":["../../../../src/packages/sui/api/suiApiCastingTypes.ts"],"names":[],"mappings":""}

package/dist/packages/sui/api/suiApiHelpers.d.ts

@@ -1,6 +0,0 @@
-import { AftermathApi } from "../../../general/providers/aftermathApi";
-export declare class SuiApiHelpers {
-    private readonly Provider;
-    constructor(Provider: AftermathApi);
-}
-//# sourceMappingURL=suiApiHelpers.d.ts.map

package/dist/packages/sui/api/suiApiHelpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"suiApiHelpers.d.ts","sourceRoot":"","sources":["../../../../src/packages/sui/api/suiApiHelpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,yCAAyC,CAAC;AAEvE,qBAAa,aAAa;IAKb,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,YAAY;CAGnD"}

package/dist/packages/sui/api/suiApiHelpers.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SuiApiHelpers = void 0;
-class SuiApiHelpers {
-    /////////////////////////////////////////////////////////////////////
-    //// Constructor
-    /////////////////////////////////////////////////////////////////////
-    constructor(Provider) {
-        this.Provider = Provider;
-        this.Provider = Provider;
-    }
-}
-exports.SuiApiHelpers = SuiApiHelpers;