@suilend/springsui-cli 1.0.0

package/sdk/src/index.js

@@ -0,0 +1,234 @@
+"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 (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LstClient = void 0;
+exports.fetchLiquidStakingInfo = fetchLiquidStakingInfo;
+exports.getSpringSuiApy = getSpringSuiApy;
+const reified_1 = require("./_generated/_framework/reified");
+const liquid_staking_1 = require("./_generated/liquid_staking");
+const functions_1 = require("./_generated/liquid_staking/fees/functions");
+const generated = __importStar(require("./_generated/liquid_staking/liquid-staking/functions"));
+const structs_1 = require("./_generated/liquid_staking/liquid-staking/structs");
+const weightHookGenerated = __importStar(require("./_generated/liquid_staking/weight/functions"));
+const structs_2 = require("./_generated/liquid_staking/weight/structs");
+const SUI_SYSTEM_STATE_ID = "0x0000000000000000000000000000000000000000000000000000000000000005";
+const SUILEND_VALIDATOR_ADDRESS = "0xce8e537664ba5d1d5a6a857b17bd142097138706281882be6805e17065ecde89";
+const SPRING_SUI_UPGRADE_CAP_ID = "0x393ea4538463add6f405f2b1e3e6d896e17850975c772135843de26d14cd17c6";
+function getLatestPackageId(client, upgradeCapId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const object = yield client.getObject({
+            id: upgradeCapId,
+            options: {
+                showContent: true,
+            },
+        });
+        return ((_a = object.data) === null || _a === void 0 ? void 0 : _a.content).fields.package;
+    });
+}
+class LstClient {
+    static initialize(client, liquidStakingObjectInfo) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const publishedAt = yield getLatestPackageId(client, SPRING_SUI_UPGRADE_CAP_ID);
+            (0, liquid_staking_1.setPublishedAt)(publishedAt);
+            console.log(`Initialized LstClient with package ID: ${publishedAt}`);
+            return new LstClient(liquidStakingObjectInfo, client);
+        });
+    }
+    constructor(liquidStakingObject, client) {
+        this.liquidStakingObject = liquidStakingObject;
+        this.client = client;
+    }
+    getAdminCapId(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const res = (yield this.client.getOwnedObjects({
+                owner: address,
+                filter: {
+                    StructType: `${liquid_staking_1.PACKAGE_ID}::liquid_staking::AdminCap<${this.liquidStakingObject.type}>`,
+                },
+            })).data;
+            if (res.length == 0) {
+                return null;
+            }
+            return (_a = res[0].data) === null || _a === void 0 ? void 0 : _a.objectId;
+        });
+    }
+    getWeightHookAdminCapId(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const res = (yield this.client.getOwnedObjects({
+                owner: address,
+                filter: {
+                    StructType: `${liquid_staking_1.PACKAGE_ID}::weight::WeightHookAdminCap<${this.liquidStakingObject.type}>`,
+                },
+            })).data;
+            if (res.length == 0) {
+                return null;
+            }
+            return (_a = res[0].data) === null || _a === void 0 ? void 0 : _a.objectId;
+        });
+    }
+    // returns the lst object
+    mint(tx, suiCoinId) {
+        const [rSui] = generated.mint(tx, this.liquidStakingObject.type, {
+            self: this.liquidStakingObject.id,
+            sui: suiCoinId,
+            systemState: SUI_SYSTEM_STATE_ID,
+        });
+        return rSui;
+    }
+    // returns the sui coin
+    redeemLst(tx, lstId) {
+        const [sui] = generated.redeem(tx, this.liquidStakingObject.type, {
+            self: this.liquidStakingObject.id,
+            systemState: SUI_SYSTEM_STATE_ID,
+            lst: lstId,
+        });
+        return sui;
+    }
+    // admin functions
+    increaseValidatorStake(tx, adminCapId, validatorAddress, suiAmount) {
+        generated.increaseValidatorStake(tx, this.liquidStakingObject.type, {
+            self: this.liquidStakingObject.id,
+            adminCap: adminCapId,
+            systemState: SUI_SYSTEM_STATE_ID,
+            validatorAddress,
+            suiAmount: BigInt(suiAmount),
+        });
+    }
+    decreaseValidatorStake(tx, adminCapId, validatorAddress, maxSuiAmount) {
+        generated.decreaseValidatorStake(tx, this.liquidStakingObject.type, {
+            self: this.liquidStakingObject.id,
+            adminCap: adminCapId,
+            systemState: SUI_SYSTEM_STATE_ID,
+            validatorAddress,
+            maxSuiAmount: BigInt(maxSuiAmount),
+        });
+    }
+    collectFees(tx, adminCapId) {
+        const [sui] = generated.collectFees(tx, this.liquidStakingObject.type, {
+            self: this.liquidStakingObject.id,
+            systemState: SUI_SYSTEM_STATE_ID,
+            adminCap: adminCapId,
+        });
+        return sui;
+    }
+    updateFees(tx, adminCapId, feeConfigArgs) {
+        let [builder] = (0, functions_1.newBuilder)(tx);
+        if (feeConfigArgs.mintFeeBps != null) {
+            console.log(`Setting mint fee bps to ${feeConfigArgs.mintFeeBps}`);
+            builder = (0, functions_1.setSuiMintFeeBps)(tx, {
+                self: builder,
+                fee: BigInt(feeConfigArgs.mintFeeBps),
+            })[0];
+        }
+        if (feeConfigArgs.redeemFeeBps != null) {
+            console.log(`Setting redeem fee bps to ${feeConfigArgs.redeemFeeBps}`);
+            builder = (0, functions_1.setRedeemFeeBps)(tx, {
+                self: builder,
+                fee: BigInt(feeConfigArgs.redeemFeeBps),
+            })[0];
+        }
+        if (feeConfigArgs.spreadFee != null) {
+            builder = (0, functions_1.setSpreadFeeBps)(tx, {
+                self: builder,
+                fee: BigInt(feeConfigArgs.spreadFee),
+            })[0];
+        }
+        const [feeConfig] = (0, functions_1.toFeeConfig)(tx, builder);
+        generated.updateFees(tx, this.liquidStakingObject.type, {
+            self: this.liquidStakingObject.id,
+            adminCap: adminCapId,
+            feeConfig,
+        });
+    }
+    // weight hook functions
+    initializeWeightHook(tx, adminCapId) {
+        const [weightHook, weightHookAdminCap] = weightHookGenerated.new_(tx, this.liquidStakingObject.type, adminCapId);
+        tx.moveCall({
+            target: `0x2::transfer::public_share_object`,
+            typeArguments: [
+                `${structs_2.WeightHook.$typeName}<${this.liquidStakingObject.type}>`,
+            ],
+            arguments: [weightHook],
+        });
+        return weightHookAdminCap;
+    }
+    setValidatorAddressesAndWeights(tx, weightHookId, weightHookAdminCap, validatorAddressesAndWeights) {
+        const [vecMap] = tx.moveCall({
+            target: `0x2::vec_map::empty`,
+            typeArguments: ["address", "u64"],
+            arguments: [],
+        });
+        for (const [validatorAddress, weight,] of validatorAddressesAndWeights.entries()) {
+            tx.moveCall({
+                target: `0x2::vec_map::insert`,
+                typeArguments: ["address", "u64"],
+                arguments: [
+                    vecMap,
+                    tx.pure.address(validatorAddress),
+                    tx.pure.u64(weight),
+                ],
+            });
+        }
+        weightHookGenerated.setValidatorAddressesAndWeights(tx, this.liquidStakingObject.type, {
+            self: weightHookId,
+            weightHookAdminCap,
+            validatorAddressesAndWeights: vecMap,
+        });
+    }
+    rebalance(tx, weightHookId) {
+        weightHookGenerated.rebalance(tx, this.liquidStakingObject.type, {
+            self: weightHookId,
+            systemState: SUI_SYSTEM_STATE_ID,
+            liquidStakingInfo: this.liquidStakingObject.id,
+        });
+    }
+}
+exports.LstClient = LstClient;
+// user functions
+function fetchLiquidStakingInfo(info, client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        return structs_1.LiquidStakingInfo.fetch(client, (0, reified_1.phantom)(info.type), info.id);
+    });
+}
+// only works for sSui
+function getSpringSuiApy(client) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const res = yield client.getValidatorsApy();
+        const validatorApy = res.apys.find((apy) => apy.address == SUILEND_VALIDATOR_ADDRESS);
+        return validatorApy === null || validatorApy === void 0 ? void 0 : validatorApy.apy;
+    });
+}