@venusprotocol/venus-protocol 6.1.0-dev.1 → 6.1.0-dev.10

package/deployments/sepolia_addresses.json

@@ -0,0 +1,10 @@
+{
+  "name": "sepolia",
+  "chainId": "11155111",
+  "addresses": {
+    "VTreasuryV8": "0x4116CA92960dF77756aAAc3aFd91361dB657fbF8",
+    "XVSStore": "0x4be90041D1e082EfE3613099aA3b987D9045d718",
+    "XVSVault": "0xC59C757D88c38F9d6B15FDae8D7026D694d1c4E5",
+    "XVSVaultProxy": "0xe507B30C41E9e375BCe05197c1e09fc9ee40c0f6"
+  }
+}

package/dist/deploy/007-deploy-VTreasuryV8.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const hardhat_1 = require("hardhat");
 const acmAdminAccount = {
     sepolia: "0x94fa6078b6b8a26f0b6edffbe6501b22a10470fb",
-    ethereum: "0x285960C5B22fD66A736C7136967A3eB15e93CC67", // ETHEREUM MULTISIG
+    ethereum: "0x285960C5B22fD66A736C7136967A3eB15e93CC67",
+    opbnbtestnet: "0xb15f6EfEbC276A3b9805df81b5FB3D50C2A62BDf",
+    opbnbmainnet: "0xC46796a21a3A9FAB6546aF3434F2eBfFd0604207", // OPBNBMAINNET MULTISIG
 };
 const func = async function (hre) {
     const { deployments, getNamedAccounts } = hre;

package/dist/deploy/007-deploy-xvs.d.ts

@@ -0,0 +1,3 @@
+import { DeployFunction } from "hardhat-deploy/types";
+declare const func: DeployFunction;
+export default func;

package/dist/deploy/007-deploy-xvs.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    await deploy("XVS", {
+        from: deployer,
+        args: [deployer],
+        log: true,
+        autoMine: true,
+    });
+};
+func.tags = ["xvs"];
+func.skip = async (hre) => hre.network.live;
+exports.default = func;

package/dist/deploy/008-deploy-vaults.d.ts

@@ -0,0 +1,3 @@
+import { DeployFunction } from "hardhat-deploy/types";
+declare const func: DeployFunction;
+export default func;

package/dist/deploy/008-deploy-vaults.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hardhat_1 = require("hardhat");
+const func = async function (hre) {
+    const { deployments, getNamedAccounts } = hre;
+    const { deploy } = deployments;
+    const { deployer } = await getNamedAccounts();
+    const xvsVaultDeployment = await deploy("XVSVault", {
+        from: deployer,
+        args: [],
+        log: true,
+        autoMine: true,
+    });
+    const xvsVaultAddress = xvsVaultDeployment.address;
+    const xvsVaultProxyDeployment = await deploy("XVSVaultProxy", {
+        from: deployer,
+        args: [],
+        log: true,
+        autoMine: true,
+    });
+    const xvsVaultProxyAddress = xvsVaultProxyDeployment.address;
+    await deploy("XVSStore", {
+        from: deployer,
+        args: [],
+        log: true,
+        autoMine: true,
+    });
+    const xvsVault = await hardhat_1.ethers.getContract("XVSVault");
+    const xvsStore = await hardhat_1.ethers.getContract("XVSStore");
+    const xvsVaultProxy = await hardhat_1.ethers.getContract("XVSVaultProxy");
+    // Become Implementation of XVSVaultProxy
+    const tx = await xvsVaultProxy._setPendingImplementation(xvsVaultAddress);
+    await tx.wait();
+    await xvsVault._become(xvsVaultProxyAddress);
+    await tx.wait();
+    // Set new owner to xvs store
+    await xvsStore.setNewOwner(xvsVaultProxyAddress);
+    await tx.wait();
+};
+func.tags = ["xvs-vault"];
+exports.default = func;

package/dist/deploy/009-configure-vaults.d.ts

@@ -0,0 +1,3 @@
+import { DeployFunction } from "hardhat-deploy/types";
+declare const func: DeployFunction;
+export default func;

package/dist/deploy/009-configure-vaults.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const hardhat_1 = require("hardhat");
+const adminAccount = {
+    sepolia: "0x94fa6078b6b8a26f0b6edffbe6501b22a10470fb",
+    ethereum: "0x285960C5B22fD66A736C7136967A3eB15e93CC67", // ETHEREUM MULTISIG
+};
+const func = async function (hre) {
+    const { getNamedAccounts } = hre;
+    const { deployer } = await getNamedAccounts();
+    const accessControlManager = await hardhat_1.ethers.getContract("AccessControlManager");
+    const xvs = await hardhat_1.ethers.getContract("XVS");
+    const xvsVaultProxyDeployment = await hardhat_1.ethers.getContract("XVSVaultProxy");
+    const xvsStoreDeployment = await hardhat_1.ethers.getContract("XVSStore");
+    const xvsVaultProxy = await hardhat_1.ethers.getContractAt("XVSVault", xvsVaultProxyDeployment.address);
+    let txn = await xvsVaultProxy.setXvsStore(xvs.address, xvsStoreDeployment.address);
+    await txn.wait();
+    txn = await xvsVaultProxy.setAccessControl(accessControlManager.address);
+    await txn.wait();
+    if (!hre.network.live) {
+        const tx = await accessControlManager.giveCallPermission(hardhat_1.ethers.constants.AddressZero, "add(address,uint256,address,uint256,uint256)", deployer);
+        await tx.wait();
+        // Add token pool to xvs vault
+        const allocPoint = 100;
+        const token = xvs.address;
+        const rewardToken = xvs.address;
+        const rewardPerBlock = "61805555555555555";
+        const lockPeriod = 604800;
+        await xvsVaultProxy.add(rewardToken, allocPoint, token, rewardPerBlock, lockPeriod);
+    }
+    else {
+        const owner = adminAccount[hre.network.name];
+        console.log("Please accept ownership of vault and store");
+        txn = await xvsVaultProxyDeployment._setPendingAdmin(owner);
+        await txn.wait();
+        txn = await xvsStoreDeployment.setPendingAdmin(owner);
+        await txn.wait();
+    }
+};
+func.tags = ["xvs-vault"];
+exports.default = func;

package/dist/hardhat.config.js

@@ -17,8 +17,34 @@ require("solidity-coverage");
 require("solidity-docgen");
 require("hardhat-contract-sizer");
 require("dotenv").config();
-const BSCSCAN_API_KEY = process.env.BSCSCAN_API_KEY;
 const DEPLOYER_PRIVATE_KEY = process.env.DEPLOYER_PRIVATE_KEY;
+(0, config_1.extendConfig)((config) => {
+    if (process.env.EXPORT !== "true") {
+        config.external = {
+            ...config.external,
+            deployments: {
+                bsctestnet: [
+                    "node_modules/@venusprotocol/governance-contracts/deployments/bsctestnet",
+                    "node_modules/@venusprotocol/venus-protocol/deployments/bsctestnet",
+                    "node_modules/@venusprotocol/oracle/deployments/bsctestnet",
+                    "node_modules/@venusprotocol/token-bridge/deployments/bsctestnet",
+                ],
+                bscmainnet: [
+                    "node_modules/@venusprotocol/governance-contracts/deployments/bscmainnet",
+                    "node_modules/@venusprotocol/venus-protocol/deployments/bscmainnet",
+                    "node_modules/@venusprotocol/oracle/deployments/bscmainnet",
+                    "node_modules/@venusprotocol/token-bridge/deployments/bscmainnet",
+                ],
+                sepolia: [
+                    "node_modules/@venusprotocol/governance-contracts/deployments/sepolia",
+                    "node_modules/@venusprotocol/oracle/deployments/sepolia",
+                    "node_modules/@venusprotocol/token-bridge/deployments/sepolia",
+                ],
+                ethereum: ["node_modules/@venusprotocol/token-bridge/deployments/ethereum"],
+            },
+        };
+    }
+});
 (0, config_1.task)("accounts", "Prints the list of accounts", async (taskArgs, hre) => {
     const accounts = await hre.ethers.getSigners();
     for (const account of accounts) {
@@ -105,41 +131,104 @@ const config = {
     networks: {
         hardhat: isFork(),
         bsctestnet: {
-            url: process.env.BSC_ARCHIVE_NODE_URL || "https://data-seed-prebsc-1-s1.binance.org:8545",
+            url: process.env.ARCHIVE_NODE_bsctestnet || "https://data-seed-prebsc-1-s1.binance.org:8545",
             chainId: 97,
             accounts: {
                 mnemonic: process.env.MNEMONIC || "",
             },
+            gasPrice: 10000000000,
             gasMultiplier: 10,
             timeout: 12000000,
         },
         bscmainnet: {
-            url: "http://127.0.0.1:1248",
-            chainId: 56,
-            live: true,
-            timeout: 1200000, // 20 minutes
+            url: process.env.ARCHIVE_NODE_bscmainnet || "https://bsc-dataseed.binance.org/",
+            accounts: DEPLOYER_PRIVATE_KEY ? [`0x${DEPLOYER_PRIVATE_KEY}`] : [],
         },
         sepolia: {
-            url: process.env.RPC_URL || "https://rpc.notadegen.com/eth/sepolia",
+            url: process.env.ARCHIVE_NODE_sepolia || "https://ethereum-sepolia.blockpi.network/v1/rpc/public",
             chainId: 11155111,
             live: true,
             gasPrice: 20000000000,
-            accounts: {
-                mnemonic: process.env.MNEMONIC || "",
-            },
+            accounts: DEPLOYER_PRIVATE_KEY ? [`0x${DEPLOYER_PRIVATE_KEY}`] : [],
         },
         ethereum: {
-            url: process.env.ETHEREUM_ARCHIVE_NODE_URL || "https://eth-mainnet.public.blastapi.io",
+            url: process.env.ARCHIVE_NODE_ethereum || "https://ethereum.blockpi.network/v1/rpc/public",
             chainId: 1,
             live: true,
-            timeout: 1200000,
-            accounts: {
-                mnemonic: process.env.MNEMONIC || "",
-            },
+            timeout: 1200000, // 20 minutes
+        },
+        opbnbtestnet: {
+            url: process.env.ARCHIVE_NODE_opbnbtestnet || "https://opbnb-testnet-rpc.bnbchain.org",
+            chainId: 5611,
+            live: true,
+            accounts: DEPLOYER_PRIVATE_KEY ? [`0x${DEPLOYER_PRIVATE_KEY}`] : [],
+        },
+        opbnbmainnet: {
+            url: process.env.ARCHIVE_NODE_opbnbmainnet || "https://opbnb-mainnet-rpc.bnbchain.org",
+            chainId: 204,
+            live: true,
+            accounts: DEPLOYER_PRIVATE_KEY ? [`0x${DEPLOYER_PRIVATE_KEY}`] : [],
         },
     },
     etherscan: {
-        apiKey: BSCSCAN_API_KEY,
+        apiKey: {
+            bscmainnet: process.env.ETHERSCAN_API_KEY || "ETHERSCAN_API_KEY",
+            bsctestnet: process.env.ETHERSCAN_API_KEY || "ETHERSCAN_API_KEY",
+            sepolia: process.env.ETHERSCAN_API_KEY || "ETHERSCAN_API_KEY",
+            ethereum: process.env.ETHERSCAN_API_KEY || "ETHERSCAN_API_KEY",
+            opbnbtestnet: process.env.ETHERSCAN_API_KEY || "ETHERSCAN_API_KEY",
+            opbnbmainnet: process.env.ETHERSCAN_API_KEY || "ETHERSCAN_API_KEY",
+        },
+        customChains: [
+            {
+                network: "bscmainnet",
+                chainId: 56,
+                urls: {
+                    apiURL: "https://api.bscscan.com/api",
+                    browserURL: "https://bscscan.com",
+                },
+            },
+            {
+                network: "bsctestnet",
+                chainId: 97,
+                urls: {
+                    apiURL: "https://api-testnet.bscscan.com/api",
+                    browserURL: "https://testnet.bscscan.com",
+                },
+            },
+            {
+                network: "sepolia",
+                chainId: 11155111,
+                urls: {
+                    apiURL: "https://api-sepolia.etherscan.io/api",
+                    browserURL: "https://sepolia.etherscan.io",
+                },
+            },
+            {
+                network: "ethereum",
+                chainId: 1,
+                urls: {
+                    apiURL: "https://api.etherscan.io/api",
+                    browserURL: "https://etherscan.io",
+                },
+            },
+            {
+                network: "opbnbtestnet",
+                chainId: 5611,
+                urls: {
+                    apiURL: `https://open-platform.nodereal.io/${process.env.ETHERSCAN_API_KEY}/op-bnb-testnet/contract/`,
+                    browserURL: "https://testnet.opbnbscan.com/",
+                },
+            },
+            {
+                network: "opbnbmainnet",
+                chainId: 204,
+                urls: {
+                    apiURL: `https://open-platform.nodereal.io/${process.env.ETHERSCAN_API_KEY}/op-bnb-mainnet/contract/`,
+                    browserURL: "https://opbnbscan.com/",
+                },
+            },
+        ],
     },
     paths: {
         sources: "./contracts",
@@ -163,9 +252,10 @@ const config = {
     external: {
         contracts: [
             {
-                artifacts: "node_modules/@venusprotocol/isolated-pools/artifacts",
+                artifacts: "node_modules/@venusprotocol/governance-contracts/artifacts",
             },
         ],
+        deployments: {},
     },
     docgen: {
         outputDir: "./docgen-docs",
@@ -174,16 +264,17 @@ const config = {
     },
 };
 function isFork() {
-    return process.env.FORK_MAINNET === "true"
+    return process.env.FORK === "true"
         ? {
             allowUnlimitedContractSize: false,
             loggingEnabled: false,
             forking: {
-                url: process.env.BSC_ARCHIVE_NODE_URL || "",
+                url: process.env[`ARCHIVE_NODE_${process.env.FORKED_NETWORK}`] ||
+                    "https://data-seed-prebsc-1-s1.binance.org:8545",
                 blockNumber: 21068448,
             },
             accounts: {
-                accountsBalance: "1000000000000000000000",
+                accountsBalance: "1000000000000000000",
             },
             live: false,
         }

package/dist/typechain/@venusprotocol/index.d.ts

@@ -1,6 +1,6 @@
 import type * as governanceContracts from "./governance-contracts";
-import type * as isolatedPools from "./isolated-pools";
 import type * as oracle from "./oracle";
+import type * as solidityUtilities from "./solidity-utilities";
 export type { governanceContracts };
-export type { isolatedPools };
 export type { oracle };
+export type { solidityUtilities };

package/dist/typechain/contracts/DelegateBorrowers/MoveDebtDelegate.d.ts

@@ -0,0 +1,274 @@
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
+import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
+import type { Listener, Provider } from "@ethersproject/providers";
+import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";
+export interface MoveDebtDelegateInterface extends utils.Interface {
+    functions: {
+        "acceptOwnership()": FunctionFragment;
+        "borrowAllowed(address)": FunctionFragment;
+        "initialize()": FunctionFragment;
+        "moveDebt(address,uint256,address)": FunctionFragment;
+        "newBorrower()": FunctionFragment;
+        "owner()": FunctionFragment;
+        "pendingOwner()": FunctionFragment;
+        "renounceOwnership()": FunctionFragment;
+        "setBorrowAllowed(address,bool)": FunctionFragment;
+        "sweepTokens(address)": FunctionFragment;
+        "transferOwnership(address)": FunctionFragment;
+        "vTokenToRepay()": FunctionFragment;
+    };
+    getFunction(nameOrSignatureOrTopic: "acceptOwnership" | "borrowAllowed" | "initialize" | "moveDebt" | "newBorrower" | "owner" | "pendingOwner" | "renounceOwnership" | "setBorrowAllowed" | "sweepTokens" | "transferOwnership" | "vTokenToRepay"): FunctionFragment;
+    encodeFunctionData(functionFragment: "acceptOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "borrowAllowed", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "initialize", values?: undefined): string;
+    encodeFunctionData(functionFragment: "moveDebt", values: [
+        PromiseOrValue<string>,
+        PromiseOrValue<BigNumberish>,
+        PromiseOrValue<string>
+    ]): string;
+    encodeFunctionData(functionFragment: "newBorrower", values?: undefined): string;
+    encodeFunctionData(functionFragment: "owner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "pendingOwner", values?: undefined): string;
+    encodeFunctionData(functionFragment: "renounceOwnership", values?: undefined): string;
+    encodeFunctionData(functionFragment: "setBorrowAllowed", values: [PromiseOrValue<string>, PromiseOrValue<boolean>]): string;
+    encodeFunctionData(functionFragment: "sweepTokens", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "transferOwnership", values: [PromiseOrValue<string>]): string;
+    encodeFunctionData(functionFragment: "vTokenToRepay", values?: undefined): string;
+    decodeFunctionResult(functionFragment: "acceptOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "borrowAllowed", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "initialize", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "moveDebt", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "newBorrower", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "owner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "pendingOwner", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "renounceOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "setBorrowAllowed", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "sweepTokens", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "transferOwnership", data: BytesLike): Result;
+    decodeFunctionResult(functionFragment: "vTokenToRepay", data: BytesLike): Result;
+    events: {
+        "BorrowAllowedSet(address,bool)": EventFragment;
+        "DebtMoved(address,address,uint256,address,address,uint256)": EventFragment;
+        "Initialized(uint8)": EventFragment;
+        "OwnershipTransferStarted(address,address)": EventFragment;
+        "OwnershipTransferred(address,address)": EventFragment;
+        "SweptTokens(address,uint256)": EventFragment;
+    };
+    getEvent(nameOrSignatureOrTopic: "BorrowAllowedSet"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "DebtMoved"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "Initialized"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferStarted"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "OwnershipTransferred"): EventFragment;
+    getEvent(nameOrSignatureOrTopic: "SweptTokens"): EventFragment;
+}
+export interface BorrowAllowedSetEventObject {
+    vToken: string;
+    allowed: boolean;
+}
+export type BorrowAllowedSetEvent = TypedEvent<[
+    string,
+    boolean
+], BorrowAllowedSetEventObject>;
+export type BorrowAllowedSetEventFilter = TypedEventFilter<BorrowAllowedSetEvent>;
+export interface DebtMovedEventObject {
+    originalBorrower: string;
+    vTokenRepaid: string;
+    repaidAmount: BigNumber;
+    newBorrower: string;
+    vTokenBorrowed: string;
+    borrowedAmount: BigNumber;
+}
+export type DebtMovedEvent = TypedEvent<[
+    string,
+    string,
+    BigNumber,
+    string,
+    string,
+    BigNumber
+], DebtMovedEventObject>;
+export type DebtMovedEventFilter = TypedEventFilter<DebtMovedEvent>;
+export interface InitializedEventObject {
+    version: number;
+}
+export type InitializedEvent = TypedEvent<[number], InitializedEventObject>;
+export type InitializedEventFilter = TypedEventFilter<InitializedEvent>;
+export interface OwnershipTransferStartedEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferStartedEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferStartedEventObject>;
+export type OwnershipTransferStartedEventFilter = TypedEventFilter<OwnershipTransferStartedEvent>;
+export interface OwnershipTransferredEventObject {
+    previousOwner: string;
+    newOwner: string;
+}
+export type OwnershipTransferredEvent = TypedEvent<[
+    string,
+    string
+], OwnershipTransferredEventObject>;
+export type OwnershipTransferredEventFilter = TypedEventFilter<OwnershipTransferredEvent>;
+export interface SweptTokensEventObject {
+    token: string;
+    amount: BigNumber;
+}
+export type SweptTokensEvent = TypedEvent<[
+    string,
+    BigNumber
+], SweptTokensEventObject>;
+export type SweptTokensEventFilter = TypedEventFilter<SweptTokensEvent>;
+export interface MoveDebtDelegate extends BaseContract {
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+    interface: MoveDebtDelegateInterface;
+    queryFilter<TEvent extends TypedEvent>(event: TypedEventFilter<TEvent>, fromBlockOrBlockhash?: string | number | undefined, toBlock?: string | number | undefined): Promise<Array<TEvent>>;
+    listeners<TEvent extends TypedEvent>(eventFilter?: TypedEventFilter<TEvent>): Array<TypedListener<TEvent>>;
+    listeners(eventName?: string): Array<Listener>;
+    removeAllListeners<TEvent extends TypedEvent>(eventFilter: TypedEventFilter<TEvent>): this;
+    removeAllListeners(eventName?: string): this;
+    off: OnEvent<this>;
+    on: OnEvent<this>;
+    once: OnEvent<this>;
+    removeListener: OnEvent<this>;
+    functions: {
+        acceptOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        borrowAllowed(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<[boolean]>;
+        initialize(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        moveDebt(originalBorrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenToBorrow: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        newBorrower(overrides?: CallOverrides): Promise<[string]>;
+        owner(overrides?: CallOverrides): Promise<[string]>;
+        pendingOwner(overrides?: CallOverrides): Promise<[string]>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        setBorrowAllowed(vTokenToBorrow: PromiseOrValue<string>, allow: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        sweepTokens(token: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<ContractTransaction>;
+        vTokenToRepay(overrides?: CallOverrides): Promise<[string]>;
+    };
+    acceptOwnership(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    borrowAllowed(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+    initialize(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    moveDebt(originalBorrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenToBorrow: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    newBorrower(overrides?: CallOverrides): Promise<string>;
+    owner(overrides?: CallOverrides): Promise<string>;
+    pendingOwner(overrides?: CallOverrides): Promise<string>;
+    renounceOwnership(overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    setBorrowAllowed(vTokenToBorrow: PromiseOrValue<string>, allow: PromiseOrValue<boolean>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    sweepTokens(token: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+        from?: PromiseOrValue<string>;
+    }): Promise<ContractTransaction>;
+    vTokenToRepay(overrides?: CallOverrides): Promise<string>;
+    callStatic: {
+        acceptOwnership(overrides?: CallOverrides): Promise<void>;
+        borrowAllowed(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<boolean>;
+        initialize(overrides?: CallOverrides): Promise<void>;
+        moveDebt(originalBorrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenToBorrow: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        newBorrower(overrides?: CallOverrides): Promise<string>;
+        owner(overrides?: CallOverrides): Promise<string>;
+        pendingOwner(overrides?: CallOverrides): Promise<string>;
+        renounceOwnership(overrides?: CallOverrides): Promise<void>;
+        setBorrowAllowed(vTokenToBorrow: PromiseOrValue<string>, allow: PromiseOrValue<boolean>, overrides?: CallOverrides): Promise<void>;
+        sweepTokens(token: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: CallOverrides): Promise<void>;
+        vTokenToRepay(overrides?: CallOverrides): Promise<string>;
+    };
+    filters: {
+        "BorrowAllowedSet(address,bool)"(vToken?: PromiseOrValue<string> | null, allowed?: null): BorrowAllowedSetEventFilter;
+        BorrowAllowedSet(vToken?: PromiseOrValue<string> | null, allowed?: null): BorrowAllowedSetEventFilter;
+        "DebtMoved(address,address,uint256,address,address,uint256)"(originalBorrower?: PromiseOrValue<string> | null, vTokenRepaid?: null, repaidAmount?: null, newBorrower?: PromiseOrValue<string> | null, vTokenBorrowed?: PromiseOrValue<string> | null, borrowedAmount?: null): DebtMovedEventFilter;
+        DebtMoved(originalBorrower?: PromiseOrValue<string> | null, vTokenRepaid?: null, repaidAmount?: null, newBorrower?: PromiseOrValue<string> | null, vTokenBorrowed?: PromiseOrValue<string> | null, borrowedAmount?: null): DebtMovedEventFilter;
+        "Initialized(uint8)"(version?: null): InitializedEventFilter;
+        Initialized(version?: null): InitializedEventFilter;
+        "OwnershipTransferStarted(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferStartedEventFilter;
+        OwnershipTransferStarted(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferStartedEventFilter;
+        "OwnershipTransferred(address,address)"(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        OwnershipTransferred(previousOwner?: PromiseOrValue<string> | null, newOwner?: PromiseOrValue<string> | null): OwnershipTransferredEventFilter;
+        "SweptTokens(address,uint256)"(token?: PromiseOrValue<string> | null, amount?: null): SweptTokensEventFilter;
+        SweptTokens(token?: PromiseOrValue<string> | null, amount?: null): SweptTokensEventFilter;
+    };
+    estimateGas: {
+        acceptOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        borrowAllowed(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<BigNumber>;
+        initialize(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        moveDebt(originalBorrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenToBorrow: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        newBorrower(overrides?: CallOverrides): Promise<BigNumber>;
+        owner(overrides?: CallOverrides): Promise<BigNumber>;
+        pendingOwner(overrides?: CallOverrides): Promise<BigNumber>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        setBorrowAllowed(vTokenToBorrow: PromiseOrValue<string>, allow: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        sweepTokens(token: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<BigNumber>;
+        vTokenToRepay(overrides?: CallOverrides): Promise<BigNumber>;
+    };
+    populateTransaction: {
+        acceptOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        borrowAllowed(arg0: PromiseOrValue<string>, overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        initialize(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        moveDebt(originalBorrower: PromiseOrValue<string>, repayAmount: PromiseOrValue<BigNumberish>, vTokenToBorrow: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        newBorrower(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        owner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        pendingOwner(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+        renounceOwnership(overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        setBorrowAllowed(vTokenToBorrow: PromiseOrValue<string>, allow: PromiseOrValue<boolean>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        sweepTokens(token: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        transferOwnership(newOwner: PromiseOrValue<string>, overrides?: Overrides & {
+            from?: PromiseOrValue<string>;
+        }): Promise<PopulatedTransaction>;
+        vTokenToRepay(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+    };
+}

package/dist/typechain/contracts/DelegateBorrowers/{SwapDebtDelegate.sol/SwapDebtDelegate.d.ts → SwapDebtDelegate.d.ts}

@@ -1,4 +1,4 @@
-import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../../common";
+import type { TypedEventFilter, TypedEvent, TypedListener, OnEvent, PromiseOrValue } from "../../common";
 import type { FunctionFragment, Result, EventFragment } from "@ethersproject/abi";
 import type { Listener, Provider } from "@ethersproject/providers";
 import type { BaseContract, BigNumber, BigNumberish, BytesLike, CallOverrides, ContractTransaction, Overrides, PopulatedTransaction, Signer, utils } from "ethers";

package/dist/typechain/contracts/DelegateBorrowers/index.d.ts

@@ -1,2 +1,2 @@
-import type * as swapDebtDelegateSol from "./SwapDebtDelegate.sol";
-export type { swapDebtDelegateSol };
+export type { MoveDebtDelegate } from "./MoveDebtDelegate";
+export type { SwapDebtDelegate } from "./SwapDebtDelegate";

package/dist/typechain/contracts/DelegateBorrowers/index.js

@@ -1,3 +1,2 @@
 "use strict";
-/* Autogenerated file. Do not edit manually. */
 Object.defineProperty(exports, "__esModule", { value: true });