stable-layer-sdk 1.0.4 → 1.0.6

package/dist/cjs/index.cjs

@@ -0,0 +1,873 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  StableLayerClient: () => StableLayerClient
+});
+module.exports = __toCommonJS(index_exports);
+var import_transactions2 = require("@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 = "0x41e25d09e20cf3bc43fe321e51ef178fac419ae47b783a7161982158fc9f17d6";
+var STABLE_VAULT_FARM_PACKAGE_ID = "0xd5b9fb5a964fa9c274e07a788d7b6d36d8df1c73e2e6f795f8db852621470b70";
+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 = "0x203eebc39442014a1b8180f3b8ed70143dac2c5d28ba5703fe34c21052728705";
+var BTC_USD_TYPE = "0x6d9fc33611f4881a3f5c0cd4899d95a862236ce52b3a38fef039077b0c5b5834::btc_usdc::BtcUSDC";
+var STABLE_COIN_TYPES = {
+  btcUSDC: BTC_USD_TYPE
+};
+
+// src/index.ts
+var import_client = require("@mysten/sui/client");
+
+// src/generated/utils/index.ts
+var import_bcs = require("@mysten/sui/bcs");
+var import_utils = require("@mysten/sui/utils");
+var import_transactions = require("@mysten/sui/transactions");
+var MOVE_STDLIB_ADDRESS = (0, import_utils.normalizeSuiAddress)("0x1");
+var SUI_FRAMEWORK_ADDRESS = (0, import_utils.normalizeSuiAddress)("0x2");
+var SUI_SYSTEM_ADDRESS = (0, import_utils.normalizeSuiAddress)("0x3");
+function getPureBcsSchema(typeTag) {
+  const parsedTag = typeof typeTag === "string" ? import_bcs.TypeTagSerializer.parseFromStr(typeTag) : typeTag;
+  if ("u8" in parsedTag) {
+    return import_bcs.bcs.U8;
+  } else if ("u16" in parsedTag) {
+    return import_bcs.bcs.U16;
+  } else if ("u32" in parsedTag) {
+    return import_bcs.bcs.U32;
+  } else if ("u64" in parsedTag) {
+    return import_bcs.bcs.U64;
+  } else if ("u128" in parsedTag) {
+    return import_bcs.bcs.U128;
+  } else if ("u256" in parsedTag) {
+    return import_bcs.bcs.U256;
+  } else if ("address" in parsedTag) {
+    return import_bcs.bcs.Address;
+  } else if ("bool" in parsedTag) {
+    return import_bcs.bcs.Bool;
+  } else if ("vector" in parsedTag) {
+    const type = getPureBcsSchema(parsedTag.vector);
+    return type ? import_bcs.bcs.vector(type) : null;
+  } else if ("struct" in parsedTag) {
+    const structTag = parsedTag.struct;
+    const pkg = (0, import_utils.normalizeSuiAddress)(parsedTag.struct.address);
+    if (pkg === MOVE_STDLIB_ADDRESS) {
+      if ((structTag.module === "ascii" || structTag.module === "string") && structTag.name === "String") {
+        return import_bcs.bcs.String;
+      }
+      if (structTag.module === "option" && structTag.name === "Option") {
+        const type = getPureBcsSchema(structTag.typeParams[0]);
+        return type ? import_bcs.bcs.option(type) : null;
+      }
+    }
+    if (pkg === SUI_FRAMEWORK_ADDRESS && structTag.module === "Object" && structTag.name === "ID") {
+      return import_bcs.bcs.Address;
+    }
+  }
+  return null;
+}
+function normalizeMoveArguments(args, argTypes, parameterNames) {
+  const argLen = Array.isArray(args) ? args.length : Object.keys(args).length;
+  if (parameterNames && argLen !== parameterNames.length) {
+    throw new Error(
+      `Invalid number of arguments, expected ${parameterNames.length}, got ${argLen}`
+    );
+  }
+  const normalizedArgs = [];
+  let index = 0;
+  for (const [i, argType] of argTypes.entries()) {
+    if (argType === `${SUI_FRAMEWORK_ADDRESS}::deny_list::DenyList`) {
+      normalizedArgs.push((tx) => tx.object.denyList());
+      continue;
+    }
+    if (argType === `${SUI_FRAMEWORK_ADDRESS}::random::Random`) {
+      normalizedArgs.push((tx) => tx.object.random());
+      continue;
+    }
+    if (argType === `${SUI_FRAMEWORK_ADDRESS}::clock::Clock`) {
+      normalizedArgs.push((tx) => tx.object.clock());
+      continue;
+    }
+    if (argType === `${SUI_SYSTEM_ADDRESS}::sui_system::SuiSystemState`) {
+      normalizedArgs.push((tx) => tx.object.system());
+      continue;
+    }
+    let arg;
+    if (Array.isArray(args)) {
+      if (index >= args.length) {
+        throw new Error(`Invalid number of arguments, expected at least ${index + 1}, got ${args.length}`);
+      }
+      arg = args[index];
+    } else {
+      if (!parameterNames) {
+        throw new Error(`Expected arguments to be passed as an array`);
+      }
+      const name = parameterNames[index];
+      arg = args[name];
+      if (arg == null) {
+        throw new Error(`Parameter ${name} is required`);
+      }
+    }
+    index += 1;
+    if (typeof arg === "function" || (0, import_transactions.isArgument)(arg)) {
+      normalizedArgs.push(arg);
+      continue;
+    }
+    const type = argTypes[i];
+    const bcsType = getPureBcsSchema(type);
+    if (bcsType) {
+      const bytes = bcsType.serialize(arg);
+      normalizedArgs.push((tx) => tx.pure(bytes));
+      continue;
+    } else if (typeof arg === "string") {
+      normalizedArgs.push((tx) => tx.object(arg));
+      continue;
+    }
+    throw new Error(`Invalid argument ${stringify(arg)} for type ${type}`);
+  }
+  return normalizedArgs;
+}
+var MoveStruct = class extends import_bcs.BcsStruct {
+};
+var MoveTuple = class extends import_bcs.BcsTuple {
+};
+function stringify(val) {
+  if (typeof val === "object") {
+    return JSON.stringify(val, (val2) => val2);
+  }
+  if (typeof val === "bigint") {
+    return val.toString();
+  }
+  return val;
+}
+
+// src/generated/yield_usdb/yield_usdb.ts
+var import_bcs8 = require("@mysten/sui/bcs");
+
+// src/generated/yield_usdb/deps/sui/object.ts
+var import_bcs2 = require("@mysten/sui/bcs");
+var $moduleName = "0x2::object";
+var UID = new MoveStruct({ name: `${$moduleName}::UID`, fields: {
+  id: import_bcs2.bcs.Address
+} });
+
+// src/generated/yield_usdb/deps/sui/balance.ts
+var import_bcs3 = require("@mysten/sui/bcs");
+var $moduleName2 = "0x2::balance";
+var Balance = new MoveStruct({ name: `${$moduleName2}::Balance`, fields: {
+  value: import_bcs3.bcs.u64()
+} });
+var Supply = new MoveStruct({ name: `${$moduleName2}::Supply`, fields: {
+  value: import_bcs3.bcs.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
+var import_bcs4 = require("@mysten/sui/bcs");
+var $moduleName4 = "bucket_v2_framework::account";
+var Account = new MoveStruct({ name: `${$moduleName4}::Account`, fields: {
+  id: UID,
+  alias: import_bcs4.bcs.option(import_bcs4.bcs.string())
+} });
+
+// src/generated/yield_usdb/buffer.ts
+var import_bcs6 = require("@mysten/sui/bcs");
+
+// src/generated/yield_usdb/deps/bucket_v2_framework/double.ts
+var import_bcs5 = require("@mysten/sui/bcs");
+var $moduleName5 = "bucket_v2_framework::double";
+var Double = new MoveStruct({ name: `${$moduleName5}::Double`, fields: {
+  value: import_bcs5.bcs.u256()
+} });
+
+// src/generated/yield_usdb/buffer.ts
+var $moduleName6 = "@local-pkg/yield_usdb.move::buffer";
+var Buffer2 = new MoveStruct({ name: `${$moduleName6}::Buffer`, fields: {
+  balance: Balance,
+  flow_rate: Double,
+  timestamp: import_bcs6.bcs.u64()
+} });
+
+// src/generated/yield_usdb/deps/sui/vec_set.ts
+var import_bcs7 = require("@mysten/sui/bcs");
+var $moduleName7 = "0x2::vec_set";
+function VecSet(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName7}::VecSet<${typeParameters[0].name}>`, fields: {
+    contents: import_bcs7.bcs.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: import_bcs8.bcs.Address,
+  max_lp_supply: import_bcs8.bcs.u64(),
+  abstract_address: import_bcs8.bcs.Address
+} });
+var MaxSupplyUpdated = new MoveStruct({ name: `${$moduleName8}::MaxSupplyUpdated`, fields: {
+  vault_id: import_bcs8.bcs.Address,
+  previous_max_lp_supply: import_bcs8.bcs.u64(),
+  current_max_lp_supply: import_bcs8.bcs.u64()
+} });
+var Minted = new MoveStruct({ name: `${$moduleName8}::Minted`, fields: {
+  vault_id: import_bcs8.bcs.Address,
+  usdb_amount: import_bcs8.bcs.u64(),
+  lp_amount: import_bcs8.bcs.u64()
+} });
+var Burned = new MoveStruct({ name: `${$moduleName8}::Burned`, fields: {
+  vault_id: import_bcs8.bcs.Address,
+  lp_amount: import_bcs8.bcs.u64(),
+  usdb_amount: import_bcs8.bcs.u64()
+} });
+var Claimed = new MoveStruct({ name: `${$moduleName8}::Claimed`, fields: {
+  vault_id: import_bcs8.bcs.Address,
+  reward_type: import_bcs8.bcs.string(),
+  reward_amount: import_bcs8.bcs.u64()
+} });
+var Collected = new MoveStruct({ name: `${$moduleName8}::Collected`, fields: {
+  vault_id: import_bcs8.bcs.Address,
+  usdb_amount: import_bcs8.bcs.u64()
+} });
+var YieldVault = new MoveStruct({ name: `${$moduleName8}::YieldVault`, fields: {
+  id: UID,
+  max_lp_supply: import_bcs8.bcs.u64(),
+  lp_treasury_cap: TreasuryCap,
+  abstract_account: Account,
+  buffer: Buffer2,
+  managers: VecSet(import_bcs8.bcs.Address),
+  versions: VecSet(import_bcs8.bcs.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
+var import_bcs15 = require("@mysten/sui/bcs");
+
+// src/generated/stable_layer/deps/std/type_name.ts
+var import_bcs9 = require("@mysten/sui/bcs");
+var $moduleName9 = "std::type_name";
+var TypeName = new MoveStruct({ name: `${$moduleName9}::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.
+     * Struct types are represented as fully qualified type names; e.g.
+     * `00000000000000000000000000000001::string::String` or
+     * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+     * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+     * 32 depending on the Move platform)
+     */
+  name: import_bcs9.bcs.string()
+} });
+
+// src/generated/stable_layer/deps/sui/vec_map.ts
+var import_bcs10 = require("@mysten/sui/bcs");
+var $moduleName10 = "0x2::vec_map";
+function Entry(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName10}::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: import_bcs10.bcs.vector(Entry(typeParameters[0], typeParameters[1]))
+  } });
+}
+
+// src/generated/stable_layer/deps/bucket_v2_framework/liability.ts
+var import_bcs11 = require("@mysten/sui/bcs");
+var $moduleName11 = "bucket_v2_framework::liability";
+var Credit = new MoveStruct({ name: `${$moduleName11}::Credit`, fields: {
+  value: import_bcs11.bcs.u64()
+} });
+var Debt = new MoveStruct({ name: `${$moduleName11}::Debt`, fields: {
+  value: import_bcs11.bcs.u64()
+} });
+
+// src/generated/stable_layer/deps/sui/vec_set.ts
+var import_bcs12 = require("@mysten/sui/bcs");
+var $moduleName12 = "0x2::vec_set";
+function VecSet2(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName12}::VecSet<${typeParameters[0].name}>`, fields: {
+    contents: import_bcs12.bcs.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: {
+  credits: VecMap(Entity, Credit),
+  debts: VecMap(Entity, Debt),
+  blacklist: VecSet2(Entity)
+} });
+
+// src/generated/stable_layer/deps/sui/object.ts
+var import_bcs13 = require("@mysten/sui/bcs");
+var $moduleName14 = "0x2::object";
+var UID2 = new MoveStruct({ name: `${$moduleName14}::UID`, fields: {
+  id: import_bcs13.bcs.Address
+} });
+
+// src/generated/stable_layer/deps/sui/balance.ts
+var import_bcs14 = require("@mysten/sui/bcs");
+var $moduleName15 = "0x2::balance";
+var Supply2 = new MoveStruct({ name: `${$moduleName15}::Supply`, fields: {
+  value: import_bcs14.bcs.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
+} });
+
+// 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: import_bcs15.bcs.string(),
+  stable_type: import_bcs15.bcs.string(),
+  factory_id: import_bcs15.bcs.Address,
+  factory_cap_id: import_bcs15.bcs.Address
+} });
+var Mint = new MoveStruct({ name: `${$moduleName17}::Mint`, fields: {
+  u_type: import_bcs15.bcs.string(),
+  stable_type: import_bcs15.bcs.string(),
+  mint_amount: import_bcs15.bcs.u64(),
+  farm_type: import_bcs15.bcs.string()
+} });
+var Burn = new MoveStruct({ name: `${$moduleName17}::Burn`, fields: {
+  u_type: import_bcs15.bcs.string(),
+  stable_type: import_bcs15.bcs.string(),
+  burn_amount: import_bcs15.bcs.u64(),
+  farm_types: import_bcs15.bcs.vector(Entity),
+  repayment_amounts: import_bcs15.bcs.vector(import_bcs15.bcs.u64())
+} });
+var StableFactoryEntity = new MoveStruct({ name: `${$moduleName17}::StableFactoryEntity`, fields: {
+  dummy_field: import_bcs15.bcs.bool()
+} });
+var StableRegistry = new MoveStruct({ name: `${$moduleName17}::StableRegistry`, fields: {
+  id: UID2,
+  versions: VecSet2(import_bcs15.bcs.u16()),
+  total_supply: import_bcs15.bcs.u64()
+} });
+var AdminCap = new MoveStruct({ name: `${$moduleName17}::AdminCap`, fields: {
+  id: UID2
+} });
+var StableFactory = new MoveStruct({ name: `${$moduleName17}::StableFactory`, fields: {
+  id: UID2,
+  treasury_cap: TreasuryCap2,
+  max_supply: import_bcs15.bcs.u64(),
+  sheet: Sheet,
+  managers: VecSet2(import_bcs15.bcs.Address)
+} });
+var FactoryCap = new MoveStruct({ name: `${$moduleName17}::FactoryCap`, fields: {
+  id: UID2,
+  factory_id: import_bcs15.bcs.Address
+} });
+function mint(options) {
+  const packageAddress = options.package ?? "@local-pkg/stable_factory.move";
+  const argumentsTypes = [
+    `${packageAddress}::stable_layer::StableRegistry`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[1]}>`
+  ];
+  const parameterNames = ["registry", "uCoin"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "stable_layer",
+    function: "mint",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function requestBurn(options) {
+  const packageAddress = options.package ?? "@local-pkg/stable_factory.move";
+  const argumentsTypes = [
+    `${packageAddress}::stable_layer::StableRegistry`,
+    `0x0000000000000000000000000000000000000000000000000000000000000002::coin::Coin<${options.typeArguments[0]}>`
+  ];
+  const parameterNames = ["registry", "stableCoin"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "stable_layer",
+    function: "request_burn",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function fulfillBurn(options) {
+  const packageAddress = options.package ?? "@local-pkg/stable_factory.move";
+  const argumentsTypes = [
+    `${packageAddress}::stable_layer::StableRegistry`,
+    `${packageAddress}::sheet::Request<${options.typeArguments[1]}, ${packageAddress}::stable_layer::StableFactoryEntity<${options.typeArguments[0]}, ${options.typeArguments[1]}>>`
+  ];
+  const parameterNames = ["registry", "burnRequest"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "stable_layer",
+    function: "fulfill_burn",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+
+// src/generated/stable_vault_farm/stable_vault_farm.ts
+var import_bcs23 = require("@mysten/sui/bcs");
+
+// src/generated/stable_vault_farm/deps/sui/object.ts
+var import_bcs16 = require("@mysten/sui/bcs");
+var $moduleName18 = "0x2::object";
+var UID3 = new MoveStruct({ name: `${$moduleName18}::UID`, fields: {
+  id: import_bcs16.bcs.Address
+} });
+
+// src/generated/stable_vault_farm/deps/std/type_name.ts
+var import_bcs17 = require("@mysten/sui/bcs");
+var $moduleName19 = "std::type_name";
+var TypeName2 = new MoveStruct({ name: `${$moduleName19}::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.
+     * Struct types are represented as fully qualified type names; e.g.
+     * `00000000000000000000000000000001::string::String` or
+     * `0000000000000000000000000000000a::module_name1::type_name1<0000000000000000000000000000000a::module_name2::type_name2<u64>>`
+     * Addresses are hex-encoded lowercase values of length ADDRESS_LENGTH (16, 20, or
+     * 32 depending on the Move platform)
+     */
+  name: import_bcs17.bcs.string()
+} });
+
+// src/generated/stable_vault_farm/deps/sui/vec_map.ts
+var import_bcs18 = require("@mysten/sui/bcs");
+var $moduleName20 = "0x2::vec_map";
+function Entry2(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName20}::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: import_bcs18.bcs.vector(Entry2(typeParameters[0], typeParameters[1]))
+  } });
+}
+
+// src/generated/stable_vault_farm/deps/bucket_v2_framework/liability.ts
+var import_bcs19 = require("@mysten/sui/bcs");
+var $moduleName21 = "bucket_v2_framework::liability";
+var Credit2 = new MoveStruct({ name: `${$moduleName21}::Credit`, fields: {
+  value: import_bcs19.bcs.u64()
+} });
+var Debt2 = new MoveStruct({ name: `${$moduleName21}::Debt`, fields: {
+  value: import_bcs19.bcs.u64()
+} });
+
+// src/generated/stable_vault_farm/deps/sui/vec_set.ts
+var import_bcs20 = require("@mysten/sui/bcs");
+var $moduleName22 = "0x2::vec_set";
+function VecSet3(...typeParameters) {
+  return new MoveStruct({ name: `${$moduleName22}::VecSet<${typeParameters[0].name}>`, fields: {
+    contents: import_bcs20.bcs.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: {
+  credits: VecMap2(Entity2, Credit2),
+  debts: VecMap2(Entity2, Debt2),
+  blacklist: VecSet3(Entity2)
+} });
+
+// src/generated/stable_vault_farm/deps/sui/table.ts
+var import_bcs21 = require("@mysten/sui/bcs");
+var $moduleName24 = "0x2::table";
+var Table = new MoveStruct({ name: `${$moduleName24}::Table`, fields: {
+  /** the ID of this table */
+  id: UID3,
+  /** the number of key-value pairs in the table */
+  size: import_bcs21.bcs.u64()
+} });
+
+// src/generated/stable_vault_farm/deps/sui/balance.ts
+var import_bcs22 = require("@mysten/sui/bcs");
+var $moduleName25 = "0x2::balance";
+var Balance2 = new MoveStruct({ name: `${$moduleName25}::Balance`, fields: {
+  value: import_bcs22.bcs.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: import_bcs23.bcs.string(),
+  amount: import_bcs23.bcs.u64(),
+  claimer: import_bcs23.bcs.Address
+} });
+var StableVaultFarmEntity = new MoveStruct({ name: `${$moduleName26}::StableVaultFarmEntity`, fields: {
+  dummy_field: import_bcs23.bcs.bool()
+} });
+var StableVaultFarmWitness = new MoveStruct({ name: `${$moduleName26}::StableVaultFarmWitness`, fields: {
+  dummy_field: import_bcs23.bcs.bool()
+} });
+var StableVaultFarm = new MoveStruct({ name: `${$moduleName26}::StableVaultFarm`, fields: {
+  id: UID3,
+  sheet: Sheet2,
+  yield_table: Table,
+  u_surplus: Balance2
+} });
+var AdminCap2 = new MoveStruct({ name: `${$moduleName26}::AdminCap`, fields: {
+  id: UID3
+} });
+function receive(options) {
+  const packageAddress = options.package ?? "@local-pkg/stable_vault_farm.move";
+  const argumentsTypes = [
+    `${packageAddress}::stable_vault_farm::StableVaultFarm<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::sheet::Loan<${options.typeArguments[1]}, ${packageAddress}::stable_layer::StableFactoryEntity<${options.typeArguments[2]}, ${options.typeArguments[1]}>, ${packageAddress}::stable_vault_farm::StableVaultFarmEntity<${options.typeArguments[0]}, ${options.typeArguments[1]}>>`,
+    `${packageAddress}::stable_vault::StableVault<${options.typeArguments[0]}, ${options.typeArguments[1]}, ${options.typeArguments[3]}>`,
+    `${packageAddress}::usdb::Treasury`,
+    `${packageAddress}::pool::Pool<${options.typeArguments[1]}>`,
+    `${packageAddress}::saving::SavingPool<${options.typeArguments[4]}>`,
+    `${packageAddress}::yield_usdb::YieldVault<${options.typeArguments[3]}, ${options.typeArguments[4]}>`,
+    `${packageAddress}::result::PriceResult<${options.typeArguments[1]}>`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["farm", "loan", "stableVault", "usdbTreasury", "psmPool", "savingPool", "yieldVault", "uPrice"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "stable_vault_farm",
+    function: "receive",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function pay(options) {
+  const packageAddress = options.package ?? "@local-pkg/stable_vault_farm.move";
+  const argumentsTypes = [
+    `${packageAddress}::stable_vault_farm::StableVaultFarm<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::sheet::Request<${options.typeArguments[1]}, ${packageAddress}::stable_layer::StableFactoryEntity<${options.typeArguments[2]}, ${options.typeArguments[1]}>>`,
+    `${packageAddress}::stable_vault::StableVault<${options.typeArguments[0]}, ${options.typeArguments[1]}, ${options.typeArguments[3]}>`,
+    `${packageAddress}::usdb::Treasury`,
+    `${packageAddress}::pool::Pool<${options.typeArguments[1]}>`,
+    `${packageAddress}::saving::SavingPool<${options.typeArguments[4]}>`,
+    `${packageAddress}::yield_usdb::YieldVault<${options.typeArguments[3]}, ${options.typeArguments[4]}>`,
+    `${packageAddress}::result::PriceResult<${options.typeArguments[1]}>`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["farm", "request", "stableVault", "usdbTreasury", "psmPool", "savingPool", "yieldVault", "uPrice"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "stable_vault_farm",
+    function: "pay",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+function claim(options) {
+  const packageAddress = options.package ?? "@local-pkg/stable_vault_farm.move";
+  const argumentsTypes = [
+    `${packageAddress}::stable_vault_farm::StableVaultFarm<${options.typeArguments[0]}, ${options.typeArguments[1]}>`,
+    `${packageAddress}::stable_layer::StableRegistry`,
+    `${packageAddress}::stable_vault::StableVault<${options.typeArguments[0]}, ${options.typeArguments[1]}, ${options.typeArguments[3]}>`,
+    `${packageAddress}::usdb::Treasury`,
+    `${packageAddress}::saving::SavingPool<${options.typeArguments[4]}>`,
+    `${packageAddress}::yield_usdb::YieldVault<${options.typeArguments[3]}, ${options.typeArguments[4]}>`,
+    "0x0000000000000000000000000000000000000000000000000000000000000002::clock::Clock"
+  ];
+  const parameterNames = ["farm", "stableRegistry", "stableVault", "usdbTreasury", "savingPool", "yieldVault"];
+  return (tx) => tx.moveCall({
+    package: packageAddress,
+    module: "stable_vault_farm",
+    function: "claim",
+    arguments: normalizeMoveArguments(options.arguments, argumentsTypes, parameterNames),
+    typeArguments: options.typeArguments
+  });
+}
+
+// src/index.ts
+var import_sdk = require("@bucket-protocol/sdk");
+var StableLayerClient = class {
+  constructor(config) {
+    this.bucketClient = new import_sdk.BucketClient({ network: config.network });
+    this.suiClient = new import_client.SuiClient({ url: (0, import_client.getFullnodeUrl)(config.network) });
+    this.sender = config.sender;
+  }
+  async buildMintTx({
+    tx,
+    lpToken,
+    usdcCoin,
+    sender,
+    autoTransfer = true
+  }) {
+    tx.setSender(sender ?? this.sender);
+    const [stableCoin, loan] = mint({
+      package: STABLE_LAYER_PACKAGE_ID,
+      arguments: {
+        registry: STABLE_REGISTRY,
+        uCoin: usdcCoin
+      },
+      typeArguments: [
+        STABLE_COIN_TYPES[lpToken],
+        USDC_TYPE,
+        STABLE_VAULT_FARM_ENTITY_TYPE
+      ]
+    })(tx);
+    const [uPrice] = await this.bucketClient.aggregatePrices(tx, {
+      coinTypes: [USDC_TYPE]
+    });
+    const depositResponse = receive({
+      package: STABLE_VAULT_FARM_PACKAGE_ID,
+      typeArguments: [
+        STABLE_LP_TYPE,
+        USDC_TYPE,
+        STABLE_COIN_TYPES[lpToken],
+        YUSDB_TYPE,
+        SAVING_TYPE
+      ],
+      arguments: {
+        farm: STABLE_VAULT_FARM,
+        loan,
+        stableVault: STABLE_VAULT,
+        usdbTreasury: this.bucketClient.treasury(tx),
+        psmPool: this.getBucketPSMPool(tx),
+        savingPool: this.getBucketSavingPool(tx),
+        yieldVault: YIELD_VAULT,
+        uPrice
+      }
+    })(tx);
+    this.checkResponse({ tx, response: depositResponse, type: "deposit" });
+    if (autoTransfer) {
+      tx.transferObjects([stableCoin], sender ?? this.sender);
+      return;
+    } else {
+      return stableCoin;
+    }
+  }
+  async buildBurnTx({
+    tx,
+    lpToken,
+    amount,
+    all,
+    sender,
+    autoTransfer = true
+  }) {
+    tx.setSender(sender ?? this.sender);
+    if (!all && !amount) {
+      throw new Error("Amount or all must be provided");
+    }
+    const btcUsdCoin = (0, import_transactions2.coinWithBalance)({
+      balance: all ? BigInt(
+        (await this.suiClient.getBalance({
+          owner: sender ?? this.sender,
+          coinType: STABLE_COIN_TYPES[lpToken]
+        })).totalBalance
+      ) : amount,
+      type: STABLE_COIN_TYPES[lpToken]
+    });
+    this.releaseRewards(tx);
+    const burnRequest = requestBurn({
+      package: STABLE_LAYER_PACKAGE_ID,
+      arguments: {
+        registry: STABLE_REGISTRY,
+        stableCoin: btcUsdCoin
+      },
+      typeArguments: [
+        STABLE_COIN_TYPES[lpToken],
+        USDC_TYPE
+      ]
+    })(tx);
+    const [uPrice] = await this.bucketClient.aggregatePrices(tx, {
+      coinTypes: [USDC_TYPE]
+    });
+    const withdrawResponse = pay({
+      package: STABLE_VAULT_FARM_PACKAGE_ID,
+      arguments: {
+        farm: STABLE_VAULT_FARM,
+        request: burnRequest,
+        stableVault: STABLE_VAULT,
+        usdbTreasury: this.bucketClient.treasury(tx),
+        psmPool: this.getBucketPSMPool(tx),
+        savingPool: this.getBucketSavingPool(tx),
+        yieldVault: YIELD_VAULT,
+        uPrice
+      },
+      typeArguments: [
+        STABLE_LP_TYPE,
+        USDC_TYPE,
+        STABLE_COIN_TYPES[lpToken],
+        YUSDB_TYPE,
+        SAVING_TYPE
+      ]
+    })(tx);
+    this.checkResponse({ tx, response: withdrawResponse, type: "withdraw" });
+    const usdcCoin = fulfillBurn({
+      package: STABLE_LAYER_PACKAGE_ID,
+      arguments: {
+        registry: STABLE_REGISTRY,
+        burnRequest
+      },
+      typeArguments: [
+        STABLE_COIN_TYPES[lpToken],
+        USDC_TYPE
+      ]
+    })(tx);
+    if (autoTransfer) {
+      tx.transferObjects([usdcCoin], sender ?? this.sender);
+      return;
+    } else {
+      return usdcCoin;
+    }
+  }
+  async buildClaimTx({
+    tx,
+    lpToken,
+    sender,
+    autoTransfer = true
+  }) {
+    tx.setSender(sender ?? this.sender);
+    this.releaseRewards(tx);
+    const [rewardCoin, withdrawResponse] = claim({
+      package: 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
+      },
+      typeArguments: [
+        STABLE_LP_TYPE,
+        USDC_TYPE,
+        STABLE_COIN_TYPES[lpToken],
+        YUSDB_TYPE,
+        SAVING_TYPE
+      ]
+    })(tx);
+    this.checkResponse({ tx, response: withdrawResponse, type: "withdraw" });
+    if (autoTransfer) {
+      tx.transferObjects([rewardCoin], sender ?? this.sender);
+      return;
+    } else {
+      return rewardCoin;
+    }
+  }
+  async getTotalSupply() {
+    const result = await this.suiClient.getObject({
+      id: STABLE_REGISTRY,
+      options: {
+        showContent: true
+      }
+    });
+    const content = result.data?.content;
+    return content?.fields?.total_supply;
+  }
+  async getTotalSupplyByCoinName(coinName) {
+    const result = await this.suiClient.getDynamicFieldObject({
+      parentId: STABLE_REGISTRY,
+      name: {
+        type: "0x1::type_name::TypeName",
+        value: STABLE_COIN_TYPES[coinName]
+      }
+    });
+    const content = result.data?.content;
+    return content?.fields?.treasury_cap?.fields?.total_supply?.fields?.value;
+  }
+  getBucketSavingPool(tx) {
+    return this.bucketClient.savingPoolObj(tx, {
+      lpType: SAVING_TYPE
+    });
+  }
+  getBucketPSMPool(tx) {
+    return this.bucketClient.psmPoolObj(tx, {
+      coinType: USDC_TYPE
+    });
+  }
+  checkResponse({
+    tx,
+    response,
+    type
+  }) {
+    if (type === "deposit") {
+      return this.bucketClient.checkDepositResponse(tx, {
+        lpType: SAVING_TYPE,
+        depositResponse: response
+      });
+    } else {
+      return this.bucketClient.checkWithdrawResponse(tx, {
+        lpType: SAVING_TYPE,
+        withdrawResponse: response
+      });
+    }
+  }
+  releaseRewards(tx) {
+    const depositResponse = release({
+      package: YIELD_USDB_PACKAGE_ID,
+      arguments: {
+        vault: YIELD_VAULT,
+        treasury: this.bucketClient.treasury(tx),
+        savingPool: this.bucketClient.savingPoolObj(tx, {
+          lpType: SAVING_TYPE
+        })
+      },
+      typeArguments: [YUSDB_TYPE, SAVING_TYPE]
+    })(tx);
+    this.bucketClient.checkDepositResponse(tx, {
+      depositResponse,
+      lpType: SAVING_TYPE
+    });
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  StableLayerClient
+});
+//# sourceMappingURL=index.cjs.map