@raac/rpc 1.0.0 → 1.0.2-beta.1

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,22 @@
+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;
+};
+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;
+    };
+};
+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,5 @@
+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<string | number>;
+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,74 @@
+"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 IndexToken_json_1 = __importDefault(require("../artifacts/core/tokens/IndexToken.sol/IndexToken.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 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 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,
+    indextoken: IndexToken_json_1.default.abi,
+    mockvrfcoordinator: MockVRFCoordinatorV2_json_1.default.abi,
+    vrfconsumer: BaseVRFv2Consumer_json_1.default.abi,
+    eth: [],
+};
+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/{utils/config.ts → dist/utils/config.js}

@@ -1,7 +1,6 @@
 // let fs;
 // let path;
 // let fileURLToPath;
-
 // import { ChainId } from "../configs/chains";
 // // if (typeof window === 'undefined') {
 // //   // Server-side
@@ -9,10 +8,8 @@
 // //   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
@@ -26,7 +23,6 @@
 // 			"chains",
 // 			`${chainId}.json`
 // 		);
-
 // 		if (fs.existsSync(configPath)) {
 // 			const configData = fs.readFileSync(configPath, "utf8");
 // 			return JSON.parse(configData);
@@ -37,7 +33,6 @@
 // 		const configs = {
 // 			8453: chain8453,
 // 		};
-
 // 		if (configs[chainId]) {
 // 			return configs[chainId];
 // 		} else {
@@ -45,5 +40,4 @@
 // 		}
 // 	}
 // };
-
 // 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,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const artifacts_1 = require("../../utils/artifacts");
+const estimateGasPrice_1 = __importDefault(require("../../methods/commons/estimateGasPrice"));
+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 (0, estimateGasPrice_1.default)(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,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const estimateGasPrice_1 = __importDefault(require("../../methods/commons/estimateGasPrice"));
+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 { maxFeePerGas } = await (0, estimateGasPrice_1.default)(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, {
+            maxFeePerGas,
+            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 = parseFloat(balance).toString();
+    }
+    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,24 @@
+"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)"];
+    try {
+        if (assetId === "eth") {
+            const balance = await provider.getBalance(address);
+            const parsedBalance = parseFloat(ethers_1.ethers.formatEther(balance));
+            return parsedBalance;
+        }
+        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 parsedBalance = parseFloat(ethers_1.ethers.formatEther(balance));
+        return parsedBalance.toString();
+    }
+    catch (error) {
+        console.error(`Error getting balance for asset ${assetId}:`, error);
+        return 0;
+    }
+}
+exports.default = getBalance;

package/dist/wallet/assets/mintAsset.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ethers_1 = require("ethers");
+const contracts_1 = require("../../utils/contracts");
+const estimateGasPrice_1 = __importDefault(require("../../methods/commons/estimateGasPrice"));
+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);
+        const { maxFeePerGas } = await (0, estimateGasPrice_1.default)(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;