@curvefi/llamalend-api 1.0.21 → 1.0.22-beta.1

package/src/mintMarkets/mintMarketConstructor.ts

@@ -1,5 +1,6 @@
 import { MintMarketTemplate} from "./MintMarketTemplate";
+import type { Llamalend } from "../llamalend.js";
 
-export const getMintMarket = (mintMarketId: string): MintMarketTemplate => {
-    return new MintMarketTemplate(mintMarketId)
+export const getMintMarket = function (this: Llamalend, mintMarketId: string): MintMarketTemplate {
+    return new MintMarketTemplate(mintMarketId, this)
 }

package/src/st-crvUSD.ts

@@ -10,235 +10,236 @@ import {
     getBalances,
     MAX_ALLOWANCE,
 } from "./utils.js";
-import { llamalend } from "./llamalend.js";
+import type { Llamalend } from "./llamalend.js";
 import { TAmount, TGas } from "./interfaces.js";
 
 // ---------------- UTILS ----------------
 
-export const convertToShares = async (assets: TAmount): Promise<string> => {
+export async function convertToShares(this: Llamalend, assets: TAmount): Promise<string> {
     const _assets = parseUnits(assets);
-    const _shares = await llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract.convertToShares(_assets);
+    const _shares = await this.contracts[this.constants.ALIASES.st_crvUSD].contract.convertToShares(_assets);
 
-    return llamalend.formatUnits(_shares);
+    return this.formatUnits(_shares);
 }
 
-export const convertToAssets = async (shares: TAmount): Promise<string> => {
+export async function convertToAssets(this: Llamalend, shares: TAmount): Promise<string> {
     const _shares = parseUnits(shares);
-    const _assets = await llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract.convertToAssets(_shares);
+    const _assets = await this.contracts[this.constants.ALIASES.st_crvUSD].contract.convertToAssets(_shares);
 
-    return llamalend.formatUnits(_assets);
+    return this.formatUnits(_assets);
 }
 
 // ---------------- BALANCES ----------------
 
-export const userBalances = async (address = llamalend.signerAddress): Promise<{ "crvUSD": string, "st_crvUSD": string }> => {
-    const rawBalances = await getBalances([llamalend.constants.ALIASES.crvUSD, llamalend.constants.ALIASES.st_crvUSD], address);
+export async function userBalances(this: Llamalend, address = ""): Promise<{ "crvUSD": string, "st_crvUSD": string }> {
+    address = address || this.signerAddress;
+    const rawBalances = await getBalances.call(this, [this.constants.ALIASES.crvUSD, this.constants.ALIASES.st_crvUSD], address);
     return {
         "crvUSD": rawBalances[0],
         "st_crvUSD": rawBalances[1],
     }
 }
 
-export const totalSupplyAndCrvUSDLocked = async (): Promise<{ "crvUSD": string, "st_crvUSD": string }> => {
-    const contract = llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract;
+export async function totalSupplyAndCrvUSDLocked(this: Llamalend): Promise<{ "crvUSD": string, "st_crvUSD": string }> {
+    const contract = this.contracts[this.constants.ALIASES.st_crvUSD].contract;
     const _totalSupply = await contract.totalSupply();
     const _crvUSDLocked = await contract.convertToAssets(_totalSupply)
     return {
-        "crvUSD": llamalend.formatUnits(_crvUSDLocked),
-        "st_crvUSD": llamalend.formatUnits(_totalSupply),
+        "crvUSD": this.formatUnits(_crvUSDLocked),
+        "st_crvUSD": this.formatUnits(_totalSupply),
     }
 }
 
 // ---------------- DEPOSIT ----------------
 
-export const maxDeposit = async (address = ""): Promise<string> => {
-    address = _getAddress(address);
-    const _assets = await llamalend.contracts[llamalend.constants.ALIASES.crvUSD].contract.balanceOf(address);
+export async function maxDeposit(this: Llamalend, address = ""): Promise<string> {
+    address = _getAddress.call(this, address);
+    const _assets = await this.contracts[this.constants.ALIASES.crvUSD].contract.balanceOf(address);
 
     return formatUnits(_assets);
 }
 
-export const previewDeposit = async (assets: TAmount): Promise<string> => {
+export async function previewDeposit(this: Llamalend, assets: TAmount): Promise<string> {
     const _assets = parseUnits(assets);
-    const _shares = await llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract.previewDeposit(_assets);
+    const _shares = await this.contracts[this.constants.ALIASES.st_crvUSD].contract.previewDeposit(_assets);
 
-    return llamalend.formatUnits(_shares);
+    return this.formatUnits(_shares);
 }
 
-export const depositIsApproved = async(assets: TAmount): Promise<boolean> => {
-    return await hasAllowance([llamalend.constants.ALIASES.crvUSD], [assets], llamalend.signerAddress, llamalend.constants.ALIASES.st_crvUSD);
+export async function depositIsApproved(this: Llamalend, assets: TAmount): Promise<boolean> {
+    return await hasAllowance.call(this, [this.constants.ALIASES.crvUSD], [assets], this.signerAddress, this.constants.ALIASES.st_crvUSD);
 }
 
-export const depositAllowance = async(): Promise<string[]> => {
-    return await getAllowance([llamalend.constants.ALIASES.crvUSD], llamalend.signerAddress, llamalend.constants.ALIASES.st_crvUSD);
+export async function depositAllowance(this: Llamalend): Promise<string[]> {
+    return await getAllowance.call(this, [this.constants.ALIASES.crvUSD], this.signerAddress, this.constants.ALIASES.st_crvUSD);
 }
 
-export const depositApproveEstimateGas = async (assets: TAmount): Promise<TGas> => {
-    return await ensureAllowanceEstimateGas([llamalend.constants.ALIASES.crvUSD], [assets], llamalend.constants.ALIASES.st_crvUSD);
+export async function depositApproveEstimateGas(this: Llamalend, assets: TAmount): Promise<TGas> {
+    return await ensureAllowanceEstimateGas.call(this, [this.constants.ALIASES.crvUSD], [assets], this.constants.ALIASES.st_crvUSD);
 }
 
-export const depositApprove = async (assets: TAmount, isMax = true): Promise<string[]> => {
-    return await ensureAllowance([llamalend.constants.ALIASES.crvUSD], [assets], llamalend.constants.ALIASES.st_crvUSD, isMax);
+export async function depositApprove(this: Llamalend, assets: TAmount, isMax = true): Promise<string[]> {
+    return await ensureAllowance.call(this, [this.constants.ALIASES.crvUSD], [assets], this.constants.ALIASES.st_crvUSD, isMax);
 }
 
-const _deposit = async (assets: TAmount, estimateGas = false): Promise<string | TGas> => {
+async function _deposit(this: Llamalend, assets: TAmount, estimateGas = false): Promise<string | TGas> {
     const _assets = parseUnits(assets);
-    const contract = llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract;
-    const gas = await contract.deposit.estimateGas(_assets, llamalend.signerAddress, { ...llamalend.constantOptions });
+    const contract = this.contracts[this.constants.ALIASES.st_crvUSD].contract;
+    const gas = await contract.deposit.estimateGas(_assets, this.signerAddress, { ...this.constantOptions });
     if (estimateGas) return smartNumber(gas);
 
-    await llamalend.updateFeeData();
+    await this.updateFeeData();
 
     const gasLimit = _mulBy1_3(DIGas(gas));
 
-    return (await contract.deposit(_assets, llamalend.signerAddress, { ...llamalend.options, gasLimit })).hash;
+    return (await contract.deposit(_assets, this.signerAddress, { ...this.options, gasLimit })).hash;
 }
 
-export const depositEstimateGas = async (assets: TAmount): Promise<TGas> => {
-    if (!(await depositIsApproved(assets))) throw Error("Approval is needed for gas estimation");
-    return await _deposit(assets, true) as number;
+export async function depositEstimateGas(this: Llamalend, assets: TAmount): Promise<TGas> {
+    if (!(await depositIsApproved.call(this, assets))) throw Error("Approval is needed for gas estimation");
+    return await _deposit.call(this, assets, true) as number;
 }
 
-export const deposit = async (assets: TAmount): Promise<string> => {
-    await depositApprove(assets);
-    return await _deposit(assets, false) as string;
+export async function deposit(this: Llamalend, assets: TAmount): Promise<string> {
+    await depositApprove.call(this, assets);
+    return await _deposit.call(this, assets, false) as string;
 }
 
 // ---------------- MINT ----------------
 
-export const maxMint = async (address = ""): Promise<string> => {
-    address = _getAddress(address);
-    const _assetBalance = await llamalend.contracts[llamalend.constants.ALIASES.crvUSD].contract.balanceOf(address);
-    const _shares = await llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract.convertToShares(_assetBalance);
+export async function maxMint(this: Llamalend, address = ""): Promise<string> {
+    address = _getAddress.call(this, address);
+    const _assetBalance = await this.contracts[this.constants.ALIASES.crvUSD].contract.balanceOf(address);
+    const _shares = await this.contracts[this.constants.ALIASES.st_crvUSD].contract.convertToShares(_assetBalance);
 
     return formatUnits(_shares);
 }
 
-export const previewMint = async (shares: TAmount): Promise<string> => {
+export async function previewMint(this: Llamalend, shares: TAmount): Promise<string> {
     const _shares = parseUnits(shares);
-    const _assets = await llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract.previewMint(_shares);
+    const _assets = await this.contracts[this.constants.ALIASES.st_crvUSD].contract.previewMint(_shares);
 
     return formatUnits(_assets);
 }
 
-export const mintIsApproved = async (shares: TAmount): Promise<boolean> => {
-    const assets = await previewMint(shares);
-    return await hasAllowance([llamalend.constants.ALIASES.crvUSD], [assets], llamalend.signerAddress, llamalend.constants.ALIASES.st_crvUSD);
+export async function mintIsApproved(this: Llamalend, shares: TAmount): Promise<boolean> {
+    const assets = await previewMint.call(this, shares);
+    return await hasAllowance.call(this, [this.constants.ALIASES.crvUSD], [assets], this.signerAddress, this.constants.ALIASES.st_crvUSD);
 }
 
-export const mintAllowance = async (): Promise<string[]> => {
-    const assets = await getAllowance([llamalend.constants.ALIASES.crvUSD], llamalend.signerAddress, llamalend.constants.ALIASES.st_crvUSD);
+export async function mintAllowance(this: Llamalend): Promise<string[]> {
+    const assets = await getAllowance.call(this, [this.constants.ALIASES.crvUSD], this.signerAddress, this.constants.ALIASES.st_crvUSD);
     try {
-        return [await convertToShares(assets[0])]
+        return [await convertToShares.call(this, assets[0])]
     } catch (e) {
-        if (parseUnits(assets[0]) === MAX_ALLOWANCE) return [llamalend.formatUnits(MAX_ALLOWANCE)];
+        if (parseUnits(assets[0]) === MAX_ALLOWANCE) return [this.formatUnits(MAX_ALLOWANCE)];
         throw e;
     }
 }
 
-export const mintApproveEstimateGas = async (shares: TAmount): Promise<TGas> => {
-    const assets = await previewMint(shares);
-    return await ensureAllowanceEstimateGas([llamalend.constants.ALIASES.crvUSD], [assets], llamalend.constants.ALIASES.st_crvUSD);
+export async function mintApproveEstimateGas(this: Llamalend, shares: TAmount): Promise<TGas> {
+    const assets = await previewMint.call(this, shares);
+    return await ensureAllowanceEstimateGas.call(this, [this.constants.ALIASES.crvUSD], [assets], this.constants.ALIASES.st_crvUSD);
 }
 
-export const mintApprove = async (shares: TAmount, isMax = true): Promise<string[]> => {
-    const assets = await previewMint(shares);
-    return await ensureAllowance([llamalend.constants.ALIASES.crvUSD], [assets], llamalend.constants.ALIASES.st_crvUSD, isMax);
+export async function mintApprove(this: Llamalend, shares: TAmount, isMax = true): Promise<string[]> {
+    const assets = await previewMint.call(this, shares);
+    return await ensureAllowance.call(this, [this.constants.ALIASES.crvUSD], [assets], this.constants.ALIASES.st_crvUSD, isMax);
 }
 
-const _mint = async (shares: TAmount, estimateGas = false): Promise<string | TGas> => {
+async function _mint(this: Llamalend, shares: TAmount, estimateGas = false): Promise<string | TGas> {
     const _shares = parseUnits(shares);
-    const contract = llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract;
-    const gas = await contract.mint.estimateGas(_shares, llamalend.signerAddress, { ...llamalend.constantOptions });
+    const contract = this.contracts[this.constants.ALIASES.st_crvUSD].contract;
+    const gas = await contract.mint.estimateGas(_shares, this.signerAddress, { ...this.constantOptions });
     if (estimateGas) return smartNumber(gas);
 
-    await llamalend.updateFeeData();
+    await this.updateFeeData();
 
     const gasLimit = _mulBy1_3(DIGas(gas));
 
-    return (await contract.mint(_shares, llamalend.signerAddress, { ...llamalend.options, gasLimit })).hash;
+    return (await contract.mint(_shares, this.signerAddress, { ...this.options, gasLimit })).hash;
 }
 
-export const mintEstimateGas = async (shares: TAmount): Promise<TGas> => {
-    if (!(await mintIsApproved(shares))) throw Error("Approval is needed for gas estimation");
-    return await _mint(shares, true) as number;
+export async function mintEstimateGas(this: Llamalend, shares: TAmount): Promise<TGas> {
+    if (!(await mintIsApproved.call(this, shares))) throw Error("Approval is needed for gas estimation");
+    return await _mint.call(this, shares, true) as number;
 }
 
-export const mint = async (shares: TAmount): Promise<string> => {
-    await mintApprove(shares);
-    return await _mint(shares, false) as string;
+export async function mint(this: Llamalend, shares: TAmount): Promise<string> {
+    await mintApprove.call(this, shares);
+    return await _mint.call(this, shares, false) as string;
 }
 
 // ---------------- WITHDRAW ----------------
 
-export const maxWithdraw = async (address = ""): Promise<string> => {
-    address = _getAddress(address);
-    const _assets = await llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract.maxWithdraw(address);
+export async function maxWithdraw(this: Llamalend, address = ""): Promise<string> {
+    address = _getAddress.call(this, address);
+    const _assets = await this.contracts[this.constants.ALIASES.st_crvUSD].contract.maxWithdraw(address);
 
     return formatUnits(_assets);
 }
 
-export const previewWithdraw = async (assets: TAmount): Promise<string> => {
+export async function previewWithdraw(this: Llamalend, assets: TAmount): Promise<string> {
     const _assets = parseUnits(assets);
-    const _shares = await llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract.previewWithdraw(_assets);
+    const _shares = await this.contracts[this.constants.ALIASES.st_crvUSD].contract.previewWithdraw(_assets);
 
     return formatUnits(_shares);
 }
 
-const _withdraw = async (assets: TAmount, estimateGas = false): Promise<string | TGas> => {
+async function _withdraw(this: Llamalend, assets: TAmount, estimateGas = false): Promise<string | TGas> {
     const _assets = parseUnits(assets);
-    const contract = llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract;
-    const gas = await contract.withdraw.estimateGas(_assets, llamalend.signerAddress, llamalend.signerAddress, { ...llamalend.constantOptions });
+    const contract = this.contracts[this.constants.ALIASES.st_crvUSD].contract;
+    const gas = await contract.withdraw.estimateGas(_assets, this.signerAddress, this.signerAddress, { ...this.constantOptions });
     if (estimateGas) return smartNumber(gas);
 
-    await llamalend.updateFeeData();
+    await this.updateFeeData();
 
     const gasLimit = _mulBy1_3(DIGas(gas));
 
-    return (await contract.withdraw(_assets, llamalend.signerAddress, llamalend.signerAddress, { ...llamalend.options, gasLimit })).hash;
+    return (await contract.withdraw(_assets, this.signerAddress, this.signerAddress, { ...this.options, gasLimit })).hash;
 }
 
-export const withdrawEstimateGas = async (assets: TAmount): Promise<TGas> => {
-    return await _withdraw(assets, true) as number;
+export async function withdrawEstimateGas(this: Llamalend, assets: TAmount): Promise<TGas> {
+    return await _withdraw.call(this, assets, true) as number;
 }
 
-export const withdraw = async (assets: TAmount): Promise<string> => {
-    return await _withdraw(assets, false) as string;
+export async function withdraw(this: Llamalend, assets: TAmount): Promise<string> {
+    return await _withdraw.call(this, assets, false) as string;
 }
 
 // ---------------- REDEEM ----------------
 
-export const maxRedeem = async (address = ""): Promise<string> => {
-    address = _getAddress(address);
-    const _shares = await llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract.maxRedeem(address)
+export async function maxRedeem(this: Llamalend, address = ""): Promise<string> {
+    address = _getAddress.call(this, address);
+    const _shares = await this.contracts[this.constants.ALIASES.st_crvUSD].contract.maxRedeem(address)
 
     return formatUnits(_shares);
 }
 
-export const previewRedeem = async (shares: TAmount): Promise<string> => {
+export async function previewRedeem(this: Llamalend, shares: TAmount): Promise<string> {
     const _shares = parseUnits(shares, 18);
-    const _assets = await llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract.previewRedeem(_shares);
+    const _assets = await this.contracts[this.constants.ALIASES.st_crvUSD].contract.previewRedeem(_shares);
 
     return formatUnits(_assets);
 }
 
-const _redeem = async (shares: TAmount, estimateGas = false): Promise<string | TGas> => {
+async function _redeem(this: Llamalend, shares: TAmount, estimateGas = false): Promise<string | TGas> {
     const _shares = parseUnits(shares, 18);
-    const contract = llamalend.contracts[llamalend.constants.ALIASES.st_crvUSD].contract;
-    const gas = await contract.redeem.estimateGas(_shares, llamalend.signerAddress, llamalend.signerAddress, { ...llamalend.constantOptions });
+    const contract = this.contracts[this.constants.ALIASES.st_crvUSD].contract;
+    const gas = await contract.redeem.estimateGas(_shares, this.signerAddress, this.signerAddress, { ...this.constantOptions });
     if (estimateGas) return smartNumber(gas);
 
-    await llamalend.updateFeeData();
+    await this.updateFeeData();
 
     const gasLimit = _mulBy1_3(DIGas(gas));
 
-    return (await contract.redeem(_shares, llamalend.signerAddress, llamalend.signerAddress, { ...llamalend.options, gasLimit })).hash;
+    return (await contract.redeem(_shares, this.signerAddress, this.signerAddress, { ...this.options, gasLimit })).hash;
 }
 
-export const redeemEstimateGas = async (shares: TAmount): Promise<TGas> => {
-    return await _redeem(shares, true) as number;
+export async function redeemEstimateGas(this: Llamalend, shares: TAmount): Promise<TGas> {
+    return await _redeem.call(this, shares, true) as number;
 }
 
-export const redeem = async (shares: TAmount): Promise<string> => {
-    return await _redeem(shares, false) as string;
+export async function redeem(this: Llamalend, shares: TAmount): Promise<string> {
+    return await _redeem.call(this, shares, false) as string;
 }