@raac/rpc 1.0.2-beta.6 → 1.1.0-beta.10

package/dist/types/utils/chain.d.ts

@@ -0,0 +1,13 @@
+import { ethers } from "ethers";
+import { ChainId } from "../configs/chains";
+import { ContractType } from "./artifacts";
+declare global {
+    interface Window {
+        ethereum?: any;
+    }
+}
+export declare const getProvider: (chainId: ChainId) => ethers.JsonRpcProvider;
+export declare const getContractAddress: (chainId: ChainId, contractName: ContractType) => any;
+export declare const getSigner: (provider: any) => Promise<ethers.JsonRpcSigner>;
+export declare const getChainId: () => Promise<number>;
+export declare const switchChain: (chainId: ChainId) => Promise<void>;

package/dist/types/utils/contracts.d.ts

@@ -0,0 +1,24 @@
+import { ChainId } from "../configs/chains";
+import { ContractType } from "./artifacts";
+import { ethers, Provider } from "ethers";
+export declare const getConfigs: () => {
+    8453: import("../configs/chains/chain").Chain8453;
+    17000: import("../configs/chains/chain").Chain8453;
+    11155111: import("../configs/chains/chain").Chain11155111;
+};
+export declare const setOverrideConfig: (chainId: ChainId, newConfig: any) => void;
+export declare const getConfig: (chainId: ChainId) => any;
+export declare const getContract: (chainId: ChainId, contractName: ContractType, provider: Provider) => ethers.Contract;
+export declare const getContractAddress: (chainId: ChainId, contractName: string) => any;
+declare const _default: {
+    getContract: (chainId: ChainId, contractName: ContractType, provider: Provider) => ethers.Contract;
+    getContractAddress: (chainId: ChainId, contractName: string) => any;
+    setOverrideConfig: (chainId: ChainId, newConfig: any) => void;
+    getConfig: (chainId: ChainId) => any;
+    getConfigs: () => {
+        8453: import("../configs/chains/chain").Chain8453;
+        17000: import("../configs/chains/chain").Chain8453;
+        11155111: import("../configs/chains/chain").Chain11155111;
+    };
+};
+export default _default;

package/dist/types/wallet/assets/approveAsset.d.ts

@@ -0,0 +1,5 @@
+import { Signer } from "ethers";
+import { AssetType } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+declare function approveAsset(chainId: ChainId, assetId: AssetType, spender: string, amount: string, signer: Signer): Promise<any>;
+export default approveAsset;

package/dist/types/wallet/assets/burnAsset.d.ts

@@ -0,0 +1,5 @@
+import { Signer } from "ethers";
+import { AssetType } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+declare function burnAsset(chainId: ChainId, assetId: AssetType, amount: bigint, signer: Signer): Promise<any>;
+export default burnAsset;

package/dist/types/wallet/assets/getAllowance.d.ts

@@ -0,0 +1,5 @@
+import { Provider } from "ethers";
+import { AssetType } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+declare function getAllowance(chainId: ChainId, assetId: AssetType, owner: string, spender: string, provider: Provider): Promise<string | 0>;
+export default getAllowance;

package/dist/types/wallet/assets/getAsset.d.ts

@@ -0,0 +1,4 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+declare function getAsset(chainId: ChainId, assetId: string, address: string, provider: Provider): Promise<any>;
+export default getAsset;

package/dist/types/wallet/assets/getAssets.d.ts

@@ -0,0 +1,4 @@
+import { Provider } from "ethers";
+import { ChainId } from "../../configs/chains/index";
+declare function getAssets(chainId: ChainId, address: string, provider: Provider): Promise<{}>;
+export default getAssets;

package/dist/types/wallet/assets/getBalance.d.ts

@@ -0,0 +1,13 @@
+import { Provider } from "ethers";
+import { AssetType } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+declare function getBalance(chainId: ChainId, assetId: AssetType, address: string, provider: Provider): Promise<{
+    balance: number;
+    symbol: string;
+    decimals: number;
+} | {
+    balance: string;
+    symbol: any;
+    decimals: any;
+}>;
+export default getBalance;

package/dist/types/wallet/assets/mintAsset.d.ts

@@ -0,0 +1,5 @@
+import { Signer } from "ethers";
+import { AssetType } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+declare function mintAsset(chainId: ChainId, assetId: AssetType, amount: bigint, address: string, signer: Signer): Promise<any>;
+export default mintAsset;

package/dist/types/wallet/assets/transferAsset.d.ts

@@ -0,0 +1,5 @@
+import { Signer } from "ethers";
+import { AssetType } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+declare function transferAsset(chainId: ChainId, assetId: AssetType, amount: bigint, fromAddress: string, toAddress: string, signer: Signer): Promise<any>;
+export default transferAsset;

package/dist/utils/artifacts.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ABIS = exports.getABI = void 0;
+const crvUSDToken_json_1 = __importDefault(require("../artifacts/mocks/core/tokens/crvUSDToken.sol/crvUSDToken.json")); // assert { type: "json" };
+const veRAACToken_json_1 = __importDefault(require("../artifacts/core/tokens/veRAACToken.sol/veRAACToken.json")); // assert { type: "json" };
+const RToken_json_1 = __importDefault(require("../artifacts/core/tokens/RToken.sol/RToken.json")); // assert { type: "json" };
+const LendingPool_json_1 = __importDefault(require("../artifacts/core/pools/LendingPool/LendingPool.sol/LendingPool.json")); // assert { type: "json" };
+const StabilityPool_json_1 = __importDefault(require("../artifacts/core/pools/StabilityPool/StabilityPool.sol/StabilityPool.json")); // assert { type: "json" };
+// import LiquidityPoolArtifact from "../artifacts/LiquidityPool/LiquidityPool.sol/LiquidityPool.json"; // assert { type: "json" };
+const RAACNFT_json_1 = __importDefault(require("../artifacts/core/tokens/RAACNFT.sol/RAACNFT.json")); // assert { type: "json" };
+const DEToken_json_1 = __importDefault(require("../artifacts/core/tokens/DEToken.sol/DEToken.json")); // assert { type: "json" };
+const RAACToken_json_1 = __importDefault(require("../artifacts/core/tokens/RAACToken.sol/RAACToken.json")); // assert { type: "json" };
+const RAACMinter_json_1 = __importDefault(require("../artifacts/core/minters/RAACMinter/RAACMinter.sol/RAACMinter.json")); // assert { type: "json" };
+const RAACHousePrices_json_1 = __importDefault(require("../artifacts/core/primitives/RAACHousePrices.sol/RAACHousePrices.json")); // assert { type: "json" };
+const AuctionFactory_json_1 = __importDefault(require("../artifacts/zeno/AuctionFactory.sol/AuctionFactory.json")); // assert { type: "json" };
+const Auction_json_1 = __importDefault(require("../artifacts/zeno/Auction.sol/Auction.json")); // assert { type: "json" };
+const ZenoFactory_json_1 = __importDefault(require("../artifacts/zeno/ZenoFactory.sol/ZenoFactory.json")); // assert { type: "json" };
+const Zeno_json_1 = __importDefault(require("../artifacts/zeno/Zeno.sol/Zeno.json")); // assert { type: "json" };
+const FeeCollector_json_1 = __importDefault(require("../artifacts/core/collectors/FeeCollector.sol/FeeCollector.json")); // assert { type: "json" };
+const MockVRFCoordinatorV2_json_1 = __importDefault(require("../artifacts/mocks/core/oracles/MockVRFCoordinatorV2.sol/MockVRFCoordinatorV2.json")); // assert { type: "json" };
+const BaseVRFv2Consumer_json_1 = __importDefault(require("../artifacts/core/oracles/BaseVRFv2Consumer.sol/BaseVRFv2Consumer.json")); // assert { type: "json" };
+const RAACPrimeRateOracle_json_1 = __importDefault(require("../artifacts/core/oracles/RAACPrimeRateOracle.sol/RAACPrimeRateOracle.json")); // assert { type: "json" };
+const RWAVault_json_1 = __importDefault(require("../artifacts/core/vaults/RWAVault.sol/RWAVault.json")); // assert { type: "json" };
+const ERC20AssetAdapter_json_1 = __importDefault(require("../artifacts/core/pools/LendingPool/ERC20AssetAdapter.sol/ERC20AssetAdapter.json")); // assert { type: "json" };
+const ERC721AssetAdapter_json_1 = __importDefault(require("../artifacts/core/pools/LendingPool/ERC721AssetAdapter.sol/ERC721AssetAdapter.json")); // assert { type: "json" };
+const ERC20VaultAdapter_json_1 = __importDefault(require("../artifacts/core/vaults/ERC20VaultAdapter.sol/ERC20VaultAdapter.json"));
+const ERC721VaultAdapter_json_1 = __importDefault(require("../artifacts/core/vaults/ERC721VaultAdapter.sol/ERC721VaultAdapter.json"));
+const RWAIndexToken_json_1 = __importDefault(require("../artifacts/core/tokens/RWAIndexToken.sol/RWAIndexToken.json"));
+const CRVUSD_ABI = crvUSDToken_json_1.default.abi;
+const RToken_json_2 = __importDefault(require("../artifacts/core/tokens/RToken.sol/RToken.json")); // assert { type: "json" }; // TODO: Isnt this same as rcrvusd?
+const RTOKEN_ABI = RToken_json_2.default.abi;
+const VERAAC_ABI = veRAACToken_json_1.default.abi;
+const RCRVUSD_ABI = RToken_json_1.default.abi;
+const DETOKEN_ABI = DEToken_json_1.default.abi;
+const RAACLENDINGPOOL_ABI = LendingPool_json_1.default.abi;
+const RAACSTABILITYPOOL_ABI = StabilityPool_json_1.default.abi;
+// const LIQUIDITYPOOL_ABI = LiquidityPoolArtifact.abi;
+const RAACMINTER_ABI = RAACMinter_json_1.default.abi;
+const RAACNFT_ABI = RAACNFT_json_1.default.abi;
+const RAACToken_ABI = RAACToken_json_1.default.abi;
+const RAACHOUSEPRICES_ABI = RAACHousePrices_json_1.default.abi;
+const FEECOLLECTOR_ABI = FeeCollector_json_1.default.abi;
+const RWAVAULT_ABI = RWAVault_json_1.default.abi;
+const ERC20ASSETADAPTER_ABI = ERC20AssetAdapter_json_1.default.abi;
+const ERC721ASSETADAPTER_ABI = ERC721AssetAdapter_json_1.default.abi;
+const RWAINDEXTOKEN_ABI = RWAIndexToken_json_1.default.abi;
+const ABIS = {
+    // Tokens
+    crvusd: CRVUSD_ABI,
+    // RAAC
+    raacnft: RAACNFT_ABI,
+    raactoken: RAACToken_ABI,
+    veraac: VERAAC_ABI,
+    // Pools tokens
+    rcrvusd: RCRVUSD_ABI,
+    rtoken: RTOKEN_ABI,
+    detoken: DETOKEN_ABI,
+    // Pools
+    lendingpool: RAACLENDINGPOOL_ABI,
+    stabilitypool: RAACSTABILITYPOOL_ABI,
+    // liquiditypool: LIQUIDITYPOOL_ABI,
+    raacminter: RAACMINTER_ABI,
+    // contracts
+    // contracts#raacHousePrices
+    raachouseprices: RAACHOUSEPRICES_ABI,
+    feecollector: FEECOLLECTOR_ABI,
+    // contracts#auction
+    auction: Auction_json_1.default.abi,
+    auctionfactory: AuctionFactory_json_1.default.abi,
+    zeno: Zeno_json_1.default.abi,
+    zenofactory: ZenoFactory_json_1.default.abi,
+    mockvrfcoordinator: MockVRFCoordinatorV2_json_1.default.abi,
+    vrfconsumer: BaseVRFv2Consumer_json_1.default.abi,
+    raacprimerateoracle: RAACPrimeRateOracle_json_1.default.abi,
+    rwavault: RWAVAULT_ABI,
+    erc20assetadapter: ERC20ASSETADAPTER_ABI,
+    erc721assetadapter: ERC721ASSETADAPTER_ABI,
+    erc20vaultadapter: ERC20VaultAdapter_json_1.default.abi,
+    erc721vaultadapter: ERC721VaultAdapter_json_1.default.abi,
+    rwaindextoken: RWAINDEXTOKEN_ABI,
+};
+exports.ABIS = ABIS;
+const getABI = (name) => {
+    return ABIS[name];
+};
+exports.getABI = getABI;

package/dist/utils/chain.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.switchChain = exports.getChainId = exports.getSigner = exports.getContractAddress = exports.getProvider = void 0;
+const ethers_1 = require("ethers");
+const getContractAddress_1 = require("../contracts/getContractAddress");
+const chains_1 = __importDefault(require("../configs/chains"));
+const isBrowser = typeof window !== "undefined";
+const getProvider = (chainId) => {
+    const config = chains_1.default[chainId];
+    const rpcUrl = config.rpcs ? config.rpcs[0] : config.rpc;
+    return new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+};
+exports.getProvider = getProvider;
+const getContractAddress = (chainId, contractName) => {
+    return (0, getContractAddress_1.getContractAddress)(chainId, contractName);
+};
+exports.getContractAddress = getContractAddress;
+const getSigner = async (provider) => {
+    if (!isBrowser) {
+        throw new Error("getSigner is only available in browser environments");
+    }
+    if (window.ethereum) {
+        await window.ethereum.request({ method: "eth_requestAccounts" });
+        return new ethers_1.ethers.BrowserProvider(window.ethereum).getSigner();
+    }
+    else {
+        throw new Error("No Ethereum browser extension detected");
+    }
+};
+exports.getSigner = getSigner;
+const getChainId = async () => {
+    if (!isBrowser) {
+        throw new Error("getChainId is only available in browser environments");
+    }
+    if (window.ethereum) {
+        const chainId = await window.ethereum.request({ method: "eth_chainId" });
+        return parseInt(chainId, 16);
+    }
+    else {
+        throw new Error("No Ethereum browser extension detected");
+    }
+};
+exports.getChainId = getChainId;
+const switchChain = async (chainId) => {
+    if (!isBrowser) {
+        throw new Error("switchChain is only available in browser environments");
+    }
+    if (window.ethereum) {
+        try {
+            await window.ethereum.request({
+                method: "wallet_switchEthereumChain",
+                params: [{ chainId: `0x${chainId.toString(16)}` }],
+            });
+        }
+        catch (error) {
+            if (error.code === 4902) {
+                await addChain(chainId);
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+    else {
+        throw new Error("No Ethereum browser extension detected");
+    }
+};
+exports.switchChain = switchChain;
+const addChain = async (chainId) => {
+    if (!isBrowser) {
+        throw new Error("addChain is only available in browser environments");
+    }
+    const chainConfig = chains_1.default[chainId];
+    if (!chainConfig) {
+        throw new Error(`Chain configuration not found for chainId: ${chainId}`);
+    }
+    await window.ethereum.request({
+        method: "wallet_addEthereumChain",
+        params: [
+            {
+                chainId: `0x${chainId.toString(16)}`,
+                chainName: chainConfig.name,
+                nativeCurrency: chainConfig.nativeCurrency,
+                rpcUrls: chainConfig.rpcs,
+                blockExplorerUrls: chainConfig.blockExplorer,
+            },
+        ],
+    });
+};

package/dist/utils/config.js

@@ -0,0 +1,43 @@
+// let fs;
+// let path;
+// let fileURLToPath;
+// import { ChainId } from "../configs/chains";
+// // if (typeof window === 'undefined') {
+// //   // Server-side
+// //   fs = await import('fs');
+// //   path = await import('path');
+// //   fileURLToPath = await import('url').fileURLToPath;
+// // }
+// // @ts-ignore
+// import chain8453 from "../configs/chains/8453.json"; // assert { type: "json" };
+// export const getConfig = (chainId: ChainId) => {
+// 	if (typeof window === "undefined") {
+// 		// Server-side logic
+// 		console.log("Server-side logic", fs, path, fileURLToPath);
+// 		const __filename = fileURLToPath(import.meta.url);
+// 		const __dirname = path.dirname(__filename);
+// 		const configPath = path.join(
+// 			__dirname,
+// 			"..",
+// 			"configs",
+// 			"chains",
+// 			`${chainId}.json`
+// 		);
+// 		if (fs.existsSync(configPath)) {
+// 			const configData = fs.readFileSync(configPath, "utf8");
+// 			return JSON.parse(configData);
+// 		} else {
+// 			throw new Error(`Configuration not found for chainId: ${chainId}`);
+// 		}
+// 	} else {
+// 		const configs = {
+// 			8453: chain8453,
+// 		};
+// 		if (configs[chainId]) {
+// 			return configs[chainId];
+// 		} else {
+// 			throw new Error(`Configuration not found for chainId: ${chainId}`);
+// 		}
+// 	}
+// };
+// export default { getConfig };

package/dist/utils/contracts.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getContractAddress = exports.getContract = exports.getConfig = exports.setOverrideConfig = exports.getConfigs = void 0;
+const configs_1 = require("../configs");
+const chains_1 = require("../configs/chains");
+const artifacts_1 = require("./artifacts");
+const ethers_1 = require("ethers");
+let _config;
+let _configs;
+const getConfigs = () => {
+    if (!_configs) {
+        _configs = (0, configs_1.getChainsConfig)();
+    }
+    return _configs;
+};
+exports.getConfigs = getConfigs;
+const setOverrideConfig = (chainId, newConfig) => {
+    if (!_configs) {
+        _configs = (0, exports.getConfigs)();
+    }
+    // FIXME: configs is not defined here.
+    if (!chains_1.configs[chainId]) {
+        // @ts-ignore
+        chains_1.configs[chainId] = {};
+    }
+    chains_1.configs[chainId] = {
+        ...chains_1.configs[chainId],
+        ...newConfig,
+        contracts: {
+            ...chains_1.configs[chainId].contracts,
+            ...newConfig.contracts,
+        },
+    };
+};
+exports.setOverrideConfig = setOverrideConfig;
+const getConfig = (chainId) => {
+    const configs = (0, exports.getConfigs)();
+    if (!configs[chainId]) {
+        throw new Error(`Unsupported chain ID: ${chainId}. Has ${JSON.stringify(Object.keys(configs))}`);
+    }
+    return configs[chainId];
+};
+exports.getConfig = getConfig;
+const getContract = (chainId, contractName, provider) => {
+    const normalizedContractName = contractName.toLowerCase();
+    const address = (0, exports.getContractAddress)(chainId, normalizedContractName);
+    const abi = (0, artifacts_1.getABI)(normalizedContractName);
+    return new ethers_1.ethers.Contract(address, abi, provider);
+};
+exports.getContract = getContract;
+const getContractAddress = (chainId, contractName) => {
+    const normalizedContractName = contractName.toLowerCase();
+    const config = (0, exports.getConfig)(chainId);
+    if (!config) {
+        throw new Error(`Unsupported chain ID: ${chainId}`);
+    }
+    const chainKeys = ["contracts", "assets", "pools", "nfts"];
+    const keys = Object.keys(config).filter((key) => chainKeys.includes(key));
+    let address = null;
+    for (const key of keys) {
+        if (config[key] && config[key][normalizedContractName]) {
+            address = config[key][normalizedContractName]?.contract;
+            break;
+        }
+    }
+    if (!address) {
+        const hasIds = keys
+            .map((key) => `${key}: ${Object.keys(config[key]).join(", ")}`)
+            .join("\n");
+        throw new Error(`Contract ${normalizedContractName} not found for chain ID: ${chainId}.\nHas:\n${hasIds}`);
+    }
+    return address;
+};
+exports.getContractAddress = getContractAddress;
+exports.default = {
+    getContract: exports.getContract,
+    getContractAddress: exports.getContractAddress,
+    setOverrideConfig: exports.setOverrideConfig,
+    getConfig: exports.getConfig,
+    getConfigs: exports.getConfigs,
+};

package/dist/wallet/assets/approveAsset.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+async function approveAsset(chainId, assetId, spender, amount, signer) {
+    if (!signer) {
+        throw new Error("Wallet not connected");
+    }
+    try {
+        const tokenAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
+        // @ts-ignore
+        const abi = (0, artifacts_1.getABI)(assetId);
+        const tokenContract = new ethers_1.ethers.Contract(tokenAddress, abi, signer);
+        const amountInWei = ethers_1.ethers.parseEther(amount);
+        // const { maxFeePerGas } = await estimateGasPrice(signer);
+        const tx = await tokenContract.approve(spender, amountInWei, {
+            // maxFeePerGas,
+            nonce: await signer.getNonce(),
+        });
+        console.log(`Approval transaction sent for ${assetId}:`, tx.hash);
+        const receipt = await tx.wait();
+        console.log(`Approved ${amount} ${assetId} for ${spender} successfully:`, receipt.transactionHash);
+        return receipt;
+    }
+    catch (error) {
+        console.error(`Approval error for ${assetId}:`, error);
+        throw new Error(`Token approval failed for ${assetId}: ${error.message}`);
+    }
+}
+exports.default = approveAsset;

package/dist/wallet/assets/burnAsset.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+async function burnAsset(chainId, assetId, amount, signer) {
+    try {
+        if (!signer) {
+            throw new Error("Wallet not connected");
+        }
+        const { assets } = (0, contracts_1.getConfig)(chainId);
+        const asset = Object.values(assets).find(
+        // @ts-ignore
+        (asset) => asset.id.toLowerCase() === assetId.toLowerCase());
+        if (!asset) {
+            throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
+        }
+        // @ts-ignore
+        const contractAddress = asset.contract;
+        // @ts-ignore
+        const abi = (0, artifacts_1.getABI)(assetId);
+        const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
+        const amountToBurn = ethers_1.ethers.parseEther(amount.toString());
+        if (!contract.burn) {
+            throw new Error(`Burn function not found on contract ${contractAddress}`);
+        }
+        const tx = await contract.burn(amountToBurn, {
+            nonce: +(await signer.getNonce()),
+        });
+        console.log(`Burning transaction sent for ${assetId}:`, tx.hash);
+        const receipt = await tx.wait();
+        console.log(`Burned ${amount} ${assetId} successfully:`, receipt.transactionHash);
+        return receipt;
+    }
+    catch (error) {
+        console.error(`Error burning asset ${assetId}:`, error);
+        throw new Error(`Burning failed for ${assetId}: ${error.message}`);
+    }
+}
+exports.default = burnAsset;

package/dist/wallet/assets/getAllowance.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+async function getAllowance(chainId, assetId, owner, spender, provider) {
+    try {
+        if (assetId === "eth") {
+            // ETH doesn't have an allowance concept, return max uint256 value ?
+            return ethers_1.ethers.formatEther(ethers_1.ethers.MaxUint256);
+        }
+        const ALLOWANCE_ABI = [
+            "function allowance(address,address) view returns (uint256)",
+        ];
+        const contractAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
+        const contract = new ethers_1.ethers.Contract(contractAddress, ALLOWANCE_ABI, provider);
+        const allowance = await contract.allowance(owner, spender);
+        return ethers_1.ethers.formatEther(allowance);
+    }
+    catch (error) {
+        console.error(`Error getting allowance for asset ${assetId}:`, error);
+        console.log({ assetId, owner, spender });
+        console.log(error);
+        return 0;
+    }
+}
+exports.default = getAllowance;

package/dist/wallet/assets/getAsset.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const contracts_1 = require("../../utils/contracts");
+async function getAsset(chainId, assetId, address, provider) {
+    const { assets } = (0, contracts_1.getConfig)(chainId);
+    // @ts-ignore
+    const asset = assets[assetId];
+    let response = {
+        ...asset,
+        balance: 0,
+    };
+    const owner = address;
+    try {
+        const balance = await this.getBalance(chainId, assetId, owner, provider);
+        response.balance = balance;
+    }
+    catch (error) {
+        console.log(`Error getting balance: ${error}`);
+    }
+    return response;
+}
+exports.default = getAsset;

package/dist/wallet/assets/getAssets.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const contracts_1 = require("../../utils/contracts");
+async function getAssets(chainId, address, provider) {
+    const { assets } = (0, contracts_1.getConfig)(chainId);
+    const responses = {};
+    const assetIds = Object.keys(assets);
+    const assetPromises = assetIds.map(async (assetId) => {
+        // @ts-ignore
+        const asset = await this.getAsset(chainId, assetId, address, signer);
+        responses[assetId] = {
+            // @ts-ignore
+            ...assets[assetId],
+            ...asset,
+        };
+        return responses[assetId];
+    });
+    const assetResponses = await Promise.all(assetPromises);
+    const response = {};
+    assetResponses.forEach((asset) => {
+        // @ts-ignore
+        response[asset.id] = asset;
+    });
+    return response;
+}
+exports.default = getAssets;

package/dist/wallet/assets/getBalance.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+async function getBalance(chainId, assetId, address, provider) {
+    const BALANCE_OF_ABI = ["function balanceOf(address) view returns (uint256)", "function symbol() view returns (string)", "function decimals() view returns (uint8)"];
+    try {
+        if (assetId === "eth") {
+            const balance = await provider.getBalance(address);
+            const parsedBalance = parseFloat(ethers_1.ethers.formatEther(balance));
+            return {
+                balance: parsedBalance,
+                symbol: "ETH",
+                decimals: 18,
+            };
+        }
+        const contractAddress = (0, contracts_1.getContractAddress)(chainId, assetId);
+        const contract = new ethers_1.ethers.Contract(contractAddress, BALANCE_OF_ABI, provider);
+        const balance = await contract.balanceOf(address);
+        const symbol = await contract.symbol();
+        const decimals = await contract.decimals();
+        const parsedBalance = ethers_1.ethers.formatUnits(balance, decimals);
+        return {
+            balance: parsedBalance,
+            symbol,
+            decimals,
+        };
+    }
+    catch (error) {
+        console.error(`Error getting balance for asset ${assetId}:`, error);
+        return {
+            balance: 0,
+            symbol: "",
+            decimals: 0,
+        };
+    }
+}
+exports.default = getBalance;

package/dist/wallet/assets/mintAsset.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+async function mintAsset(chainId, assetId, amount, address, signer) {
+    try {
+        if (!signer) {
+            throw new Error("Wallet not connected");
+        }
+        const { assets } = (0, contracts_1.getConfig)(chainId);
+        console.log("assets", assets);
+        const asset = Object.values(assets).find(
+        // @ts-ignore
+        (asset) => asset.id.toLowerCase() === assetId.toLowerCase());
+        if (!asset) {
+            throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
+        }
+        // @ts-ignore
+        const contractAddress = asset.contract;
+        let contract;
+        // @ts-ignore
+        const abi = (0, artifacts_1.getABI)(assetId);
+        contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
+        if (!contract.mint) {
+            throw new Error(`Mint function not found on contract ${contractAddress}`);
+        }
+        const tx = await contract.mint(address, ethers_1.ethers.parseEther(amount.toString()), {
+            // maxFeePerGas,
+            nonce: +(await signer.getNonce()),
+        });
+        console.log(`Minting transaction sent for ${assetId}:`, tx.hash);
+        const receipt = await tx.wait();
+        console.log(`Minted ${amount} ${assetId} successfully:`, receipt.hash);
+        return receipt;
+    }
+    catch (error) {
+        console.error(`Error minting asset ${assetId}:`, error);
+        throw new Error(`Minting failed for ${assetId}: ${error.message}`);
+    }
+}
+exports.default = mintAsset;