@suilend/springsui-cli 1.0.0 → 1.0.2

package/sdk/src/index.d.ts

@@ -4,41 +4,45 @@ import { LiquidStakingInfo } from "./_generated/liquid_staking/liquid-staking/st
 export interface LiquidStakingObjectInfo {
     id: string;
     type: string;
+    weightHookId: string;
 }
 export declare class LstClient {
     liquidStakingObject: LiquidStakingObjectInfo;
     client: SuiClient;
     static initialize(client: SuiClient, liquidStakingObjectInfo: LiquidStakingObjectInfo): Promise<LstClient>;
+    static createNewLst(tx: Transaction, treasuryCap: string, coinType: string): TransactionObjectInput;
+    static getWeightHookAdminCapId(client: SuiClient, address: string, weightHookAdminCapId: string): Promise<string | null | undefined>;
     constructor(liquidStakingObject: LiquidStakingObjectInfo, client: SuiClient);
     getAdminCapId(address: string): Promise<string | null | undefined>;
-    getWeightHookAdminCapId(address: string): Promise<string | null | undefined>;
     mint(tx: Transaction, suiCoinId: TransactionObjectInput): {
         $kind: "NestedResult";
         NestedResult: [number, number];
     };
+    mintAndRebalanceAndSendToUser: (tx: Transaction, address: string, amount: string) => void;
     redeemLst(tx: Transaction, lstId: TransactionObjectInput): {
         $kind: "NestedResult";
         NestedResult: [number, number];
     };
+    redeemAndSendToUser(tx: Transaction, address: string, amount: string): Promise<void>;
     increaseValidatorStake(tx: Transaction, adminCapId: TransactionObjectInput, validatorAddress: string, suiAmount: number): void;
-    decreaseValidatorStake(tx: Transaction, adminCapId: TransactionObjectInput, validatorAddress: string, maxSuiAmount: number): void;
-    collectFees(tx: Transaction, adminCapId: TransactionObjectInput): {
+    decreaseValidatorStake(tx: Transaction, adminCapId: TransactionObjectInput, validatorAddress: string, targetUnstakeSuiAmount: bigint): void;
+    collectFees(tx: Transaction, weightHookAdminCapId: TransactionObjectInput): {
         $kind: "NestedResult";
         NestedResult: [number, number];
     };
-    updateFees(tx: Transaction, adminCapId: TransactionObjectInput, feeConfigArgs: FeeConfigArgs): void;
+    collectFeesAndSendToUser(tx: Transaction, weightHookAdminCapId: TransactionObjectInput, address: string): void;
+    updateFees(tx: Transaction, weightHookAdminCapId: TransactionObjectInput, feeConfigArgs: FeeConfigArgs): void;
     initializeWeightHook(tx: Transaction, adminCapId: TransactionObjectInput): {
         $kind: "NestedResult";
         NestedResult: [number, number];
     };
-    setValidatorAddressesAndWeights(tx: Transaction, weightHookId: TransactionObjectInput, weightHookAdminCap: TransactionObjectInput, validatorAddressesAndWeights: Map<string, number>): void;
+    setValidatorAddressesAndWeights(tx: Transaction, weightHookId: TransactionObjectInput, weightHookAdminCap: TransactionObjectInput, validatorAddressesAndWeights: Record<string, number>): void;
     rebalance(tx: Transaction, weightHookId: TransactionObjectInput): void;
 }
 export declare function fetchLiquidStakingInfo(info: LiquidStakingObjectInfo, client: SuiClient): Promise<LiquidStakingInfo<any>>;
-interface FeeConfigArgs {
+export interface FeeConfigArgs {
     mintFeeBps?: number;
     redeemFeeBps?: number;
-    spreadFee?: number;
+    spreadFeeBps?: number;
 }
 export declare function getSpringSuiApy(client: SuiClient): Promise<number | undefined>;
-export {};

package/sdk/src/index.js

@@ -44,7 +44,7 @@ const weightHookGenerated = __importStar(require("./_generated/liquid_staking/we
 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";
+const SPRING_SUI_UPGRADE_CAP_ID = "0x4dc657b6c0fe896f4b94fee1ceac96312dde0a36b94e799caaec30deb53dcd67";
 function getLatestPackageId(client, upgradeCapId) {
     return __awaiter(this, void 0, void 0, function* () {
         var _a;
@@ -66,17 +66,33 @@ class LstClient {
             return new LstClient(liquidStakingObjectInfo, client);
         });
     }
-    constructor(liquidStakingObject, client) {
-        this.liquidStakingObject = liquidStakingObject;
-        this.client = client;
+    static createNewLst(tx, treasuryCap, coinType) {
+        const [feeConfigBuilder] = (0, functions_1.newBuilder)(tx);
+        const [feeConfig] = (0, functions_1.toFeeConfig)(tx, feeConfigBuilder);
+        const [adminCap, liquidStakingInfo] = generated.createLst(tx, coinType, {
+            feeConfig,
+            lstTreasuryCap: treasuryCap,
+        });
+        tx.moveCall({
+            target: `0x2::transfer::public_share_object`,
+            typeArguments: [`${structs_1.LiquidStakingInfo.$typeName}<${coinType}>`],
+            arguments: [liquidStakingInfo],
+        });
+        const [weightHook, weightHookAdminCap] = weightHookGenerated.new_(tx, coinType, adminCap);
+        tx.moveCall({
+            target: `0x2::transfer::public_share_object`,
+            typeArguments: [`${structs_2.WeightHook.$typeName}<${coinType}>`],
+            arguments: [weightHook],
+        });
+        return weightHookAdminCap;
     }
-    getAdminCapId(address) {
+    static getWeightHookAdminCapId(client, address, weightHookAdminCapId) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
-            const res = (yield this.client.getOwnedObjects({
+            const res = (yield client.getOwnedObjects({
                 owner: address,
                 filter: {
-                    StructType: `${liquid_staking_1.PACKAGE_ID}::liquid_staking::AdminCap<${this.liquidStakingObject.type}>`,
+                    StructType: `${liquid_staking_1.PACKAGE_ID}::weight::WeightHookAdminCap<${weightHookAdminCapId}>`,
                 },
             })).data;
             if (res.length == 0) {
@@ -85,13 +101,23 @@ class LstClient {
             return (_a = res[0].data) === null || _a === void 0 ? void 0 : _a.objectId;
         });
     }
-    getWeightHookAdminCapId(address) {
+    constructor(liquidStakingObject, client) {
+        this.mintAndRebalanceAndSendToUser = (tx, address, amount) => {
+            const [sui] = tx.splitCoins(tx.gas, [BigInt(amount)]);
+            const rSui = this.mint(tx, sui);
+            tx.transferObjects([rSui], address);
+            this.rebalance(tx, this.liquidStakingObject.weightHookId);
+        };
+        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}::weight::WeightHookAdminCap<${this.liquidStakingObject.type}>`,
+                    StructType: `${liquid_staking_1.PACKAGE_ID}::liquid_staking::AdminCap<${this.liquidStakingObject.type}>`,
                 },
             })).data;
             if (res.length == 0) {
@@ -118,6 +144,22 @@ class LstClient {
         });
         return sui;
     }
+    redeemAndSendToUser(tx, address, amount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const coins = (yield this.client.getCoins({
+                owner: address,
+                coinType: this.liquidStakingObject.type,
+            })).data;
+            if (coins.length > 1) {
+                tx.mergeCoins(tx.object(coins[0].coinObjectId), coins.map((c) => tx.object(c.coinObjectId)).slice(1));
+            }
+            const [lst] = tx.splitCoins(tx.object(coins[0].coinObjectId), [
+                BigInt(amount),
+            ]);
+            const sui = this.redeemLst(tx, lst);
+            tx.transferObjects([sui], address);
+        });
+    }
     // admin functions
     increaseValidatorStake(tx, adminCapId, validatorAddress, suiAmount) {
         generated.increaseValidatorStake(tx, this.liquidStakingObject.type, {
@@ -128,24 +170,29 @@ class LstClient {
             suiAmount: BigInt(suiAmount),
         });
     }
-    decreaseValidatorStake(tx, adminCapId, validatorAddress, maxSuiAmount) {
+    decreaseValidatorStake(tx, adminCapId, validatorAddress, targetUnstakeSuiAmount) {
         generated.decreaseValidatorStake(tx, this.liquidStakingObject.type, {
             self: this.liquidStakingObject.id,
             adminCap: adminCapId,
             systemState: SUI_SYSTEM_STATE_ID,
             validatorAddress,
-            maxSuiAmount: BigInt(maxSuiAmount),
+            targetUnstakeSuiAmount,
         });
     }
-    collectFees(tx, adminCapId) {
-        const [sui] = generated.collectFees(tx, this.liquidStakingObject.type, {
-            self: this.liquidStakingObject.id,
+    collectFees(tx, weightHookAdminCapId) {
+        const [sui] = weightHookGenerated.collectFees(tx, this.liquidStakingObject.type, {
+            self: this.liquidStakingObject.weightHookId,
+            liquidStakingInfo: this.liquidStakingObject.id,
             systemState: SUI_SYSTEM_STATE_ID,
-            adminCap: adminCapId,
+            weightHookAdminCap: weightHookAdminCapId,
         });
         return sui;
     }
-    updateFees(tx, adminCapId, feeConfigArgs) {
+    collectFeesAndSendToUser(tx, weightHookAdminCapId, address) {
+        const sui = this.collectFees(tx, weightHookAdminCapId);
+        tx.transferObjects([sui], address);
+    }
+    updateFees(tx, weightHookAdminCapId, feeConfigArgs) {
         let [builder] = (0, functions_1.newBuilder)(tx);
         if (feeConfigArgs.mintFeeBps != null) {
             console.log(`Setting mint fee bps to ${feeConfigArgs.mintFeeBps}`);
@@ -161,16 +208,18 @@ class LstClient {
                 fee: BigInt(feeConfigArgs.redeemFeeBps),
             })[0];
         }
-        if (feeConfigArgs.spreadFee != null) {
+        if (feeConfigArgs.spreadFeeBps != null) {
+            console.log(`Setting spread fee bps to ${feeConfigArgs.spreadFeeBps}`);
             builder = (0, functions_1.setSpreadFeeBps)(tx, {
                 self: builder,
-                fee: BigInt(feeConfigArgs.spreadFee),
+                fee: BigInt(feeConfigArgs.spreadFeeBps),
             })[0];
         }
         const [feeConfig] = (0, functions_1.toFeeConfig)(tx, builder);
-        generated.updateFees(tx, this.liquidStakingObject.type, {
-            self: this.liquidStakingObject.id,
-            adminCap: adminCapId,
+        weightHookGenerated.updateFees(tx, this.liquidStakingObject.type, {
+            self: this.liquidStakingObject.weightHookId,
+            liquidStakingInfo: this.liquidStakingObject.id,
+            weightHookAdminCap: weightHookAdminCapId,
             feeConfig,
         });
     }
@@ -192,7 +241,7 @@ class LstClient {
             typeArguments: ["address", "u64"],
             arguments: [],
         });
-        for (const [validatorAddress, weight,] of validatorAddressesAndWeights.entries()) {
+        for (const [validatorAddress, weight] of Object.entries(validatorAddressesAndWeights)) {
             tx.moveCall({
                 target: `0x2::vec_map::insert`,
                 typeArguments: ["address", "u64"],