stable-layer-sdk 3.0.0 → 3.1.0

package/dist/esm/index.mjs

@@ -2,7 +2,8 @@
 import { BucketClient } from "@bucket-protocol/sdk";
 import { bcs as bcs24 } from "@mysten/sui/bcs";
 import { SuiGrpcClient } from "@mysten/sui/grpc";
-import { coinWithBalance } from "@mysten/sui/transactions";
+import { coinWithBalance, Transaction } from "@mysten/sui/transactions";
+import { normalizeStructTag, SUI_CLOCK_OBJECT_ID } from "@mysten/sui/utils";
 
 // src/generated/utils/index.ts
 import { bcs, TypeTagSerializer, BcsStruct, BcsEnum, BcsTuple } from "@mysten/sui/bcs";
@@ -251,6 +252,22 @@ var FactoryCap = new MoveStruct({ name: `${$moduleName9}::FactoryCap`, fields: {
   id: UID,
   factory_id: bcs8.Address
 } });
+function setMaxSupply(options) {
+  const packageAddress = options.package ?? "@local-pkg/stable_factory.move";
+  const argumentsTypes = [
+    `${packageAddress}::stable_layer::StableRegistry`,
+    `${packageAddress}::stable_layer::FactoryCap<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    "u64"
+  ];
+  const parameterNames = ["registry", "FactoryCap", "maxSupply"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "stable_layer",
+    function: "set_max_supply",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
 function mint(options) {
   const packageAddress = options.package ?? "@local-pkg/stable_factory.move";
   const argumentsTypes = [
@@ -590,29 +607,128 @@ function release(options) {
   });
 }
 
+// src/libs/constants.mainnet.ts
+var STABLE_REGISTRY_MAINNET_ALT = "0x213f4d584c0770f455bb98c94a4ee5ea9ddbc3d4ebb98a0ad6d093eb6da41642";
+var STABLE_LAYER_PACKAGE_MAINNET_ALT = "0x41e25d09e20cf3bc43fe321e51ef178fac419ae47b783a7161982158fc9f17d6";
+var MAINNET = {
+  STABLE_VAULT: "0x65f38160110cd6859d05f338ff54b4f462883bb6f87c667a65c0fb0e537410a7",
+  USDC_TYPE: "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC",
+  STABLE_LP_TYPE: "0xb75744fadcbfc174627567ca29645d0af8f6e6fd01b6f57c75a08cd3fb97c567::lake_usdc::LakeUSDC",
+  YUSDB_TYPE: "0xac718b4b672d7f461fe7e86847166ff9c23cadba217397f0848a95bdea1f1051::yesusdb::YesUSDB",
+  STABLE_LAYER_PACKAGE_ID: "0xa4a78d8d3d1df62fb81d10068142e79b0d30ad4e3f578060487e36ed9ea764da",
+  STABLE_REGISTRY_MAINNET_ALT,
+  STABLE_LAYER_PACKAGE_MAINNET_ALT,
+  STABLE_VAULT_FARM_PACKAGE_ID: "0x00d31ddaa73a56abcc3e2d885ac1e1d90f9ae0e38bbef2ba2923550c8250de4d",
+  SAVING_TYPE: "0x38f61c75fa8407140294c84167dd57684580b55c3066883b48dedc344b1cde1e::susdb::SUSDB",
+  YIELD_VAULT: "0x0a7f6325253157cd437812fea0ceee9a6b96f2ec5eac410da6df39558ff3a4d1",
+  STABLE_REGISTRY: "0x213f4d584c0770f455bb98c94a4ee5ea9ddbc3d4ebb98a0ad6d093eb6da41642",
+  STABLE_VAULT_FARM: "0xe958b7d102b33bf3c09addb0e2cdff102ff2c93afe407ec5c2a541e8959a650c",
+  YIELD_USDB_PACKAGE_ID: "0x3dcbf82f7e3b80ed65cee596612602a6c7e78c71fd40f6455b40ad033ed04786"
+};
+var STABLE_VAULT_FARM_ENTITY_TYPE_MAINNET = `0xc1025fe014b03d33b207b5afb0ba04293be87fab438c1418a26a75c2fe05c223::stable_vault_farm::StableVaultFarmEntity<${MAINNET.STABLE_LP_TYPE}, ${MAINNET.USDC_TYPE}>`;
+
+// src/libs/constants.testnet.ts
+var TESTNET_USDC = "0xa1ec7fc00a6f40db9693ad1415d0c193ad3906494428cf252621037bd7117e29::usdc::USDC";
+var MOCK_FARM_PACKAGE_ID_TESTNET = "0x3a55ec8fabe5f3e982908ed3a7c3065f26e83ab226eb8d3450177dbaac25878b";
+var MOCK_FARM_ORIGINAL_PACKAGE_ID_TESTNET = "0x673d4118c17de717b0b90c326f8f52f87b5fff8678f513edd2ae575a55175954";
+var MOCK_FARM_REGISTRY_TESTNET = "0xc3e8d2e33e36f6a4b5c199fe2dde3ba6dc29e7af8dd045c86e62d7c21f374d02";
+var MOCK_USDB_TYPE_TESTNET = `${MOCK_FARM_ORIGINAL_PACKAGE_ID_TESTNET}::usdb::USDB`;
+var TESTNET = {
+  STABLE_LAYER_PACKAGE_ID: "0x9c248c80c3a757167780f17e0c00a4d293280be7276f1b81a153f6e47d2567c9",
+  STABLE_REGISTRY: "0xfa0fd96e0fbc07dc6bdc23cc1ac5b4c0056f4b469b9db0a70b6ea01c14a4c7b5",
+  USDC_TYPE: TESTNET_USDC,
+  STABLE_VAULT_FARM_ENTITY_TYPE: `${MOCK_FARM_ORIGINAL_PACKAGE_ID_TESTNET}::farm::MockFarmEntity`,
+  MOCK_FARM_PACKAGE_ID: MOCK_FARM_PACKAGE_ID_TESTNET,
+  MOCK_FARM_REGISTRY: MOCK_FARM_REGISTRY_TESTNET,
+  MOCK_USDB_TYPE: MOCK_USDB_TYPE_TESTNET,
+  STABLE_VAULT: "",
+  STABLE_LP_TYPE: "",
+  YUSDB_TYPE: "",
+  STABLE_VAULT_FARM_PACKAGE_ID: "",
+  SAVING_TYPE: "",
+  YIELD_VAULT: "",
+  STABLE_VAULT_FARM: "",
+  YIELD_USDB_PACKAGE_ID: ""
+};
+var STABLE_VAULT_FARM_ENTITY_TYPE_TESTNET = TESTNET.STABLE_VAULT_FARM_ENTITY_TYPE;
+
 // src/libs/constants.ts
-var STABLE_VAULT = "0x65f38160110cd6859d05f338ff54b4f462883bb6f87c667a65c0fb0e537410a7";
-var USDC_TYPE = "0xdba34672e30cb065b1f93e3ab55318768fd6fef66c15942c9f7cb846e2f900e7::usdc::USDC";
-var STABLE_LP_TYPE = "0xb75744fadcbfc174627567ca29645d0af8f6e6fd01b6f57c75a08cd3fb97c567::lake_usdc::LakeUSDC";
-var YUSDB_TYPE = "0xac718b4b672d7f461fe7e86847166ff9c23cadba217397f0848a95bdea1f1051::yesusdb::YesUSDB";
-var STABLE_LAYER_PACKAGE_ID = "0xa4a78d8d3d1df62fb81d10068142e79b0d30ad4e3f578060487e36ed9ea764da";
-var STABLE_VAULT_FARM_PACKAGE_ID = "0x00d31ddaa73a56abcc3e2d885ac1e1d90f9ae0e38bbef2ba2923550c8250de4d";
-var SAVING_TYPE = "0x38f61c75fa8407140294c84167dd57684580b55c3066883b48dedc344b1cde1e::susdb::SUSDB";
-var YIELD_VAULT = "0x0a7f6325253157cd437812fea0ceee9a6b96f2ec5eac410da6df39558ff3a4d1";
-var STABLE_REGISTRY = "0x213f4d584c0770f455bb98c94a4ee5ea9ddbc3d4ebb98a0ad6d093eb6da41642";
-var STABLE_VAULT_FARM_ENTITY_TYPE = `0xc1025fe014b03d33b207b5afb0ba04293be87fab438c1418a26a75c2fe05c223::stable_vault_farm::StableVaultFarmEntity<${STABLE_LP_TYPE}, ${USDC_TYPE}>`;
-var STABLE_VAULT_FARM = "0xe958b7d102b33bf3c09addb0e2cdff102ff2c93afe407ec5c2a541e8959a650c";
-var YIELD_USDB_PACKAGE_ID = "0x3dcbf82f7e3b80ed65cee596612602a6c7e78c71fd40f6455b40ad033ed04786";
+function getMainnetConstants() {
+  return {
+    ...MAINNET,
+    STABLE_VAULT_FARM_ENTITY_TYPE: STABLE_VAULT_FARM_ENTITY_TYPE_MAINNET,
+    MOCK_FARM_PACKAGE_ID: "",
+    MOCK_FARM_REGISTRY: "",
+    MOCK_USDB_TYPE: ""
+  };
+}
+function getTestnetConstants() {
+  return {
+    ...TESTNET,
+    STABLE_VAULT_FARM_ENTITY_TYPE: STABLE_VAULT_FARM_ENTITY_TYPE_TESTNET
+  };
+}
+function getConstants(network) {
+  return network === "testnet" ? getTestnetConstants() : getMainnetConstants();
+}
+var STABLE_VAULT = MAINNET.STABLE_VAULT;
+var USDC_TYPE = MAINNET.USDC_TYPE;
+var STABLE_LP_TYPE = MAINNET.STABLE_LP_TYPE;
+var YUSDB_TYPE = MAINNET.YUSDB_TYPE;
+var STABLE_LAYER_PACKAGE_ID = MAINNET.STABLE_LAYER_PACKAGE_ID;
+var STABLE_VAULT_FARM_PACKAGE_ID = MAINNET.STABLE_VAULT_FARM_PACKAGE_ID;
+var SAVING_TYPE = MAINNET.SAVING_TYPE;
+var YIELD_VAULT = MAINNET.YIELD_VAULT;
+var STABLE_REGISTRY = MAINNET.STABLE_REGISTRY;
+var STABLE_VAULT_FARM = MAINNET.STABLE_VAULT_FARM;
+var YIELD_USDB_PACKAGE_ID = MAINNET.YIELD_USDB_PACKAGE_ID;
+var STABLE_VAULT_FARM_ENTITY_TYPE = STABLE_VAULT_FARM_ENTITY_TYPE_MAINNET;
 
 // src/index.ts
-var StableLayerClient = class {
-  constructor(config) {
-    this.bucketClient = new BucketClient({ network: config.network });
-    this.suiClient = new SuiGrpcClient({
+var StableLayerClient = class _StableLayerClient {
+  static getConstants(network) {
+    return getConstants(network);
+  }
+  getConstants() {
+    return getConstants(this.network);
+  }
+  static async initialize(config) {
+    const defaultBaseUrl = `https://fullnode.${config.network}.sui.io:443`;
+    const baseUrl = config.baseUrl ?? process.env.SUI_GRPC_URL ?? defaultBaseUrl;
+    const suiClient = config.suiClient ?? new SuiGrpcClient({
       network: config.network,
-      baseUrl: `https://fullnode.${config.network}.sui.io:443`
+      baseUrl
     });
+    const bucketClient = await BucketClient.initialize({
+      network: config.network,
+      suiClient,
+      configObjectId: config.configObjectId,
+      configOverrides: config.configOverrides
+    });
+    return new _StableLayerClient(config, bucketClient, suiClient);
+  }
+  constructor(config, bucketClient, suiClient) {
+    this.bucketClient = bucketClient;
+    this.suiClient = suiClient;
     this.sender = config.sender;
+    this.network = config.network;
+    this.mockFarmRegistryId = config.mockFarmRegistryId;
+    this.mockFarmPackageId = config.mockFarmPackageId;
+    this.mockUsdbCoinType = config.mockUsdbCoinType;
+  }
+  getMockFarmPackageId() {
+    const c = this.getConstants();
+    const id = (this.mockFarmPackageId ?? c.MOCK_FARM_PACKAGE_ID)?.trim();
+    if (!id) {
+      throw new Error(
+        "StableLayerClient: missing mock farm package (set mockFarmPackageId or MOCK_FARM_PACKAGE_ID in testnet constants)."
+      );
+    }
+    return id;
+  }
+  getMockFarmEntityType() {
+    const c = this.getConstants();
+    return c.STABLE_VAULT_FARM_ENTITY_TYPE || `${this.getMockFarmPackageId()}::farm::MockFarmEntity`;
   }
   async buildMintTx({
     tx,
@@ -622,38 +738,69 @@ var StableLayerClient = class {
     autoTransfer = true
   }) {
     tx.setSender(sender ?? this.sender);
+    const constants = this.getConstants();
+    if (this.network === "testnet") {
+      const farmRegistry = this.mockFarmRegistryId ?? constants.MOCK_FARM_REGISTRY;
+      const pkg = this.getMockFarmPackageId();
+      if (!farmRegistry) {
+        throw new Error(
+          "buildMintTx (testnet): missing mock farm registry (mockFarmRegistryId or MOCK_FARM_REGISTRY)."
+        );
+      }
+      const stableTag = normalizeStructTag(stableCoinType);
+      const usdTag = normalizeStructTag(constants.USDC_TYPE);
+      const farmEntityTag = normalizeStructTag(this.getMockFarmEntityType());
+      const [stableCoin2, loan2] = mint({
+        package: constants.STABLE_LAYER_PACKAGE_ID,
+        arguments: {
+          registry: constants.STABLE_REGISTRY,
+          uCoin: usdcCoin
+        },
+        typeArguments: [stableTag, usdTag, farmEntityTag]
+      })(tx);
+      tx.moveCall({
+        target: `${pkg}::farm::receive`,
+        typeArguments: [stableTag, usdTag],
+        arguments: [tx.object(farmRegistry), loan2, tx.object(SUI_CLOCK_OBJECT_ID)]
+      });
+      if (autoTransfer) {
+        tx.transferObjects([stableCoin2], sender ?? this.sender);
+        return;
+      }
+      return stableCoin2;
+    }
     const [stableCoin, loan] = mint({
-      package: STABLE_LAYER_PACKAGE_ID,
+      package: constants.STABLE_LAYER_PACKAGE_ID,
       arguments: {
-        registry: STABLE_REGISTRY,
+        registry: constants.STABLE_REGISTRY,
         uCoin: usdcCoin
       },
-      typeArguments: [stableCoinType, USDC_TYPE, STABLE_VAULT_FARM_ENTITY_TYPE]
+      typeArguments: [stableCoinType, constants.USDC_TYPE, constants.STABLE_VAULT_FARM_ENTITY_TYPE]
     })(tx);
     const [uPrice] = await this.bucketClient.aggregatePrices(tx, {
-      coinTypes: [USDC_TYPE]
+      coinTypes: [constants.USDC_TYPE]
     });
     const depositResponse = receive({
-      package: STABLE_VAULT_FARM_PACKAGE_ID,
+      package: constants.STABLE_VAULT_FARM_PACKAGE_ID,
       typeArguments: [
-        STABLE_LP_TYPE,
-        USDC_TYPE,
+        constants.STABLE_LP_TYPE,
+        constants.USDC_TYPE,
         stableCoinType,
-        YUSDB_TYPE,
-        SAVING_TYPE
+        constants.YUSDB_TYPE,
+        constants.SAVING_TYPE
       ],
       arguments: {
-        farm: STABLE_VAULT_FARM,
+        farm: constants.STABLE_VAULT_FARM,
         loan,
-        stableVault: STABLE_VAULT,
-        usdbTreasury: this.bucketClient.treasury(tx),
-        psmPool: this.getBucketPSMPool(tx),
-        savingPool: this.getBucketSavingPool(tx),
-        yieldVault: YIELD_VAULT,
+        stableVault: constants.STABLE_VAULT,
+        usdbTreasury: await Promise.resolve(this.bucketClient.treasury(tx)),
+        psmPool: await this.getBucketPSMPool(tx),
+        savingPool: await this.getBucketSavingPool(tx),
+        yieldVault: constants.YIELD_VAULT,
         uPrice
       }
     })(tx);
-    this.checkResponse({ tx, response: depositResponse, type: "deposit" });
+    await this.checkResponse({ tx, response: depositResponse, type: "deposit" });
     if (autoTransfer) {
       tx.transferObjects([stableCoin], sender ?? this.sender);
       return;
@@ -682,46 +829,84 @@ var StableLayerClient = class {
       ) : amount,
       type: stableCoinType
     });
-    this.releaseRewards(tx);
+    const constants = this.getConstants();
+    if (this.network === "testnet") {
+      const farmRegistry = this.mockFarmRegistryId ?? constants.MOCK_FARM_REGISTRY;
+      const pkg = this.getMockFarmPackageId();
+      if (!farmRegistry) {
+        throw new Error(
+          "buildBurnTx (testnet): missing mock farm registry (mockFarmRegistryId or MOCK_FARM_REGISTRY)."
+        );
+      }
+      const stableTag = normalizeStructTag(stableCoinType);
+      const usdTag = normalizeStructTag(constants.USDC_TYPE);
+      const burnRequest2 = requestBurn({
+        package: constants.STABLE_LAYER_PACKAGE_ID,
+        arguments: {
+          registry: constants.STABLE_REGISTRY,
+          stableCoin: btcUsdCoin
+        },
+        typeArguments: [stableTag, usdTag]
+      })(tx);
+      tx.moveCall({
+        target: `${pkg}::farm::pay`,
+        typeArguments: [stableTag, usdTag],
+        arguments: [tx.object(farmRegistry), tx.object(SUI_CLOCK_OBJECT_ID), burnRequest2]
+      });
+      const usdcCoin2 = fulfillBurn({
+        package: constants.STABLE_LAYER_PACKAGE_ID,
+        arguments: {
+          registry: constants.STABLE_REGISTRY,
+          burnRequest: burnRequest2
+        },
+        typeArguments: [stableTag, usdTag]
+      })(tx);
+      if (autoTransfer) {
+        tx.transferObjects([usdcCoin2], sender ?? this.sender);
+        return;
+      }
+      return usdcCoin2;
+    }
+    await this.releaseRewards(tx);
     const burnRequest = requestBurn({
-      package: STABLE_LAYER_PACKAGE_ID,
+      package: constants.STABLE_LAYER_PACKAGE_ID,
       arguments: {
-        registry: STABLE_REGISTRY,
+        registry: constants.STABLE_REGISTRY,
         stableCoin: btcUsdCoin
       },
-      typeArguments: [stableCoinType, USDC_TYPE]
+      typeArguments: [stableCoinType, constants.USDC_TYPE]
     })(tx);
     const [uPrice] = await this.bucketClient.aggregatePrices(tx, {
-      coinTypes: [USDC_TYPE]
+      coinTypes: [constants.USDC_TYPE]
     });
     const withdrawResponse = pay({
-      package: STABLE_VAULT_FARM_PACKAGE_ID,
+      package: constants.STABLE_VAULT_FARM_PACKAGE_ID,
       arguments: {
-        farm: STABLE_VAULT_FARM,
+        farm: constants.STABLE_VAULT_FARM,
         request: burnRequest,
-        stableVault: STABLE_VAULT,
-        usdbTreasury: this.bucketClient.treasury(tx),
-        psmPool: this.getBucketPSMPool(tx),
-        savingPool: this.getBucketSavingPool(tx),
-        yieldVault: YIELD_VAULT,
+        stableVault: constants.STABLE_VAULT,
+        usdbTreasury: await Promise.resolve(this.bucketClient.treasury(tx)),
+        psmPool: await this.getBucketPSMPool(tx),
+        savingPool: await this.getBucketSavingPool(tx),
+        yieldVault: constants.YIELD_VAULT,
         uPrice
       },
       typeArguments: [
-        STABLE_LP_TYPE,
-        USDC_TYPE,
+        constants.STABLE_LP_TYPE,
+        constants.USDC_TYPE,
         stableCoinType,
-        YUSDB_TYPE,
-        SAVING_TYPE
+        constants.YUSDB_TYPE,
+        constants.SAVING_TYPE
       ]
     })(tx);
-    this.checkResponse({ tx, response: withdrawResponse, type: "withdraw" });
+    await this.checkResponse({ tx, response: withdrawResponse, type: "withdraw" });
     const usdcCoin = fulfillBurn({
-      package: STABLE_LAYER_PACKAGE_ID,
+      package: constants.STABLE_LAYER_PACKAGE_ID,
       arguments: {
-        registry: STABLE_REGISTRY,
+        registry: constants.STABLE_REGISTRY,
         burnRequest
       },
-      typeArguments: [stableCoinType, USDC_TYPE]
+      typeArguments: [stableCoinType, constants.USDC_TYPE]
     })(tx);
     if (autoTransfer) {
       tx.transferObjects([usdcCoin], sender ?? this.sender);
@@ -737,26 +922,53 @@ var StableLayerClient = class {
     autoTransfer = true
   }) {
     tx.setSender(sender ?? this.sender);
-    this.releaseRewards(tx);
+    if (this.network === "testnet") {
+      const constants2 = this.getConstants();
+      const farmRegistry = this.mockFarmRegistryId ?? constants2.MOCK_FARM_REGISTRY;
+      const pkg = this.getMockFarmPackageId();
+      if (!farmRegistry) {
+        throw new Error(
+          "buildClaimTx (testnet): missing mock farm registry (mockFarmRegistryId or MOCK_FARM_REGISTRY)."
+        );
+      }
+      const stableTag = normalizeStructTag(stableCoinType);
+      const usdTag = normalizeStructTag(constants2.USDC_TYPE);
+      const rewardCoin2 = tx.moveCall({
+        target: `${pkg}::farm::claim`,
+        typeArguments: [stableTag, usdTag],
+        arguments: [
+          tx.object(farmRegistry),
+          tx.object(constants2.STABLE_REGISTRY),
+          tx.object(SUI_CLOCK_OBJECT_ID)
+        ]
+      });
+      if (autoTransfer) {
+        tx.transferObjects([rewardCoin2], sender ?? this.sender);
+        return;
+      }
+      return rewardCoin2;
+    }
+    await this.releaseRewards(tx);
+    const constants = this.getConstants();
     const [rewardCoin, withdrawResponse] = claim({
-      package: STABLE_VAULT_FARM_PACKAGE_ID,
+      package: constants.STABLE_VAULT_FARM_PACKAGE_ID,
       arguments: {
-        stableRegistry: STABLE_REGISTRY,
-        farm: STABLE_VAULT_FARM,
-        stableVault: STABLE_VAULT,
-        usdbTreasury: this.bucketClient.treasury(tx),
-        savingPool: this.getBucketSavingPool(tx),
-        yieldVault: YIELD_VAULT
+        stableRegistry: constants.STABLE_REGISTRY,
+        farm: constants.STABLE_VAULT_FARM,
+        stableVault: constants.STABLE_VAULT,
+        usdbTreasury: await Promise.resolve(this.bucketClient.treasury(tx)),
+        savingPool: await this.getBucketSavingPool(tx),
+        yieldVault: constants.YIELD_VAULT
       },
       typeArguments: [
-        STABLE_LP_TYPE,
-        USDC_TYPE,
+        constants.STABLE_LP_TYPE,
+        constants.USDC_TYPE,
         stableCoinType,
-        YUSDB_TYPE,
-        SAVING_TYPE
+        constants.YUSDB_TYPE,
+        constants.SAVING_TYPE
       ]
     })(tx);
-    this.checkResponse({ tx, response: withdrawResponse, type: "withdraw" });
+    await this.checkResponse({ tx, response: withdrawResponse, type: "withdraw" });
     if (autoTransfer) {
       tx.transferObjects([rewardCoin], sender ?? this.sender);
       return;
@@ -764,9 +976,63 @@ var StableLayerClient = class {
       return rewardCoin;
     }
   }
+  async getClaimRewardUsdbAmount({
+    stableCoinType,
+    sender
+  }) {
+    const tx = new Transaction();
+    await this.buildClaimTx({
+      tx,
+      stableCoinType,
+      sender,
+      autoTransfer: true
+    });
+    const usdbType = this.network === "testnet" ? normalizeStructTag(this.mockUsdbCoinType ?? (this.getConstants().MOCK_USDB_TYPE || `${this.getMockFarmPackageId()}::usdb::USDB`)) : normalizeStructTag(await this.bucketClient.getUsdbCoinType());
+    const res = await this.suiClient.simulateTransaction({
+      transaction: tx,
+      include: { balanceChanges: true }
+    });
+    if (res.$kind !== "Transaction") {
+      throw new Error(
+        "StableLayerClient.getClaimRewardUsdbAmount: dry-run did not succeed; cannot infer claimable USDB."
+      );
+    }
+    const changes = res.Transaction?.balanceChanges ?? [];
+    const addr = sender.toLowerCase();
+    let sum = 0n;
+    for (const bc of changes) {
+      if (bc.address.toLowerCase() !== addr) continue;
+      if (normalizeStructTag(bc.coinType) !== usdbType) continue;
+      const amt = BigInt(bc.amount);
+      if (amt > 0n) sum += amt;
+    }
+    return sum;
+  }
+  buildSetMaxSupplyTx({
+    tx,
+    registry,
+    factoryCapId,
+    maxSupply,
+    stableCoinType,
+    usdCoinType,
+    sender
+  }) {
+    tx.setSender(sender ?? this.sender);
+    const constants = this.getConstants();
+    setMaxSupply({
+      package: constants.STABLE_LAYER_PACKAGE_ID,
+      arguments: {
+        registry,
+        FactoryCap: factoryCapId,
+        maxSupply
+      },
+      typeArguments: [stableCoinType, usdCoinType]
+    })(tx);
+  }
   async getTotalSupply() {
+    const constants = this.getConstants();
     const result = await this.suiClient.getObject({
-      objectId: STABLE_REGISTRY,
+      objectId: constants.STABLE_REGISTRY,
       include: { json: true }
     });
     const json = result.object?.json;
@@ -775,8 +1041,9 @@ var StableLayerClient = class {
   async getTotalSupplyByCoinType(stableCoinType) {
     const TypeName3 = bcs24.struct("TypeName", { name: bcs24.string() });
     const nameBcs = TypeName3.serialize({ name: stableCoinType.slice(2) }).toBytes();
+    const constants = this.getConstants();
     const result = await this.suiClient.core.getDynamicObjectField({
-      parentId: STABLE_REGISTRY,
+      parentId: constants.STABLE_REGISTRY,
       name: {
         type: "0x1::type_name::TypeName",
         bcs: nameBcs
@@ -786,52 +1053,75 @@ var StableLayerClient = class {
     const json = result.object?.json;
     return json?.treasury_cap?.total_supply?.value ?? void 0;
   }
-  getBucketSavingPool(tx) {
-    return this.bucketClient.savingPoolObj(tx, {
-      lpType: SAVING_TYPE
-    });
+  async getBucketSavingPool(tx) {
+    return Promise.resolve(
+      this.bucketClient.savingPoolObj(tx, { lpType: this.getConstants().SAVING_TYPE })
+    );
   }
-  getBucketPSMPool(tx) {
-    return this.bucketClient.psmPoolObj(tx, {
-      coinType: USDC_TYPE
-    });
+  async getBucketPSMPool(tx) {
+    return Promise.resolve(
+      this.bucketClient.psmPoolObj(tx, { coinType: this.getConstants().USDC_TYPE })
+    );
   }
-  checkResponse({
+  async checkResponse({
     tx,
     response,
     type
   }) {
+    const lpType = this.getConstants().SAVING_TYPE;
     if (type === "deposit") {
-      return this.bucketClient.checkDepositResponse(tx, {
-        lpType: SAVING_TYPE,
-        depositResponse: response
-      });
+      return Promise.resolve(
+        this.bucketClient.checkDepositResponse(tx, {
+          lpType,
+          depositResponse: response
+        })
+      );
     } else {
-      return this.bucketClient.checkWithdrawResponse(tx, {
-        lpType: SAVING_TYPE,
-        withdrawResponse: response
-      });
+      return Promise.resolve(
+        this.bucketClient.checkWithdrawResponse(tx, {
+          lpType,
+          withdrawResponse: response
+        })
+      );
     }
   }
-  releaseRewards(tx) {
+  async releaseRewards(tx) {
+    const constants = this.getConstants();
     const depositResponse = release({
-      package: YIELD_USDB_PACKAGE_ID,
+      package: constants.YIELD_USDB_PACKAGE_ID,
       arguments: {
-        vault: YIELD_VAULT,
-        treasury: this.bucketClient.treasury(tx),
-        savingPool: this.bucketClient.savingPoolObj(tx, {
-          lpType: SAVING_TYPE
-        })
+        vault: constants.YIELD_VAULT,
+        treasury: await Promise.resolve(this.bucketClient.treasury(tx)),
+        savingPool: await Promise.resolve(
+          this.bucketClient.savingPoolObj(tx, { lpType: constants.SAVING_TYPE })
+        )
       },
-      typeArguments: [YUSDB_TYPE, SAVING_TYPE]
+      typeArguments: [constants.YUSDB_TYPE, constants.SAVING_TYPE]
     })(tx);
-    this.bucketClient.checkDepositResponse(tx, {
-      depositResponse,
-      lpType: SAVING_TYPE
-    });
+    await Promise.resolve(
+      this.bucketClient.checkDepositResponse(tx, {
+        depositResponse,
+        lpType: constants.SAVING_TYPE
+      })
+    );
   }
 };
 export {
-  StableLayerClient
+  SAVING_TYPE,
+  STABLE_LAYER_PACKAGE_ID,
+  STABLE_LAYER_PACKAGE_MAINNET_ALT,
+  STABLE_LP_TYPE,
+  STABLE_REGISTRY,
+  STABLE_REGISTRY_MAINNET_ALT,
+  STABLE_VAULT,
+  STABLE_VAULT_FARM,
+  STABLE_VAULT_FARM_ENTITY_TYPE,
+  STABLE_VAULT_FARM_PACKAGE_ID,
+  StableLayerClient,
+  USDC_TYPE,
+  YIELD_USDB_PACKAGE_ID,
+  YIELD_VAULT,
+  YUSDB_TYPE,
+  getConstants
 };
 //# sourceMappingURL=index.mjs.map