stable-layer-sdk 2.0.0 → 3.1.0

package/dist/esm/index.mjs

@@ -1,24 +1,9 @@
 // src/index.ts
-import {
-  coinWithBalance
-} from "@mysten/sui/transactions";
-
-// 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";
-
-// src/index.ts
-import { getFullnodeUrl, SuiClient } from "@mysten/sui/client";
+import { BucketClient } from "@bucket-protocol/sdk";
+import { bcs as bcs24 } from "@mysten/sui/bcs";
+import { SuiGrpcClient } from "@mysten/sui/grpc";
+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";
@@ -141,133 +126,13 @@ function stringify(val) {
   return val;
 }
 
-// src/generated/yield_usdb/yield_usdb.ts
-import { bcs as bcs8 } from "@mysten/sui/bcs";
-
-// src/generated/yield_usdb/deps/sui/object.ts
-import { bcs as bcs2 } from "@mysten/sui/bcs";
-var $moduleName = "0x2::object";
-var UID = new MoveStruct({ name: `${$moduleName}::UID`, fields: {
-  id: bcs2.Address
-} });
-
-// src/generated/yield_usdb/deps/sui/balance.ts
-import { bcs as bcs3 } from "@mysten/sui/bcs";
-var $moduleName2 = "0x2::balance";
-var Balance = new MoveStruct({ name: `${$moduleName2}::Balance`, fields: {
-  value: bcs3.u64()
-} });
-var Supply = new MoveStruct({ name: `${$moduleName2}::Supply`, fields: {
-  value: bcs3.u64()
-} });
-
-// src/generated/yield_usdb/deps/sui/coin.ts
-var $moduleName3 = "0x2::coin";
-var TreasuryCap = new MoveStruct({ name: `${$moduleName3}::TreasuryCap`, fields: {
-  id: UID,
-  total_supply: Supply
-} });
-
-// src/generated/yield_usdb/deps/bucket_v2_framework/account.ts
-import { bcs as bcs4 } from "@mysten/sui/bcs";
-var $moduleName4 = "bucket_v2_framework::account";
-var Account = new MoveStruct({ name: `${$moduleName4}::Account`, fields: {
-  id: UID,
-  alias: bcs4.option(bcs4.string())
-} });
-
-// src/generated/yield_usdb/buffer.ts
-import { bcs as bcs6 } from "@mysten/sui/bcs";
-
-// src/generated/yield_usdb/deps/bucket_v2_framework/double.ts
-import { bcs as bcs5 } from "@mysten/sui/bcs";
-var $moduleName5 = "bucket_v2_framework::double";
-var Double = new MoveStruct({ name: `${$moduleName5}::Double`, fields: {
-  value: bcs5.u256()
-} });
-
-// src/generated/yield_usdb/buffer.ts
-var $moduleName6 = "@local-pkg/yield_usdb.move::buffer";
-var Buffer = new MoveStruct({ name: `${$moduleName6}::Buffer`, fields: {
-  balance: Balance,
-  flow_rate: Double,
-  timestamp: bcs6.u64()
-} });
-
-// src/generated/yield_usdb/deps/sui/vec_set.ts
-import { bcs as bcs7 } from "@mysten/sui/bcs";
-var $moduleName7 = "0x2::vec_set";
-function VecSet(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName7}::VecSet<${typeParameters[0].name}>`, fields: {
-    contents: bcs7.vector(typeParameters[0])
-  } });
-}
-
-// src/generated/yield_usdb/yield_usdb.ts
-var $moduleName8 = "@local-pkg/yield_usdb.move::yield_usdb";
-var Created = new MoveStruct({ name: `${$moduleName8}::Created`, fields: {
-  vault_id: bcs8.Address,
-  max_lp_supply: bcs8.u64(),
-  abstract_address: bcs8.Address
-} });
-var MaxSupplyUpdated = new MoveStruct({ name: `${$moduleName8}::MaxSupplyUpdated`, fields: {
-  vault_id: bcs8.Address,
-  previous_max_lp_supply: bcs8.u64(),
-  current_max_lp_supply: bcs8.u64()
-} });
-var Minted = new MoveStruct({ name: `${$moduleName8}::Minted`, fields: {
-  vault_id: bcs8.Address,
-  usdb_amount: bcs8.u64(),
-  lp_amount: bcs8.u64()
-} });
-var Burned = new MoveStruct({ name: `${$moduleName8}::Burned`, fields: {
-  vault_id: bcs8.Address,
-  lp_amount: bcs8.u64(),
-  usdb_amount: bcs8.u64()
-} });
-var Claimed = new MoveStruct({ name: `${$moduleName8}::Claimed`, fields: {
-  vault_id: bcs8.Address,
-  reward_type: bcs8.string(),
-  reward_amount: bcs8.u64()
-} });
-var Collected = new MoveStruct({ name: `${$moduleName8}::Collected`, fields: {
-  vault_id: bcs8.Address,
-  usdb_amount: bcs8.u64()
-} });
-var YieldVault = new MoveStruct({ name: `${$moduleName8}::YieldVault`, fields: {
-  id: UID,
-  max_lp_supply: bcs8.u64(),
-  lp_treasury_cap: TreasuryCap,
-  abstract_account: Account,
-  buffer: Buffer,
-  managers: VecSet(bcs8.Address),
-  versions: VecSet(bcs8.u16())
-} });
-function release(options) {
-  const packageAddress = options.package ?? "@local-pkg/yield_usdb.move";
-  const argumentsTypes = [
-    `${packageAddress}::yield_usdb::YieldVault<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
-    `${packageAddress}::usdb::Treasury`,
-    `${packageAddress}::saving::SavingPool<${options.typeArguments[1]}>`,
-    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
-  ];
-  const parameterNames = ["vault", "treasury", "savingPool"];
-  return (tx) => tx.moveCall({
-    package: packageAddress,
-    module: "yield_usdb",
-    function: "release",
-    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
-    typeArguments: options.typeArguments
-  });
-}
-
 // src/generated/stable_layer/stable_layer.ts
-import { bcs as bcs15 } from "@mysten/sui/bcs";
+import { bcs as bcs8 } from "@mysten/sui/bcs";
 
 // src/generated/stable_layer/deps/std/type_name.ts
-import { bcs as bcs9 } from "@mysten/sui/bcs";
-var $moduleName9 = "std::type_name";
-var TypeName = new MoveStruct({ name: `${$moduleName9}::TypeName`, fields: {
+import { bcs as bcs2 } from "@mysten/sui/bcs";
+var $moduleName = "std::type_name";
+var TypeName = new MoveStruct({ name: `${$moduleName}::TypeName`, fields: {
   /**
      * String representation of the type. All types are represented using their source
      * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
@@ -277,116 +142,132 @@ var TypeName = new MoveStruct({ name: `${$moduleName9}::TypeName`, fields: {
      * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
      * 32 depending on the Move platform)
      */
-  name: bcs9.string()
+  name: bcs2.string()
 } });
 
 // src/generated/stable_layer/deps/sui/vec_map.ts
-import { bcs as bcs10 } from "@mysten/sui/bcs";
-var $moduleName10 = "0x2::vec_map";
+import { bcs as bcs3 } from "@mysten/sui/bcs";
+var $moduleName2 = "0x2::vec_map";
 function Entry(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName10}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+  return new MoveStruct({ name: `${$moduleName2}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
     key: typeParameters[0],
     value: typeParameters[1]
   } });
 }
 function VecMap(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName10}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
-    contents: bcs10.vector(Entry(typeParameters[0], typeParameters[1]))
+  return new MoveStruct({ name: `${$moduleName2}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+    contents: bcs3.vector(Entry(typeParameters[0], typeParameters[1]))
   } });
 }
 
 // src/generated/stable_layer/deps/bucket_v2_framework/liability.ts
-import { bcs as bcs11 } from "@mysten/sui/bcs";
-var $moduleName11 = "bucket_v2_framework::liability";
-var Credit = new MoveStruct({ name: `${$moduleName11}::Credit`, fields: {
-  value: bcs11.u64()
+import { bcs as bcs4 } from "@mysten/sui/bcs";
+var $moduleName3 = "bucket_v2_framework::liability";
+var Credit = new MoveStruct({ name: `${$moduleName3}::Credit`, fields: {
+  value: bcs4.u64()
 } });
-var Debt = new MoveStruct({ name: `${$moduleName11}::Debt`, fields: {
-  value: bcs11.u64()
+var Debt = new MoveStruct({ name: `${$moduleName3}::Debt`, fields: {
+  value: bcs4.u64()
 } });
 
 // src/generated/stable_layer/deps/sui/vec_set.ts
-import { bcs as bcs12 } from "@mysten/sui/bcs";
-var $moduleName12 = "0x2::vec_set";
-function VecSet2(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName12}::VecSet<${typeParameters[0].name}>`, fields: {
-    contents: bcs12.vector(typeParameters[0])
+import { bcs as bcs5 } from "@mysten/sui/bcs";
+var $moduleName4 = "0x2::vec_set";
+function VecSet(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName4}::VecSet<${typeParameters[0].name}>`, fields: {
+    contents: bcs5.vector(typeParameters[0])
   } });
 }
 
 // src/generated/stable_layer/deps/bucket_v2_framework/sheet.ts
-var $moduleName13 = "bucket_v2_framework::sheet";
-var Entity = new MoveTuple({ name: `${$moduleName13}::Entity`, fields: [TypeName] });
-var Sheet = new MoveStruct({ name: `${$moduleName13}::Sheet`, fields: {
+var $moduleName5 = "bucket_v2_framework::sheet";
+var Entity = new MoveTuple({ name: `${$moduleName5}::Entity`, fields: [TypeName] });
+var Sheet = new MoveStruct({ name: `${$moduleName5}::Sheet`, fields: {
   credits: VecMap(Entity, Credit),
   debts: VecMap(Entity, Debt),
-  blacklist: VecSet2(Entity)
+  blacklist: VecSet(Entity)
 } });
 
 // src/generated/stable_layer/deps/sui/object.ts
-import { bcs as bcs13 } from "@mysten/sui/bcs";
-var $moduleName14 = "0x2::object";
-var UID2 = new MoveStruct({ name: `${$moduleName14}::UID`, fields: {
-  id: bcs13.Address
+import { bcs as bcs6 } from "@mysten/sui/bcs";
+var $moduleName6 = "0x2::object";
+var UID = new MoveStruct({ name: `${$moduleName6}::UID`, fields: {
+  id: bcs6.Address
 } });
 
 // src/generated/stable_layer/deps/sui/balance.ts
-import { bcs as bcs14 } from "@mysten/sui/bcs";
-var $moduleName15 = "0x2::balance";
-var Supply2 = new MoveStruct({ name: `${$moduleName15}::Supply`, fields: {
-  value: bcs14.u64()
+import { bcs as bcs7 } from "@mysten/sui/bcs";
+var $moduleName7 = "0x2::balance";
+var Supply = new MoveStruct({ name: `${$moduleName7}::Supply`, fields: {
+  value: bcs7.u64()
 } });
 
 // src/generated/stable_layer/deps/sui/coin.ts
-var $moduleName16 = "0x2::coin";
-var TreasuryCap2 = new MoveStruct({ name: `${$moduleName16}::TreasuryCap`, fields: {
-  id: UID2,
-  total_supply: Supply2
+var $moduleName8 = "0x2::coin";
+var TreasuryCap = new MoveStruct({ name: `${$moduleName8}::TreasuryCap`, fields: {
+  id: UID,
+  total_supply: Supply
 } });
 
 // src/generated/stable_layer/stable_layer.ts
-var $moduleName17 = "@local-pkg/stable_factory.move::stable_layer";
-var NewStable = new MoveStruct({ name: `${$moduleName17}::NewStable`, fields: {
-  u_type: bcs15.string(),
-  stable_type: bcs15.string(),
-  factory_id: bcs15.Address,
-  factory_cap_id: bcs15.Address
-} });
-var Mint = new MoveStruct({ name: `${$moduleName17}::Mint`, fields: {
-  u_type: bcs15.string(),
-  stable_type: bcs15.string(),
-  mint_amount: bcs15.u64(),
-  farm_type: bcs15.string()
-} });
-var Burn = new MoveStruct({ name: `${$moduleName17}::Burn`, fields: {
-  u_type: bcs15.string(),
-  stable_type: bcs15.string(),
-  burn_amount: bcs15.u64(),
-  farm_types: bcs15.vector(Entity),
-  repayment_amounts: bcs15.vector(bcs15.u64())
-} });
-var StableFactoryEntity = new MoveStruct({ name: `${$moduleName17}::StableFactoryEntity`, fields: {
-  dummy_field: bcs15.bool()
-} });
-var StableRegistry = new MoveStruct({ name: `${$moduleName17}::StableRegistry`, fields: {
-  id: UID2,
-  versions: VecSet2(bcs15.u16()),
-  total_supply: bcs15.u64()
+var $moduleName9 = "@local-pkg/stable_factory.move::stable_layer";
+var NewStable = new MoveStruct({ name: `${$moduleName9}::NewStable`, fields: {
+  u_type: bcs8.string(),
+  stable_type: bcs8.string(),
+  factory_id: bcs8.Address,
+  factory_cap_id: bcs8.Address
 } });
-var AdminCap = new MoveStruct({ name: `${$moduleName17}::AdminCap`, fields: {
-  id: UID2
+var Mint = new MoveStruct({ name: `${$moduleName9}::Mint`, fields: {
+  u_type: bcs8.string(),
+  stable_type: bcs8.string(),
+  mint_amount: bcs8.u64(),
+  farm_type: bcs8.string()
 } });
-var StableFactory = new MoveStruct({ name: `${$moduleName17}::StableFactory`, fields: {
-  id: UID2,
-  treasury_cap: TreasuryCap2,
-  max_supply: bcs15.u64(),
+var Burn = new MoveStruct({ name: `${$moduleName9}::Burn`, fields: {
+  u_type: bcs8.string(),
+  stable_type: bcs8.string(),
+  burn_amount: bcs8.u64(),
+  farm_types: bcs8.vector(Entity),
+  repayment_amounts: bcs8.vector(bcs8.u64())
+} });
+var StableFactoryEntity = new MoveStruct({ name: `${$moduleName9}::StableFactoryEntity`, fields: {
+  dummy_field: bcs8.bool()
+} });
+var StableRegistry = new MoveStruct({ name: `${$moduleName9}::StableRegistry`, fields: {
+  id: UID,
+  versions: VecSet(bcs8.u16()),
+  total_supply: bcs8.u64()
+} });
+var AdminCap = new MoveStruct({ name: `${$moduleName9}::AdminCap`, fields: {
+  id: UID
+} });
+var StableFactory = new MoveStruct({ name: `${$moduleName9}::StableFactory`, fields: {
+  id: UID,
+  treasury_cap: TreasuryCap,
+  max_supply: bcs8.u64(),
   sheet: Sheet,
-  managers: VecSet2(bcs15.Address)
+  managers: VecSet(bcs8.Address)
 } });
-var FactoryCap = new MoveStruct({ name: `${$moduleName17}::FactoryCap`, fields: {
-  id: UID2,
-  factory_id: bcs15.Address
+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 = [
@@ -434,19 +315,19 @@ function fulfillBurn(options) {
 }
 
 // src/generated/stable_vault_farm/stable_vault_farm.ts
-import { bcs as bcs23 } from "@mysten/sui/bcs";
+import { bcs as bcs16 } from "@mysten/sui/bcs";
 
 // src/generated/stable_vault_farm/deps/sui/object.ts
-import { bcs as bcs16 } from "@mysten/sui/bcs";
-var $moduleName18 = "0x2::object";
-var UID3 = new MoveStruct({ name: `${$moduleName18}::UID`, fields: {
-  id: bcs16.Address
+import { bcs as bcs9 } from "@mysten/sui/bcs";
+var $moduleName10 = "0x2::object";
+var UID2 = new MoveStruct({ name: `${$moduleName10}::UID`, fields: {
+  id: bcs9.Address
 } });
 
 // src/generated/stable_vault_farm/deps/std/type_name.ts
-import { bcs as bcs17 } from "@mysten/sui/bcs";
-var $moduleName19 = "std::type_name";
-var TypeName2 = new MoveStruct({ name: `${$moduleName19}::TypeName`, fields: {
+import { bcs as bcs10 } from "@mysten/sui/bcs";
+var $moduleName11 = "std::type_name";
+var TypeName2 = new MoveStruct({ name: `${$moduleName11}::TypeName`, fields: {
   /**
      * String representation of the type. All types are represented using their source
      * syntax: "u8", "u64", "bool", "address", "vector", and so on for primitive types.
@@ -456,90 +337,90 @@ var TypeName2 = new MoveStruct({ name: `${$moduleName19}::TypeName`, fields: {
      * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
      * 32 depending on the Move platform)
      */
-  name: bcs17.string()
+  name: bcs10.string()
 } });
 
 // src/generated/stable_vault_farm/deps/sui/vec_map.ts
-import { bcs as bcs18 } from "@mysten/sui/bcs";
-var $moduleName20 = "0x2::vec_map";
+import { bcs as bcs11 } from "@mysten/sui/bcs";
+var $moduleName12 = "0x2::vec_map";
 function Entry2(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName20}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+  return new MoveStruct({ name: `${$moduleName12}::Entry<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
     key: typeParameters[0],
     value: typeParameters[1]
   } });
 }
 function VecMap2(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName20}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
-    contents: bcs18.vector(Entry2(typeParameters[0], typeParameters[1]))
+  return new MoveStruct({ name: `${$moduleName12}::VecMap<${typeParameters[0].name}, ${typeParameters[1].name}>`, fields: {
+    contents: bcs11.vector(Entry2(typeParameters[0], typeParameters[1]))
   } });
 }
 
 // src/generated/stable_vault_farm/deps/bucket_v2_framework/liability.ts
-import { bcs as bcs19 } from "@mysten/sui/bcs";
-var $moduleName21 = "bucket_v2_framework::liability";
-var Credit2 = new MoveStruct({ name: `${$moduleName21}::Credit`, fields: {
-  value: bcs19.u64()
+import { bcs as bcs12 } from "@mysten/sui/bcs";
+var $moduleName13 = "bucket_v2_framework::liability";
+var Credit2 = new MoveStruct({ name: `${$moduleName13}::Credit`, fields: {
+  value: bcs12.u64()
 } });
-var Debt2 = new MoveStruct({ name: `${$moduleName21}::Debt`, fields: {
-  value: bcs19.u64()
+var Debt2 = new MoveStruct({ name: `${$moduleName13}::Debt`, fields: {
+  value: bcs12.u64()
 } });
 
 // src/generated/stable_vault_farm/deps/sui/vec_set.ts
-import { bcs as bcs20 } from "@mysten/sui/bcs";
-var $moduleName22 = "0x2::vec_set";
-function VecSet3(...typeParameters) {
-  return new MoveStruct({ name: `${$moduleName22}::VecSet<${typeParameters[0].name}>`, fields: {
-    contents: bcs20.vector(typeParameters[0])
+import { bcs as bcs13 } from "@mysten/sui/bcs";
+var $moduleName14 = "0x2::vec_set";
+function VecSet2(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName14}::VecSet<${typeParameters[0].name}>`, fields: {
+    contents: bcs13.vector(typeParameters[0])
   } });
 }
 
 // src/generated/stable_vault_farm/deps/bucket_v2_framework/sheet.ts
-var $moduleName23 = "bucket_v2_framework::sheet";
-var Entity2 = new MoveTuple({ name: `${$moduleName23}::Entity`, fields: [TypeName2] });
-var Sheet2 = new MoveStruct({ name: `${$moduleName23}::Sheet`, fields: {
+var $moduleName15 = "bucket_v2_framework::sheet";
+var Entity2 = new MoveTuple({ name: `${$moduleName15}::Entity`, fields: [TypeName2] });
+var Sheet2 = new MoveStruct({ name: `${$moduleName15}::Sheet`, fields: {
   credits: VecMap2(Entity2, Credit2),
   debts: VecMap2(Entity2, Debt2),
-  blacklist: VecSet3(Entity2)
+  blacklist: VecSet2(Entity2)
 } });
 
 // src/generated/stable_vault_farm/deps/sui/table.ts
-import { bcs as bcs21 } from "@mysten/sui/bcs";
-var $moduleName24 = "0x2::table";
-var Table = new MoveStruct({ name: `${$moduleName24}::Table`, fields: {
+import { bcs as bcs14 } from "@mysten/sui/bcs";
+var $moduleName16 = "0x2::table";
+var Table = new MoveStruct({ name: `${$moduleName16}::Table`, fields: {
   /** the ID of this table */
-  id: UID3,
+  id: UID2,
   /** the number of key-value pairs in the table */
-  size: bcs21.u64()
+  size: bcs14.u64()
 } });
 
 // src/generated/stable_vault_farm/deps/sui/balance.ts
-import { bcs as bcs22 } from "@mysten/sui/bcs";
-var $moduleName25 = "0x2::balance";
-var Balance2 = new MoveStruct({ name: `${$moduleName25}::Balance`, fields: {
-  value: bcs22.u64()
+import { bcs as bcs15 } from "@mysten/sui/bcs";
+var $moduleName17 = "0x2::balance";
+var Balance = new MoveStruct({ name: `${$moduleName17}::Balance`, fields: {
+  value: bcs15.u64()
 } });
 
 // src/generated/stable_vault_farm/stable_vault_farm.ts
-var $moduleName26 = "@local-pkg/stable_vault_farm.move::stable_vault_farm";
-var Claim = new MoveStruct({ name: `${$moduleName26}::Claim`, fields: {
-  reward_type: bcs23.string(),
-  amount: bcs23.u64(),
-  claimer: bcs23.Address
+var $moduleName18 = "@local-pkg/stable_vault_farm.move::stable_vault_farm";
+var Claim = new MoveStruct({ name: `${$moduleName18}::Claim`, fields: {
+  reward_type: bcs16.string(),
+  amount: bcs16.u64(),
+  claimer: bcs16.Address
 } });
-var StableVaultFarmEntity = new MoveStruct({ name: `${$moduleName26}::StableVaultFarmEntity`, fields: {
-  dummy_field: bcs23.bool()
+var StableVaultFarmEntity = new MoveStruct({ name: `${$moduleName18}::StableVaultFarmEntity`, fields: {
+  dummy_field: bcs16.bool()
 } });
-var StableVaultFarmWitness = new MoveStruct({ name: `${$moduleName26}::StableVaultFarmWitness`, fields: {
-  dummy_field: bcs23.bool()
+var StableVaultFarmWitness = new MoveStruct({ name: `${$moduleName18}::StableVaultFarmWitness`, fields: {
+  dummy_field: bcs16.bool()
 } });
-var StableVaultFarm = new MoveStruct({ name: `${$moduleName26}::StableVaultFarm`, fields: {
-  id: UID3,
+var StableVaultFarm = new MoveStruct({ name: `${$moduleName18}::StableVaultFarm`, fields: {
+  id: UID2,
   sheet: Sheet2,
   yield_table: Table,
-  u_surplus: Balance2
+  u_surplus: Balance
 } });
-var AdminCap2 = new MoveStruct({ name: `${$moduleName26}::AdminCap`, fields: {
-  id: UID3
+var AdminCap2 = new MoveStruct({ name: `${$moduleName18}::AdminCap`, fields: {
+  id: UID2
 } });
 function receive(options) {
   const packageAddress = options.package ?? "@local-pkg/stable_vault_farm.move";
@@ -606,13 +487,248 @@ function claim(options) {
   });
 }
 
+// src/generated/yield_usdb/yield_usdb.ts
+import { bcs as bcs23 } from "@mysten/sui/bcs";
+
+// src/generated/yield_usdb/deps/sui/object.ts
+import { bcs as bcs17 } from "@mysten/sui/bcs";
+var $moduleName19 = "0x2::object";
+var UID3 = new MoveStruct({ name: `${$moduleName19}::UID`, fields: {
+  id: bcs17.Address
+} });
+
+// src/generated/yield_usdb/deps/sui/balance.ts
+import { bcs as bcs18 } from "@mysten/sui/bcs";
+var $moduleName20 = "0x2::balance";
+var Balance2 = new MoveStruct({ name: `${$moduleName20}::Balance`, fields: {
+  value: bcs18.u64()
+} });
+var Supply2 = new MoveStruct({ name: `${$moduleName20}::Supply`, fields: {
+  value: bcs18.u64()
+} });
+
+// src/generated/yield_usdb/deps/sui/coin.ts
+var $moduleName21 = "0x2::coin";
+var TreasuryCap2 = new MoveStruct({ name: `${$moduleName21}::TreasuryCap`, fields: {
+  id: UID3,
+  total_supply: Supply2
+} });
+
+// src/generated/yield_usdb/deps/bucket_v2_framework/account.ts
+import { bcs as bcs19 } from "@mysten/sui/bcs";
+var $moduleName22 = "bucket_v2_framework::account";
+var Account = new MoveStruct({ name: `${$moduleName22}::Account`, fields: {
+  id: UID3,
+  alias: bcs19.option(bcs19.string())
+} });
+
+// src/generated/yield_usdb/buffer.ts
+import { bcs as bcs21 } from "@mysten/sui/bcs";
+
+// src/generated/yield_usdb/deps/bucket_v2_framework/double.ts
+import { bcs as bcs20 } from "@mysten/sui/bcs";
+var $moduleName23 = "bucket_v2_framework::double";
+var Double = new MoveStruct({ name: `${$moduleName23}::Double`, fields: {
+  value: bcs20.u256()
+} });
+
+// src/generated/yield_usdb/buffer.ts
+var $moduleName24 = "@local-pkg/yield_usdb.move::buffer";
+var Buffer = new MoveStruct({ name: `${$moduleName24}::Buffer`, fields: {
+  balance: Balance2,
+  flow_rate: Double,
+  timestamp: bcs21.u64()
+} });
+
+// src/generated/yield_usdb/deps/sui/vec_set.ts
+import { bcs as bcs22 } from "@mysten/sui/bcs";
+var $moduleName25 = "0x2::vec_set";
+function VecSet3(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName25}::VecSet<${typeParameters[0].name}>`, fields: {
+    contents: bcs22.vector(typeParameters[0])
+  } });
+}
+
+// src/generated/yield_usdb/yield_usdb.ts
+var $moduleName26 = "@local-pkg/yield_usdb.move::yield_usdb";
+var Created = new MoveStruct({ name: `${$moduleName26}::Created`, fields: {
+  vault_id: bcs23.Address,
+  max_lp_supply: bcs23.u64(),
+  abstract_address: bcs23.Address
+} });
+var MaxSupplyUpdated = new MoveStruct({ name: `${$moduleName26}::MaxSupplyUpdated`, fields: {
+  vault_id: bcs23.Address,
+  previous_max_lp_supply: bcs23.u64(),
+  current_max_lp_supply: bcs23.u64()
+} });
+var Minted = new MoveStruct({ name: `${$moduleName26}::Minted`, fields: {
+  vault_id: bcs23.Address,
+  usdb_amount: bcs23.u64(),
+  lp_amount: bcs23.u64()
+} });
+var Burned = new MoveStruct({ name: `${$moduleName26}::Burned`, fields: {
+  vault_id: bcs23.Address,
+  lp_amount: bcs23.u64(),
+  usdb_amount: bcs23.u64()
+} });
+var Claimed = new MoveStruct({ name: `${$moduleName26}::Claimed`, fields: {
+  vault_id: bcs23.Address,
+  reward_type: bcs23.string(),
+  reward_amount: bcs23.u64()
+} });
+var Collected = new MoveStruct({ name: `${$moduleName26}::Collected`, fields: {
+  vault_id: bcs23.Address,
+  usdb_amount: bcs23.u64()
+} });
+var YieldVault = new MoveStruct({ name: `${$moduleName26}::YieldVault`, fields: {
+  id: UID3,
+  max_lp_supply: bcs23.u64(),
+  lp_treasury_cap: TreasuryCap2,
+  abstract_account: Account,
+  buffer: Buffer,
+  managers: VecSet3(bcs23.Address),
+  versions: VecSet3(bcs23.u16())
+} });
+function release(options) {
+  const packageAddress = options.package ?? "@local-pkg/yield_usdb.move";
+  const argumentsTypes = [
+    `${packageAddress}::yield_usdb::YieldVault<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::usdb::Treasury`,
+    `${packageAddress}::saving::SavingPool<${options.typeArguments[1]}>`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["vault", "treasury", "savingPool"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "yield_usdb",
+    function: "release",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+
+// 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
+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
-import { BucketClient } from "@bucket-protocol/sdk";
-var StableLayerClient = class {
-  constructor(config) {
-    this.bucketClient = new BucketClient({ network: config.network });
-    this.suiClient = new SuiClient({ url: getFullnodeUrl(config.network) });
+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
+    });
+    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,42 +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,50 +825,88 @@ var StableLayerClient = class {
         (await this.suiClient.getBalance({
           owner: sender ?? this.sender,
           coinType: stableCoinType
-        })).totalBalance
+        })).balance.balance
       ) : 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);
@@ -741,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;
@@ -768,75 +976,152 @@ 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({
-      id: STABLE_REGISTRY,
-      options: {
-        showContent: true
-      }
+      objectId: constants.STABLE_REGISTRY,
+      include: { json: true }
     });
-    const content = result.data?.content;
-    return content?.fields?.total_supply;
+    const json = result.object?.json;
+    return json?.total_supply ?? void 0;
   }
   async getTotalSupplyByCoinType(stableCoinType) {
-    const result = await this.suiClient.getDynamicFieldObject({
-      parentId: STABLE_REGISTRY,
+    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: constants.STABLE_REGISTRY,
       name: {
         type: "0x1::type_name::TypeName",
-        value: {
-          name: stableCoinType.slice(2)
-        }
-      }
+        bcs: nameBcs
+      },
+      include: { json: true }
     });
-    const content = result.data?.content;
-    return content?.fields?.treasury_cap?.fields?.total_supply?.fields?.value;
+    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