@reflectmoney/stable.ts 1.1.8 → 1.2.0

package/dist/classes/Stablecoin.d.ts

@@ -34,6 +34,7 @@ export declare abstract class Stablecoin<T extends Controller> {
     driftClient?: DriftClient;
     /** Lookup table with stablecoin-specific accounts. */
     lookupTable: PublicKey;
+    isPermissioned: boolean;
     /**
      * Loads the controller account for this stablecoin.
      *
@@ -216,4 +217,20 @@ export declare abstract class Stablecoin<T extends Controller> {
      * @returns Promise resolving to the USD exchange rate as a number
      */
     abstract getReceiptUsdExchangeRate(): Promise<number>;
+    /**
+     * Abstract method to simulate mint math and get the quote for a mint operation.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @param amount - Amount of base tokens (e.g., USDC) to deposit
+     * @returns Promise resolving to the amount of receipt tokens that would be minted
+     */
+    abstract simulateMintMath(amount: BN): Promise<BN>;
+    /**
+     * Abstract method to simulate redeem math and get the quote for a redeem operation.
+     * Must be implemented by concrete stablecoin classes.
+     *
+     * @param amount - Amount of receipt tokens to redeem
+     * @returns Promise resolving to the amount of base tokens that would be returned
+     */
+    abstract simulateRedeemMath(amount: BN): Promise<BN>;
 }

package/dist/stablecoins/LstStablecoin.d.ts

@@ -100,4 +100,6 @@ export declare class LstStablecoin extends Stablecoin<DriftLstController> {
      */
     getBaseUsdExchangeRate(): Promise<number>;
     getReceiptUsdExchangeRate(): Promise<number>;
+    simulateMintMath(): Promise<BN>;
+    simulateRedeemMath(): Promise<BN>;
 }

package/dist/stablecoins/LstStablecoin.js

@@ -325,5 +325,15 @@ class LstStablecoin extends Stablecoin_1.Stablecoin {
             return exchangeRate;
         });
     }
+    simulateMintMath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new bn_js_1.default(0);
+        });
+    }
+    simulateRedeemMath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new bn_js_1.default(0);
+        });
+    }
 }
 exports.LstStablecoin = LstStablecoin;

package/dist/stablecoins/UsdcPlusStablecoin.d.ts

@@ -45,7 +45,7 @@ export declare class UsdcPlusStablecoin extends Stablecoin<DriftUsdcController>
      * @param signer - Public key of the signer
      * @returns Promise resolving to the constructed accounts object of type T
      */
-    constructAccounts<T>(signer: PublicKey): Promise<T>;
+    constructAccounts<T>(signer: PublicKey, permissions?: boolean): Promise<T>;
     /**
      * Constructs remaining accounts for transactions.
      * Currently returns an empty array as no additional accounts are needed.
@@ -83,4 +83,44 @@ export declare class UsdcPlusStablecoin extends Stablecoin<DriftUsdcController>
      */
     getBaseUsdExchangeRate(): Promise<number>;
     getReceiptUsdExchangeRate(): Promise<number>;
+    /**
+     * Math helper function that calculates receipt tokens to issue for a given deposit amount.
+     * Mirrors the compute_receipt_token function from Rust.
+     *
+     * @param deposit - Amount of USDC being deposited
+     * @param depositedVault - Current deposited vault value
+     * @param receiptTokenSupply - Current effective supply of receipt tokens
+     * @returns Amount of receipt tokens to issue
+     */
+    private computeReceiptToken;
+    /**
+     * Math helper function that calculates base token amount to return for a given receipt token burn.
+     * Mirrors the compute_base_token function from Rust.
+     *
+     * @param receipt - Amount of receipt tokens being burned
+     * @param depositedVault - Current deposited vault value
+     * @param receiptTokenSupply - Current effective supply of receipt tokens
+     * @returns Amount of base tokens (USDC) to return
+     */
+    private computeBaseToken;
+    /**
+     * Processes a user deposit: calculates receipt tokens to issue and updates internal accounting.
+     * Mirrors the process_deposit function from Rust AutoCompound.
+     *
+     * @param usdcDeposited - Amount of USDC being deposited
+     * @returns Amount of receipt tokens to issue
+     * @throws Error if USDC input is zero
+     */
+    private processDeposit;
+    /**
+     * Processes a user redemption: calculates USDC to return and updates internal accounting.
+     * Mirrors the process_redemption function from Rust AutoCompound.
+     *
+     * @param receiptTokensBurned - Amount of receipt tokens being burned
+     * @returns Amount of USDC to return to user
+     * @throws Error if receipt token input is zero
+     */
+    private processRedemption;
+    simulateMintMath(usdcAmount: BN): Promise<BN>;
+    simulateRedeemMath(receiptTokens: BN): Promise<BN>;
 }

package/dist/stablecoins/UsdcPlusStablecoin.js

@@ -49,6 +49,7 @@ class UsdcPlusStablecoin extends Stablecoin_1.Stablecoin {
             wallet: new nodewallet_1.default(web3_js_1.Keypair.generate()),
             authority: this.controllerKey
         });
+        this.isPermissioned = true;
         // Otherwise has to be loaded first.
         if (stablecoinMintOverride)
             this.stablecoinMint = stablecoinMintOverride;
@@ -135,8 +136,8 @@ class UsdcPlusStablecoin extends Stablecoin_1.Stablecoin {
      * @param signer - Public key of the signer
      * @returns Promise resolving to the constructed accounts object of type T
      */
-    constructAccounts(signer) {
-        return __awaiter(this, void 0, void 0, function* () {
+    constructAccounts(signer_1) {
+        return __awaiter(this, arguments, void 0, function* (signer, permissions = this.isPermissioned) {
             const userAccount = (0, sdk_1.getUserAccountPublicKeySync)(constants_1.DRIFT_PROGRAM_ID, this.controllerKey);
             const userStats = (0, sdk_1.getUserStatsAccountPublicKey)(constants_1.DRIFT_PROGRAM_ID, this.controllerKey);
             const anchorRemainingAccounts = yield this.constructRemainingAccounts();
@@ -165,7 +166,7 @@ class UsdcPlusStablecoin extends Stablecoin_1.Stablecoin {
                 userReceiptAta,
                 userStats,
                 userUsdcAta,
-                adminPermissions: null,
+                adminPermissions: permissions ? classes_1.PdaClient.derivePermissions(signer) : null,
                 anchorRemainingAccounts,
                 systemProgram: web3_js_1.SystemProgram.programId,
                 tokenProgram: spl_token_1.TOKEN_PROGRAM_ID
@@ -208,7 +209,7 @@ class UsdcPlusStablecoin extends Stablecoin_1.Stablecoin {
      */
     mint(signer, amount, minimumReceived) {
         return __awaiter(this, void 0, void 0, function* () {
-            const accounts = yield this.constructAccounts(signer);
+            const accounts = yield this.constructAccounts(signer, true);
             const ix = (0, reflect_main_1.createMintDriftS1Instruction)(accounts, {
                 minUsdcAmount: minimumReceived,
                 usdcAmount: amount
@@ -224,7 +225,7 @@ class UsdcPlusStablecoin extends Stablecoin_1.Stablecoin {
      */
     redeem(signer, amount, minimumReceived) {
         return __awaiter(this, void 0, void 0, function* () {
-            const accounts = yield this.constructAccounts(signer);
+            const accounts = yield this.constructAccounts(signer, true);
             const ix = (0, reflect_main_1.createRedeemDriftS1Instruction)(accounts, {
                 canChill: false,
                 minLstRedeem: minimumReceived,
@@ -280,5 +281,91 @@ class UsdcPlusStablecoin extends Stablecoin_1.Stablecoin {
             return this.getBaseUsdExchangeRate();
         });
     }
+    /**
+     * Math helper function that calculates receipt tokens to issue for a given deposit amount.
+     * Mirrors the compute_receipt_token function from Rust.
+     *
+     * @param deposit - Amount of USDC being deposited
+     * @param depositedVault - Current deposited vault value
+     * @param receiptTokenSupply - Current effective supply of receipt tokens
+     * @returns Amount of receipt tokens to issue
+     */
+    computeReceiptToken(deposit, depositedVault, receiptTokenSupply) {
+        // If supply is 0, return deposit amount (1:1 ratio for first deposit)
+        if (receiptTokenSupply.isZero()) {
+            return deposit;
+        }
+        // receipt_tokens = (deposit * receipt_token_supply) / deposited_vault
+        return deposit.mul(receiptTokenSupply).div(depositedVault);
+    }
+    /**
+     * Math helper function that calculates base token amount to return for a given receipt token burn.
+     * Mirrors the compute_base_token function from Rust.
+     *
+     * @param receipt - Amount of receipt tokens being burned
+     * @param depositedVault - Current deposited vault value
+     * @param receiptTokenSupply - Current effective supply of receipt tokens
+     * @returns Amount of base tokens (USDC) to return
+     */
+    computeBaseToken(receipt, depositedVault, receiptTokenSupply) {
+        // usdc_amount = (receipt * deposited_vault) / receipt_token_supply
+        return receipt.mul(depositedVault).div(receiptTokenSupply);
+    }
+    /**
+     * Processes a user deposit: calculates receipt tokens to issue and updates internal accounting.
+     * Mirrors the process_deposit function from Rust AutoCompound.
+     *
+     * @param usdcDeposited - Amount of USDC being deposited
+     * @returns Amount of receipt tokens to issue
+     * @throws Error if USDC input is zero
+     */
+    processDeposit(usdcDeposited) {
+        if (usdcDeposited.isZero()) {
+            throw new Error("USDC input can not be zero");
+        }
+        if (!this.controller || !this.controller.compounder) {
+            throw new Error("Controller not loaded. Call load() first.");
+        }
+        const autocompound = this.controller.compounder;
+        // Calculate receipt tokens to issue
+        const receiptTokens = this.computeReceiptToken(usdcDeposited, new bn_js_1.default(autocompound.depositedVaultValue), new bn_js_1.default(autocompound.effectiveSupply));
+        return receiptTokens;
+    }
+    /**
+     * Processes a user redemption: calculates USDC to return and updates internal accounting.
+     * Mirrors the process_redemption function from Rust AutoCompound.
+     *
+     * @param receiptTokensBurned - Amount of receipt tokens being burned
+     * @returns Amount of USDC to return to user
+     * @throws Error if receipt token input is zero
+     */
+    processRedemption(receiptTokensBurned) {
+        if (receiptTokensBurned.isZero()) {
+            throw new Error("LP input can not be zero");
+        }
+        if (!this.controller || !this.controller.compounder) {
+            throw new Error("Controller not loaded. Call load() first.");
+        }
+        const autocompound = this.controller.compounder;
+        // Calculate USDC to return
+        const usdcAmount = this.computeBaseToken(receiptTokensBurned, new bn_js_1.default(autocompound.depositedVaultValue), new bn_js_1.default(autocompound.effectiveSupply));
+        return usdcAmount;
+    }
+    simulateMintMath(usdcAmount) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.controller) {
+                yield this.load();
+            }
+            return this.processDeposit(usdcAmount);
+        });
+    }
+    simulateRedeemMath(receiptTokens) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.controller) {
+                yield this.load();
+            }
+            return this.processRedemption(receiptTokens);
+        });
+    }
 }
 exports.UsdcPlusStablecoin = UsdcPlusStablecoin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reflectmoney/stable.ts",
-  "version": "1.1.8",
+  "version": "1.2.0",
   "type": "commonjs",
   "author": "stablecoinjesus @ Palindrome Engineering",
   "repository": {