@scallop-io/sui-scallop-sdk 0.37.3

package/dist/index.js

@@ -0,0 +1,1487 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  ADDRESSES_ID: () => ADDRESSES_ID,
+  API_BASE_URL: () => API_BASE_URL,
+  SUI_COIN_TYPE_ARG_REGEX: () => SUI_COIN_TYPE_ARG_REGEX,
+  SUPPORT_ASSET_COINS: () => SUPPORT_ASSET_COINS,
+  SUPPORT_COLLATERAL_COINS: () => SUPPORT_COLLATERAL_COINS,
+  SUPPORT_ORACLES: () => SUPPORT_ORACLES,
+  SUPPORT_PACKAGES: () => SUPPORT_PACKAGES,
+  Scallop: () => Scallop,
+  ScallopAddress: () => ScallopAddress,
+  ScallopClient: () => ScallopClient,
+  ScallopUtils: () => ScallopUtils
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/constants/common.ts
+var API_BASE_URL = "https://sui.api.scallop.io";
+var ADDRESSES_ID = "6462a088a7ace142bb6d7e9b";
+var SUPPORT_ASSET_COINS = [
+  "eth",
+  "btc",
+  "usdc",
+  "usdt",
+  "sui"
+];
+var SUPPORT_COLLATERAL_COINS = [
+  "eth",
+  "btc",
+  "usdc",
+  "usdt",
+  "sui"
+];
+var SUPPORT_ORACLES = ["supra", "switchboard", "pyth"];
+var SUPPORT_PACKAGES = [
+  "coinDecimalsRegistry",
+  "math",
+  "whitelist",
+  "x",
+  "protocol",
+  "query",
+  "supra",
+  "pyth",
+  "switchboard",
+  "xOracle",
+  "testCoin"
+];
+var SUI_COIN_TYPE_ARG_REGEX = /^0x(0*)2::sui::SUI$/;
+
+// src/models/scallop.ts
+var import_sui_kit6 = require("@scallop-io/sui-kit");
+
+// src/models/scallopAddress.ts
+var import_axios = __toESM(require("axios"));
+var ScallopAddress = class {
+  constructor(params) {
+    const { id, auth, network } = params;
+    if (auth)
+      this._auth = auth;
+    this._id = id;
+    this._network = network || "mainnet";
+    this._addressesMap = /* @__PURE__ */ new Map();
+    this._apiClient = import_axios.default.create({
+      baseURL: API_BASE_URL,
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/json"
+      },
+      timeout: 3e4
+    });
+  }
+  /**
+   * Get addresses API id.
+   *
+   * @returns The addresses API id.
+   */
+  getId() {
+    return this._id;
+  }
+  /**
+   * Get the address at the provided path.
+   *
+   * @param path - The path of the address to get.
+   * @returns The address at the provided path.
+   */
+  get(path) {
+    if (this._addresses) {
+      const value = path.split(".").reduce(
+        (nestedAddressObj, key) => typeof nestedAddressObj === "object" ? nestedAddressObj[key] : nestedAddressObj,
+        this._addresses
+      );
+      return value || void 0;
+    } else {
+      return void 0;
+    }
+  }
+  /**
+   * Set the address at the provided path.
+   *
+   * @param path - The path of the address to set.
+   * @param address - The address be setted to the tartget path.
+   * @returns The addresses.
+   */
+  set(path, address) {
+    if (this._addresses) {
+      const keys = path.split(".");
+      keys.reduce((nestedAddressObj, key, index) => {
+        if (index === keys.length - 1) {
+          nestedAddressObj[key] = address;
+        } else {
+          return nestedAddressObj[key];
+        }
+      }, this._addresses);
+    }
+    return this._addresses;
+  }
+  /**
+   * Get the addresses.
+   *
+   * @param network - Specifies which network's addresses you want to get.
+   * @returns The addresses.
+   */
+  getAddresses(network) {
+    if (network) {
+      return this._addressesMap.get(network);
+    } else {
+      return this._addresses;
+    }
+  }
+  /**
+   * Set the addresses into addresses map.
+   *
+   * @param network - Specifies which network's addresses you want to set.
+   * @param addresses - The addresses be setted to the tartget network.
+   * @returns The addresses.
+   */
+  setAddresses(network, addresses) {
+    const targetNetwork = network || this._network;
+    const targetAddresses = addresses || this._addresses || void 0;
+    if (targetAddresses) {
+      this._addressesMap.set(targetNetwork, targetAddresses);
+    } else {
+      this._addressesMap.set(targetNetwork, {
+        core: {
+          version: "",
+          versionCap: "",
+          market: "",
+          adminCap: "",
+          coinDecimalsRegistry: "",
+          coins: {
+            btc: {
+              id: "",
+              metaData: "",
+              treasury: "",
+              oracle: {
+                supra: "",
+                switchboard: "",
+                pyth: {
+                  feed: "",
+                  feedObject: ""
+                }
+              }
+            },
+            eth: {
+              id: "",
+              metaData: "",
+              treasury: "",
+              oracle: {
+                supra: "",
+                switchboard: "",
+                pyth: {
+                  feed: "",
+                  feedObject: ""
+                }
+              }
+            },
+            usdc: {
+              id: "",
+              metaData: "",
+              treasury: "",
+              oracle: {
+                supra: "",
+                switchboard: "",
+                pyth: {
+                  feed: "",
+                  feedObject: ""
+                }
+              }
+            },
+            usdt: {
+              id: "",
+              metaData: "",
+              treasury: "",
+              oracle: {
+                supra: "",
+                switchboard: "",
+                pyth: {
+                  feed: "",
+                  feedObject: ""
+                }
+              }
+            },
+            sui: {
+              id: "",
+              metaData: "",
+              treasury: "",
+              oracle: {
+                supra: "",
+                switchboard: "",
+                pyth: {
+                  feed: "",
+                  feedObject: ""
+                }
+              }
+            }
+          },
+          oracles: {
+            xOracle: "",
+            xOracleCap: "",
+            supra: {
+              registry: "",
+              registryCap: "",
+              holder: ""
+            },
+            switchboard: {
+              registry: "",
+              registryCap: ""
+            },
+            pyth: {
+              registry: "",
+              registryCap: "",
+              state: "",
+              wormhole: "",
+              wormholeState: ""
+            }
+          },
+          packages: {
+            coinDecimalsRegistry: {
+              id: "",
+              upgradeCap: ""
+            },
+            math: {
+              id: "",
+              upgradeCap: ""
+            },
+            whitelist: {
+              id: "",
+              upgradeCap: ""
+            },
+            x: {
+              id: "",
+              upgradeCap: ""
+            },
+            protocol: {
+              id: "",
+              upgradeCap: ""
+            },
+            query: {
+              id: "",
+              upgradeCap: ""
+            },
+            // Deploy by pyth on testnet
+            pyth: {
+              id: "",
+              upgradeCap: ""
+            },
+            // Deploy by ourself on testnet
+            switchboard: {
+              id: "",
+              upgradeCap: ""
+            },
+            xOracle: {
+              id: "",
+              upgradeCap: ""
+            },
+            // Deploy for faucet on testnet
+            testCoin: {
+              id: "",
+              upgradeCap: ""
+            }
+          }
+        }
+      });
+    }
+  }
+  /**
+   * Get all addresses.
+   *
+   * @returns All addresses.
+   */
+  getAllAddresses() {
+    return Object.fromEntries(this._addressesMap);
+  }
+  /**
+   * Create a new address through the API and synchronize it back to the
+   * instance. If the `network` is not specified, the mainnet is used by default.
+   * If no `addresses` is provided, an addresses with all empty strings is created
+   * by default.
+   *
+   * This function only allows for one addresses to be input into a specific network
+   * at a time, and does not provide an addresses map for setting addresses
+   * across all networks at once.
+   *
+   * @param network - Specifies which network's addresses you want to set.
+   * @param addresses - The addresses be setted to the tartget network.
+   * @param auth - The authentication API key.
+   * @returns The addresses.
+   */
+  async create(network, addresses, auth) {
+    const apiKey = auth || this._auth || void 0;
+    const targetNetwork = network || this._network;
+    const targetAddresses = addresses || this._addresses || void 0;
+    if (apiKey !== void 0) {
+      this._addressesMap.clear();
+      this.setAddresses(targetNetwork, targetAddresses);
+      const response = await this._apiClient.post(
+        `${API_BASE_URL}/addresses`,
+        JSON.stringify(Object.fromEntries(this._addressesMap)),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": auth || this._auth
+          }
+        }
+      );
+      if (response.status === 201) {
+        for (const [network2, addresses2] of Object.entries(
+          response.data
+        )) {
+          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
+            if (network2 === this._network)
+              this._addresses = addresses2;
+            this._addressesMap.set(network2, addresses2);
+          }
+        }
+        this._id = response.data.id;
+        return this._addresses;
+      } else {
+        throw Error("Failed to create addresses.");
+      }
+    } else {
+      throw Error("You don't have permission to access this request.");
+    }
+  }
+  /**
+   * It doesn't read the data stored in the address instance, but reads and
+   * synchronizes the data from the API into instance.
+   *
+   * @param id - The id of the addresses to get.
+   * @returns The addresses.
+   */
+  async read(id) {
+    const addressesId = id || this._id || void 0;
+    if (addressesId !== void 0) {
+      const response = await this._apiClient.get(
+        `${API_BASE_URL}/addresses/${addressesId}`,
+        {
+          headers: {
+            "Content-Type": "application/json"
+          }
+        }
+      );
+      if (response.status === 200) {
+        for (const [network, addresses] of Object.entries(
+          response.data
+        )) {
+          if (["localnet", "devnet", "testnet", "mainnet"].includes(network)) {
+            if (network === this._network)
+              this._addresses = addresses;
+            this._addressesMap.set(network, addresses);
+          }
+        }
+        this._id = response.data.id;
+        return this._addresses;
+      } else {
+        throw Error("Failed to create addresses.");
+      }
+    }
+  }
+  /**
+   * Update the address through the API and synchronize it back to the
+   * instance. If the `network` is not specified, the mainnet is used by default.
+   * If no `addresses` is provided, an addresses with all empty strings is created
+   * by default.
+   *
+   * This function only allows for one addresses to be input into a specific network
+   * at a time, and does not provide an addresses map for setting addresses
+   * across all networks at once.
+   *
+   * @param id - The id of the addresses to update.
+   * @param network - Specifies which network's addresses you want to set.
+   * @param addresses - The addresses be setted to the tartget network.
+   * @param auth - The authentication api key.
+   * @returns The addresses.
+   */
+  async update(id, network, addresses, auth) {
+    const apiKey = auth || this._auth || void 0;
+    const targetId = id || this._id || void 0;
+    const targetNetwork = network || this._network;
+    const targetAddresses = addresses || this._addresses || void 0;
+    if (targetId === void 0)
+      throw Error("Require addresses id.");
+    if (apiKey !== void 0) {
+      if (id !== this._id) {
+        this._addressesMap.clear();
+      }
+      this.setAddresses(targetNetwork, targetAddresses);
+      const response = await this._apiClient.put(
+        `${API_BASE_URL}/addresses/${targetId}`,
+        JSON.stringify(Object.fromEntries(this._addressesMap)),
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": auth || this._auth
+          }
+        }
+      );
+      if (response.status === 200) {
+        for (const [network2, addresses2] of Object.entries(
+          response.data
+        )) {
+          if (["localnet", "devnet", "testnet", "mainnet"].includes(network2)) {
+            if (network2 === this._network)
+              this._addresses = addresses2;
+            this._addressesMap.set(network2, addresses2);
+          }
+        }
+        this._id = response.data.id;
+        return this._addresses;
+      } else {
+        throw Error("Failed to update addresses.");
+      }
+    } else {
+      throw Error("You don't have permission to access this request.");
+    }
+  }
+  /**
+   * Deletes all addresses of a specified id through the API and synchronizes
+   * them back to the instance.
+   *
+   * @param id - The id of the addresses to delete.
+   * @param auth - The authentication API key.
+   */
+  async delete(id, auth) {
+    const apiKey = auth || this._auth || void 0;
+    const targetId = id || this._id || void 0;
+    if (targetId === void 0)
+      throw Error("Require addresses id.");
+    if (apiKey !== void 0) {
+      const response = await this._apiClient.delete(
+        `${API_BASE_URL}/addresses/${targetId}`,
+        {
+          headers: {
+            "Content-Type": "application/json",
+            "api-key": auth || this._auth
+          }
+        }
+      );
+      if (response.status === 200) {
+        this._id = void 0;
+        this._addresses = void 0;
+        this._addressesMap.clear();
+      } else {
+        throw Error("Failed to delete addresses.");
+      }
+    } else {
+      throw Error("You don't have permission to access this request.");
+    }
+  }
+};
+
+// src/models/scallopClient.ts
+var import_sui4 = require("@mysten/sui.js");
+var import_sui_kit5 = require("@scallop-io/sui-kit");
+
+// src/models/scallopUtils.ts
+var import_sui = require("@mysten/sui.js");
+var import_sui_kit = require("@scallop-io/sui-kit");
+var import_price_service_client = require("@pythnetwork/price-service-client");
+var ScallopUtils = class {
+  constructor(params) {
+    this._suiKit = new import_sui_kit.SuiKit(params);
+  }
+  /**
+   * @description Select coin id  that add up to the given amount as transaction arguments.
+   * @param owner The address of the owner.
+   * @param amount The amount that is needed for the coin.
+   * @param coinType The coin type, default is 0x2::SUI::SUI.
+   * @return The selected transaction coin arguments.
+   */
+  async selectCoins(owner, amount, coinType = import_sui.SUI_TYPE_ARG) {
+    const coins = await this._suiKit.rpcProvider.selectCoins(
+      owner,
+      amount,
+      coinType
+    );
+    return coins.map((c) => c.objectId);
+  }
+  /**
+   * @description Fetch price feed VAAs of interest from the Pyth.
+   * @param priceIds Array of hex-encoded price ids.
+   * @param isTestnet Specify whether it is a test network.
+   * @return Array of base64 encoded VAAs.
+   */
+  async getVaas(priceIds, isTestnet) {
+    const connection = new import_price_service_client.PriceServiceConnection(
+      isTestnet ? "https://xc-testnet.pyth.network" : "https://xc-mainnet.pyth.network",
+      {
+        priceFeedRequestConfig: {
+          binary: true
+        }
+      }
+    );
+    return await connection.getLatestVaas(priceIds);
+  }
+  /**
+   * @description Handle non-standard coins.
+   * @param coinPackageId Package id of coin.
+   * @param coinName specific support coin name.
+   * @return coinType.
+   */
+  parseCoinType(coinPackageId, coinName) {
+    if (coinName === "sui")
+      return (0, import_sui.normalizeStructTag)(import_sui.SUI_TYPE_ARG);
+    const wormHoleCoins = [
+      // USDC
+      "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf",
+      // USDT
+      "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c"
+    ];
+    if (wormHoleCoins.includes(coinPackageId)) {
+      return `${coinPackageId}::coin::COIN`;
+    } else {
+      return `${coinPackageId}::${coinName}::${coinName.toUpperCase()}`;
+    }
+  }
+  /**
+   * @description Handle non-standard coin names.
+   * @param coinPackageId Package id of coin.
+   * @param coinName specific support coin name.
+   * @return coinType.
+   */
+  getCoinNameFromCoinType(coinType) {
+    const wormHoleCoinTypes = [
+      // USDC
+      "0x5d4b302506645c37ff133b98c4b50a5ae14841659738d6d733d59d0d217a93bf::coin::COIN",
+      // USDT
+      "0xc060006111016b8a020ad5b33834984a437aaa7d3c74c18e09a95d48aceab08c::coin::COIN"
+    ];
+    if (coinType === wormHoleCoinTypes[0]) {
+      return "usdc";
+    } else if (coinType === wormHoleCoinTypes[1]) {
+      return "usdt";
+    } else {
+      return coinType.split("::")[2].toLowerCase();
+    }
+  }
+  /**
+   * @description Handle market coin types.
+   *
+   * @param coinPackageId Package id of coin.
+   * @param protocolPkgId Package id of protocol.
+   * @param coinName specific support coin name.
+   *
+   * @return marketCoinType.
+   */
+  parseMarketCoinType(coinPackageId, protocolPkgId, coinName) {
+    const coinType = this.parseCoinType(
+      coinName === "sui" ? import_sui.SUI_FRAMEWORK_ADDRESS : coinPackageId,
+      coinName
+    );
+    return `${protocolPkgId}::reserve::MarketCoin<${coinType}>`;
+  }
+};
+
+// src/queries/market.ts
+var import_sui_kit2 = require("@scallop-io/sui-kit");
+var queryMarket = async (scallopAddress, suiKit) => {
+  const packageId = scallopAddress.get("core.packages.query.id");
+  const marketId = scallopAddress.get("core.market");
+  const txBlock = new import_sui_kit2.SuiTxBlock();
+  const queryTarget = `${packageId}::market_query::market_data`;
+  txBlock.moveCall(queryTarget, [marketId]);
+  const queryResult = await suiKit.inspectTxn(txBlock);
+  return queryResult.events[0].parsedJson;
+};
+
+// src/queries/obligation.ts
+var import_sui_kit3 = require("@scallop-io/sui-kit");
+var queryObligation = async (obligationId, scallopAddress, suiKit) => {
+  const packageId = scallopAddress.get("core.packages.query.id");
+  const queryTarget = `${packageId}::obligation_query::obligation_data`;
+  const txBlock = new import_sui_kit3.SuiTxBlock();
+  txBlock.moveCall(queryTarget, [obligationId]);
+  const queryResult = await suiKit.inspectTxn(txBlock);
+  return queryResult.events[0].parsedJson;
+};
+var getObligations = async (ownerAddress, scallopAddress, suiKit) => {
+  const owner = ownerAddress || suiKit.currentAddress();
+  const keyObjectRefs = await suiKit.provider().getOwnedObjects({
+    owner,
+    filter: {
+      StructType: `${scallopAddress.get(
+        "core.packages.protocol.id"
+      )}::obligation::ObligationKey`
+    }
+  });
+  const keyIds = keyObjectRefs.data.map((ref) => ref?.data?.objectId).filter((id) => id !== void 0);
+  const keyObjects = await suiKit.getObjects(keyIds);
+  const obligations = [];
+  for (const keyObject of keyObjects) {
+    const keyId = keyObject.objectId;
+    const fields = keyObject.objectFields;
+    const obligationId = fields["ownership"]["fields"]["of"];
+    obligations.push({ id: obligationId, keyId });
+  }
+  return obligations;
+};
+
+// src/txBuilders/normalMethods.ts
+var import_sui2 = require("@mysten/sui.js");
+var import_sui_kit4 = require("@scallop-io/sui-kit");
+var scallopNormalMethodsHandler = {
+  openObligation: ({ txBlock, coreIds }) => () => txBlock.moveCall(
+    `${coreIds.protocolPkg}::open_obligation::open_obligation`,
+    [coreIds.version]
+  ),
+  returnObligation: ({ txBlock, coreIds }) => (obligation, obligationHotPotato) => txBlock.moveCall(
+    `${coreIds.protocolPkg}::open_obligation::return_obligation`,
+    [coreIds.version, obligation, obligationHotPotato]
+  ),
+  openObligationEntry: ({ txBlock, coreIds }) => () => txBlock.moveCall(
+    `${coreIds.protocolPkg}::open_obligation::open_obligation_entry`,
+    [coreIds.version]
+  ),
+  addCollateral: ({ txBlock, coreIds, scallopUtils, scallopAddress }) => (obligation, coin, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::deposit_collateral::deposit_collateral`,
+      [coreIds.version, obligation, coreIds.market, coin],
+      [coinType]
+    );
+  },
+  takeCollateral: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (obligation, obligationKey, amount, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::withdraw_collateral::withdraw_collateral`,
+      [
+        coreIds.version,
+        obligation,
+        obligationKey,
+        coreIds.market,
+        coreIds.dmlR,
+        amount,
+        coreIds.oracle,
+        import_sui2.SUI_CLOCK_OBJECT_ID
+      ],
+      [coinType]
+    );
+  },
+  deposit: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (coin, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::mint::mint`,
+      [coreIds.version, coreIds.market, coin, import_sui2.SUI_CLOCK_OBJECT_ID],
+      [coinType]
+    );
+  },
+  depositEntry: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (coin, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::mint::mint_entry`,
+      [coreIds.version, coreIds.market, coin, import_sui2.SUI_CLOCK_OBJECT_ID],
+      [coinType]
+    );
+  },
+  withdraw: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (marketCoin, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::redeem::redeem`,
+      [coreIds.version, coreIds.market, marketCoin, import_sui2.SUI_CLOCK_OBJECT_ID],
+      [coinType]
+    );
+  },
+  withdrawEntry: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (marketCoin, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::redeem::redeem_entry`,
+      [coreIds.version, coreIds.market, marketCoin, import_sui2.SUI_CLOCK_OBJECT_ID],
+      [coinType]
+    );
+  },
+  borrow: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (obligation, obligationKey, amount, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::borrow::borrow`,
+      [
+        coreIds.version,
+        obligation,
+        obligationKey,
+        coreIds.market,
+        coreIds.dmlR,
+        amount,
+        coreIds.oracle,
+        import_sui2.SUI_CLOCK_OBJECT_ID
+      ],
+      [coinType]
+    );
+  },
+  borrowEntry: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (obligation, obligationKey, amount, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::borrow::borrow_entry`,
+      [
+        coreIds.version,
+        obligation,
+        obligationKey,
+        coreIds.market,
+        coreIds.dmlR,
+        amount,
+        coreIds.oracle,
+        import_sui2.SUI_CLOCK_OBJECT_ID
+      ],
+      [coinType]
+    );
+  },
+  repay: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (obligation, coin, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::repay::repay`,
+      [
+        coreIds.version,
+        obligation,
+        coreIds.market,
+        coin,
+        import_sui2.SUI_CLOCK_OBJECT_ID
+      ],
+      [coinType]
+    );
+  },
+  borrowFlashLoan: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (amount, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::flash_loan::borrow_flash_loan`,
+      [coreIds.version, coreIds.market, amount],
+      [coinType]
+    );
+  },
+  repayFlashLoan: ({ txBlock, coreIds, scallopAddress, scallopUtils }) => (coin, loan, coinName) => {
+    const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+    const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+    return txBlock.moveCall(
+      `${coreIds.protocolPkg}::flash_loan::repay_flash_loan`,
+      [coreIds.version, coreIds.market, coin, loan],
+      [coinType]
+    );
+  }
+};
+var newTxBlock = (scallopAddress, scallopUtils) => {
+  const coreIds = {
+    protocolPkg: scallopAddress.get("core.packages.protocol.id"),
+    market: scallopAddress.get("core.market"),
+    version: scallopAddress.get("core.version"),
+    dmlR: scallopAddress.get("core.coinDecimalsRegistry"),
+    oracle: scallopAddress.get("core.oracles.xOracle")
+  };
+  const txBlock = new import_sui_kit4.SuiTxBlock();
+  const txBlockProxy = new Proxy(txBlock, {
+    get: (target, prop) => {
+      if (prop in scallopNormalMethodsHandler) {
+        return scallopNormalMethodsHandler[prop]({
+          txBlock: target,
+          coreIds,
+          scallopAddress,
+          scallopUtils
+        });
+      }
+      return target[prop];
+    }
+  });
+  return txBlockProxy;
+};
+
+// src/txBuilders/oracle.ts
+var import_bcs = require("@mysten/bcs");
+var import_sui3 = require("@mysten/sui.js");
+var updateOraclesForWithdrawCollateral = async (txBlock, address, scallopUtils, suiKit, obligationId, isTestnet) => {
+  const obligationCoinNames = await getObligationCoinNames(
+    suiKit,
+    obligationId,
+    address,
+    scallopUtils
+  );
+  return updateOracles(
+    txBlock,
+    address,
+    scallopUtils,
+    obligationCoinNames,
+    isTestnet
+  );
+};
+var updateOraclesForBorrow = async (txBlock, address, scallopUtils, suiKit, obligationId, borrowCoinName, isTestnet) => {
+  const obligationCoinNames = await getObligationCoinNames(
+    suiKit,
+    obligationId,
+    address,
+    scallopUtils
+  );
+  const updateCoinNames = [
+    .../* @__PURE__ */ new Set([...obligationCoinNames, borrowCoinName])
+  ];
+  return updateOracles(
+    txBlock,
+    address,
+    scallopUtils,
+    updateCoinNames,
+    isTestnet
+  );
+};
+var getObligationCoinNames = async (suiKit, obligationId, address, scallopUtils) => {
+  const obligation = await queryObligation(obligationId, address, suiKit);
+  const collateralCoinTypes = obligation.collaterals.map((collateral) => {
+    return `0x${collateral.type.name}`;
+  });
+  const debtCoinTypes = obligation.debts.map((debt) => {
+    return `0x${debt.type.name}`;
+  });
+  const obligationCoinTypes = [
+    .../* @__PURE__ */ new Set([...collateralCoinTypes, ...debtCoinTypes])
+  ];
+  const obligationCoinNames = obligationCoinTypes.map((coinType) => {
+    return scallopUtils.getCoinNameFromCoinType(coinType);
+  });
+  return obligationCoinNames;
+};
+var updateOracles = async (txBlock, address, scallopUtils, coinNames, isTestnet) => {
+  const updateCoinTypes = [...new Set(coinNames)];
+  for (const coinName of updateCoinTypes) {
+    await updateOracle(txBlock, address, scallopUtils, coinName, isTestnet);
+  }
+};
+var updateOracle = async (txBlock, address, scallopUtils, coinName, isTestnet) => {
+  const coinPackageId = address.get(`core.coins.${coinName}.id`);
+  const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+  const [vaaFromFeeId] = await scallopUtils.getVaas(
+    [address.get(`core.coins.${coinName}.oracle.pyth.feed`)],
+    isTestnet
+  );
+  updatePrice(
+    txBlock,
+    isTestnet ? ["pyth"] : ["pyth"],
+    address.get("core.packages.xOracle.id"),
+    address.get("core.oracles.xOracle"),
+    address.get("core.packages.pyth.id"),
+    address.get("core.oracles.pyth.registry"),
+    address.get("core.oracles.pyth.state"),
+    address.get("core.oracles.pyth.wormholeState"),
+    address.get(`core.coins.${coinName}.oracle.pyth.feedObject`),
+    vaaFromFeeId,
+    address.get("core.packages.switchboard.id"),
+    address.get("core.oracles.switchboard.registry"),
+    address.get(`core.coins.${coinName}.oracle.switchboard`),
+    address.get("core.packages.supra.id"),
+    address.get("core.oracles.supra.registry"),
+    address.get(`core.oracles.supra.holder`),
+    coinType
+  );
+};
+function updatePrice(txBlock, rules, xOraclePackageId, xOracleId, pythPackageId, pythRegistryId, pythStateId, pythWormholeStateId, pythFeedObjectId, pythVaaFromFeeId, switchboardPackageId, switchboardRegistryId, switchboardAggregatorId, supraPackageId, supraRegistryId, supraHolderId, coinType) {
+  const request = priceUpdateRequest(
+    txBlock,
+    xOraclePackageId,
+    xOracleId,
+    coinType
+  );
+  if (rules.includes("pyth")) {
+    updatePythPrice(
+      txBlock,
+      pythPackageId,
+      request,
+      pythStateId,
+      pythWormholeStateId,
+      pythFeedObjectId,
+      pythVaaFromFeeId,
+      pythRegistryId,
+      coinType
+    );
+  }
+  if (rules.includes("switchboard")) {
+    updateSwitchboardPrice(
+      txBlock,
+      switchboardPackageId,
+      request,
+      switchboardAggregatorId,
+      switchboardRegistryId,
+      coinType
+    );
+  }
+  if (rules.includes("supra")) {
+    updateSupraPrice(
+      txBlock,
+      supraPackageId,
+      request,
+      supraHolderId,
+      supraRegistryId,
+      coinType
+    );
+  }
+  confirmPriceUpdateRequest(
+    txBlock,
+    xOraclePackageId,
+    xOracleId,
+    request,
+    coinType
+  );
+  return txBlock;
+}
+function priceUpdateRequest(txBlock, packageId, xOracleId, coinType) {
+  const target = `${packageId}::x_oracle::price_update_request`;
+  const typeArgs = [coinType];
+  return txBlock.moveCall(target, [xOracleId], typeArgs);
+}
+function confirmPriceUpdateRequest(txBlock, packageId, xOracleId, request, coinType) {
+  const target = `${packageId}::x_oracle::confirm_price_update_request`;
+  const typeArgs = [coinType];
+  txBlock.moveCall(target, [xOracleId, request, import_sui3.SUI_CLOCK_OBJECT_ID], typeArgs);
+  return txBlock;
+}
+function updateSupraPrice(txBlock, packageId, request, holderId, registryId, coinType) {
+  txBlock.moveCall(
+    `${packageId}::rule::set_price`,
+    [request, holderId, registryId, import_sui3.SUI_CLOCK_OBJECT_ID],
+    [coinType]
+  );
+}
+function updateSwitchboardPrice(txBlock, packageId, request, aggregatorId, registryId, coinType) {
+  txBlock.moveCall(
+    `${packageId}::rule::set_price`,
+    [request, aggregatorId, registryId, import_sui3.SUI_CLOCK_OBJECT_ID],
+    [coinType]
+  );
+}
+function updatePythPrice(txBlock, packageId, request, stateId, wormholeStateId, feedObjectId, vaaFromFeeId, registryId, coinType) {
+  const [updateFee] = txBlock.splitSUIFromGas([1]);
+  txBlock.moveCall(
+    `${packageId}::rule::set_price`,
+    [
+      request,
+      wormholeStateId,
+      stateId,
+      feedObjectId,
+      registryId,
+      txBlock.pure([...(0, import_bcs.fromB64)(vaaFromFeeId)]),
+      updateFee,
+      import_sui3.SUI_CLOCK_OBJECT_ID
+    ],
+    [coinType]
+  );
+}
+
+// src/txBuilders/coin.ts
+var selectCoin = async (txBlock, scallopAddress, scallopUtils, coinName, amount, sender) => {
+  const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+  const coinType = scallopUtils.parseCoinType(coinPackageId, coinName);
+  const coins = await scallopUtils.selectCoins(sender, amount, coinType);
+  const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(coins, amount);
+  return { takeCoin, leftCoin };
+};
+var selectMarketCoin = async (txBlock, scallopAddress, scallopUtils, coinName, amount, sender) => {
+  const coinPackageId = scallopAddress.get(`core.coins.${coinName}.id`);
+  const protocolPackageId = scallopAddress.get("core.packages.protocol.id");
+  const coinType = scallopUtils.parseMarketCoinType(
+    coinPackageId,
+    protocolPackageId,
+    coinName
+  );
+  const coins = await scallopUtils.selectCoins(sender, amount, coinType);
+  const [takeCoin, leftCoin] = txBlock.takeAmountFromCoins(coins, amount);
+  return { takeCoin, leftCoin };
+};
+
+// src/txBuilders/quickMethods.ts
+var requireSender = (txBlock) => {
+  const sender = txBlock.blockData.sender;
+  if (!sender) {
+    throw new Error("Sender is required");
+  }
+  return sender;
+};
+var requireObligationInfo = async (...args) => {
+  const [txBlock, scallopAddress, suiKit, obligationId, obligationKey] = args;
+  if (args.length === 4 && obligationId)
+    return { obligationId };
+  if (args.length === 5 && obligationId && obligationKey)
+    return { obligationId, obligationKey };
+  const sender = requireSender(txBlock);
+  const obligations = await getObligations(sender, scallopAddress, suiKit);
+  if (obligations.length === 0) {
+    throw new Error(`No obligation found for sender ${sender}`);
+  }
+  return {
+    obligationId: obligations[0].id,
+    obligationKey: obligations[0].keyId
+  };
+};
+var scallopQuickMethodsHandler = {
+  addCollateralQuick: ({ txBlock, scallopAddress, scallopUtils, suiKit }) => async (amount, coinName, obligationId) => {
+    const sender = requireSender(txBlock);
+    const { obligationId: obligationArg } = await requireObligationInfo(
+      txBlock,
+      scallopAddress,
+      suiKit,
+      obligationId
+    );
+    if (coinName === "sui") {
+      const [suiCoin] = txBlock.splitSUIFromGas([amount]);
+      txBlock.addCollateral(obligationArg, suiCoin, coinName);
+    } else {
+      const { leftCoin, takeCoin } = await selectCoin(
+        txBlock,
+        scallopAddress,
+        scallopUtils,
+        coinName,
+        amount,
+        sender
+      );
+      txBlock.addCollateral(obligationArg, takeCoin, coinName);
+      txBlock.transferObjects([leftCoin], sender);
+    }
+  },
+  takeCollateralQuick: ({ txBlock, suiKit, scallopUtils, scallopAddress, isTestnet }) => async (amount, coinName, obligationId, obligationKey) => {
+    const { obligationId: obligationArg, obligationKey: obligationKeyArg } = await requireObligationInfo(
+      txBlock,
+      scallopAddress,
+      suiKit,
+      obligationId,
+      obligationKey
+    );
+    await updateOraclesForWithdrawCollateral(
+      txBlock,
+      scallopAddress,
+      scallopUtils,
+      suiKit,
+      obligationArg,
+      isTestnet
+    );
+    return txBlock.takeCollateral(
+      obligationArg,
+      obligationKeyArg,
+      amount,
+      coinName
+    );
+  },
+  depositQuick: ({ txBlock, scallopUtils, scallopAddress }) => async (amount, coinName) => {
+    const sender = requireSender(txBlock);
+    if (coinName === "sui") {
+      const [suiCoin] = txBlock.splitSUIFromGas([amount]);
+      return txBlock.deposit(suiCoin, coinName);
+    } else {
+      const { leftCoin, takeCoin } = await selectCoin(
+        txBlock,
+        scallopAddress,
+        scallopUtils,
+        coinName,
+        amount,
+        sender
+      );
+      txBlock.transferObjects([leftCoin], sender);
+      return txBlock.deposit(takeCoin, coinName);
+    }
+  },
+  withdrawQuick: ({ txBlock, scallopUtils, scallopAddress }) => async (amount, coinName) => {
+    const sender = requireSender(txBlock);
+    const { leftCoin, takeCoin } = await selectMarketCoin(
+      txBlock,
+      scallopAddress,
+      scallopUtils,
+      coinName,
+      amount,
+      sender
+    );
+    txBlock.transferObjects([leftCoin], sender);
+    return txBlock.withdraw(takeCoin, coinName);
+  },
+  borrowQuick: ({ txBlock, suiKit, scallopUtils, scallopAddress, isTestnet }) => async (amount, coinName, obligationId, obligationKey) => {
+    const { obligationId: obligationArg, obligationKey: obligationKeyArg } = await requireObligationInfo(
+      txBlock,
+      scallopAddress,
+      suiKit,
+      obligationId,
+      obligationKey
+    );
+    await updateOraclesForBorrow(
+      txBlock,
+      scallopAddress,
+      scallopUtils,
+      suiKit,
+      obligationArg,
+      coinName,
+      isTestnet
+    );
+    return txBlock.borrow(
+      obligationArg,
+      obligationKeyArg,
+      amount,
+      coinName
+    );
+  },
+  repayQuick: ({ txBlock, suiKit, scallopUtils, scallopAddress }) => async (amount, coinName, obligationId) => {
+    const sender = requireSender(txBlock);
+    const { obligationId: obligationArg } = await requireObligationInfo(
+      txBlock,
+      scallopAddress,
+      suiKit,
+      obligationId
+    );
+    if (coinName === "sui") {
+      const [suiCoin] = txBlock.splitSUIFromGas([amount]);
+      return txBlock.repay(obligationArg, suiCoin, coinName);
+    } else {
+      const { leftCoin, takeCoin } = await selectCoin(
+        txBlock,
+        scallopAddress,
+        scallopUtils,
+        coinName,
+        amount,
+        sender
+      );
+      txBlock.transferObjects([leftCoin], sender);
+      return txBlock.repay(obligationArg, takeCoin, coinName);
+    }
+  },
+  updateAssetPricesQuick: ({ txBlock, scallopUtils, scallopAddress, isTestnet }) => async (coinNames) => {
+    return updateOracles(
+      txBlock,
+      scallopAddress,
+      scallopUtils,
+      coinNames,
+      isTestnet
+    );
+  }
+};
+var newScallopTxBlock = (suiKit, scallopAddress, scallopUtils, isTestnet) => {
+  const txBlock = newTxBlock(scallopAddress, scallopUtils);
+  const txBlockProxy = new Proxy(txBlock, {
+    get: (target, prop) => {
+      if (prop in scallopQuickMethodsHandler) {
+        return scallopQuickMethodsHandler[prop]({
+          txBlock: target,
+          suiKit,
+          scallopAddress,
+          scallopUtils,
+          isTestnet
+        });
+      }
+      return target[prop];
+    }
+  });
+  return txBlockProxy;
+};
+
+// src/models/scallopClient.ts
+var ScallopClient = class {
+  constructor(params, address, walletAddress, isTestnet) {
+    this.suiKit = new import_sui_kit5.SuiKit(params);
+    this.address = address;
+    this.walletAddress = (0, import_sui4.normalizeSuiAddress)(
+      walletAddress || this.suiKit.currentAddress()
+    );
+    this._utils = new ScallopUtils(params);
+    this._isTestnet = isTestnet || (params.networkType ? params.networkType === "testnet" : false);
+  }
+  createTxBlock() {
+    return newScallopTxBlock(
+      this.suiKit,
+      this.address,
+      this._utils,
+      this._isTestnet
+    );
+  }
+  /**
+   * Query market data.
+   *
+   * @return Market data
+   */
+  async queryMarket() {
+    return queryMarket(this.address, this.suiKit);
+  }
+  /**
+   * Query obligations data.
+   *
+   * @param ownerAddress - The owner address.
+   * @return Obligations data
+   */
+  async getObligations(ownerAddress) {
+    const owner = ownerAddress || this.walletAddress;
+    return getObligations(owner, this.address, this.suiKit);
+  }
+  /**
+   * Query obligation data.
+   *
+   * @param obligationId - The obligation id from protocol package.
+   * @return Obligation data
+   */
+  async queryObligation(obligationId) {
+    return queryObligation(obligationId, this.address, this.suiKit);
+  }
+  async openObligation(sign = true) {
+    const txBlock = this.createTxBlock();
+    txBlock.openObligationEntry();
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  async depositCollateral(coinName, amount, sign = true, obligationId, walletAddress) {
+    const txBlock = this.createTxBlock();
+    const sender = walletAddress || this.walletAddress;
+    txBlock.setSender(sender);
+    if (obligationId) {
+      await txBlock.addCollateralQuick(amount, coinName, obligationId);
+    } else {
+      const [obligation, obligationKey, hotPotato] = txBlock.openObligation();
+      await txBlock.addCollateralQuick(amount, coinName, obligation);
+      txBlock.returnObligation(obligation, hotPotato);
+      txBlock.transferObjects([obligationKey], sender);
+    }
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  /**
+   * Withdraw collateral from the specific pool.
+   *
+   * @param coinName - Types of collateral coin.
+   * @param amount - The amount of coins would deposit.
+   * @param sign - Decide to directly sign the transaction or return the transaction block.
+   * @param obligationId - The obligation object.
+   * @param obligationKey - The obligation key object to verifying obligation authority.
+   * @param walletAddress - The wallet address of the owner.
+   * @return Transaction block response or transaction block
+   */
+  async withdrawCollateral(coinName, amount, sign = true, obligationId, obligationKey, walletAddress) {
+    const txBlock = this.createTxBlock();
+    const sender = walletAddress || this.walletAddress;
+    txBlock.setSender(sender);
+    const collateralCoin = await txBlock.takeCollateralQuick(
+      amount,
+      coinName,
+      obligationId,
+      obligationKey
+    );
+    txBlock.transferObjects([collateralCoin], sender);
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  async deposit(coinName, amount, sign = true, walletAddress) {
+    const txBlock = this.createTxBlock();
+    const sender = walletAddress || this.walletAddress;
+    txBlock.setSender(sender);
+    const marketCoin = await txBlock.depositQuick(amount, coinName);
+    txBlock.transferObjects([marketCoin], sender);
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  async withdraw(coinName, amount, sign = true, walletAddress) {
+    const txBlock = this.createTxBlock();
+    const sender = walletAddress || this.walletAddress;
+    txBlock.setSender(sender);
+    const coin = await txBlock.withdrawQuick(amount, coinName);
+    txBlock.transferObjects([coin], sender);
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  /**
+   * borrow asset from the specific pool.
+   *
+   * @param coinName - Types of asset coin.
+   * @param amount - The amount of coins would borrow.
+   * @param sign - Decide to directly sign the transaction or return the transaction block.
+   * @param obligationId - The obligation object.
+   * @param obligationKey - The obligation key object to verifying obligation authority.
+   * @param walletAddress - The wallet address of the owner.
+   * @return Transaction block response or transaction block
+   */
+  async borrow(coinName, amount, sign = true, obligationId, obligationKey, walletAddress) {
+    const txBlock = this.createTxBlock();
+    const sender = walletAddress || this.walletAddress;
+    txBlock.setSender(sender);
+    const coin = await txBlock.borrowQuick(
+      amount,
+      coinName,
+      obligationId,
+      obligationKey
+    );
+    txBlock.transferObjects([coin], sender);
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  /**
+   * Repay asset into the specific pool.
+   *
+   * @param coinName - Types of asset coin.
+   * @param amount - The amount of coins would repay.
+   * @param sign - Decide to directly sign the transaction or return the transaction block.
+   * @param obligationId - The obligation object.
+   * @param walletAddress - The wallet address of the owner.
+   * @return Transaction block response or transaction block
+   */
+  async repay(coinName, amount, sign = true, obligationId, walletAddress) {
+    const txBlock = this.createTxBlock();
+    const sender = walletAddress || this.walletAddress;
+    txBlock.setSender(sender);
+    await txBlock.repayQuick(amount, coinName, obligationId);
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  async flashLoan(coinName, amount, callback, sign = true) {
+    const txBlock = this.createTxBlock();
+    const [coin, loan] = txBlock.borrowFlashLoan(amount, coinName);
+    txBlock.repayFlashLoan(callback(txBlock, coin), loan, coinName);
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+  async mintTestCoin(coinName, amount, sign = true, receiveAddress) {
+    if (!this._isTestnet) {
+      throw new Error("Only be used on the test network.");
+    }
+    const txBlock = this.createTxBlock();
+    const recipient = receiveAddress || this.walletAddress;
+    const packageId = this.address.get("core.packages.testCoin.id");
+    const treasuryId = this.address.get(`core.coins.${coinName}.treasury`);
+    const target = `${packageId}::${coinName}::mint`;
+    const coin = txBlock.moveCall(target, [treasuryId, amount]);
+    txBlock.transferObjects([coin], recipient);
+    if (sign) {
+      return await this.suiKit.signAndSendTxn(
+        txBlock
+      );
+    } else {
+      return txBlock.txBlock;
+    }
+  }
+};
+
+// src/models/scallop.ts
+var Scallop = class {
+  constructor(params) {
+    this.params = params;
+    this.suiKit = new import_sui_kit6.SuiKit(params);
+    this.address = new ScallopAddress({
+      id: ADDRESSES_ID,
+      network: params?.networkType
+    });
+  }
+  /**
+   * Create an instance to operate the transaction block, making it more convenient to organize transaction combinations.
+   * @return Scallop Transaction Builder
+   */
+  async createTxBuilder() {
+    await this.address.read();
+    const scallopUtils = new ScallopUtils(this.params);
+    const suiKit = new import_sui_kit6.SuiKit(this.params);
+    const isTestnet = this.params.networkType === "testnet";
+    return {
+      createTxBlock: () => {
+        return newScallopTxBlock(suiKit, this.address, scallopUtils, isTestnet);
+      },
+      signAndSendTxBlock: (txBlock) => {
+        return suiKit.signAndSendTxn(txBlock);
+      }
+    };
+  }
+  /**
+   * Create an instance to collect the addresses, making it easier to get object addresses from lending contract.
+   *
+   * @param id - The API id of the addresses.
+   * @param auth - The authentication API key.
+   * @param network - Specifies which network's addresses you want to set.
+   * @return Scallop Address
+   */
+  createAddress(id, auth, network) {
+    return new ScallopAddress({ id, auth, network });
+  }
+  /**
+   * Create an instance that provides contract interaction operations for general users.
+   *
+   * @param walletAddress - When user cannot provide a secret key or mnemonic, the scallop client cannot directly derive the address of the transaction the user wants to sign. This argument specifies the wallet address for signing the transaction.
+   * @return Scallop Client
+   */
+  async createScallopClient(walletAddress) {
+    await this.address.read();
+    return new ScallopClient(this.params, this.address, walletAddress);
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADDRESSES_ID,
+  API_BASE_URL,
+  SUI_COIN_TYPE_ARG_REGEX,
+  SUPPORT_ASSET_COINS,
+  SUPPORT_COLLATERAL_COINS,
+  SUPPORT_ORACLES,
+  SUPPORT_PACKAGES,
+  Scallop,
+  ScallopAddress,
+  ScallopClient,
+  ScallopUtils
+});
+//# sourceMappingURL=index.js.map