@raac/rpc 1.0.0

package/utils/config.ts

@@ -0,0 +1,49 @@
+// 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/utils/contracts.ts

@@ -0,0 +1,94 @@
+import { getChainsConfig, getChainConfig } from "../configs";
+import { ChainId, configs } from "../configs/chains";
+import { Chain } from "../configs/chains/chain";
+import { ABIS, ContractType, getABI } from "./artifacts";
+import { ethers, Provider } from "ethers";
+
+let _config;
+let _configs: ReturnType<typeof getChainsConfig>;
+
+export const getConfigs = () => {
+	if (!_configs) {
+		_configs = getChainsConfig();
+	}
+	return _configs;
+};
+
+export const setOverrideConfig = (chainId: ChainId, newConfig: any) => {
+	if (!_configs) {
+		_configs = getConfigs();
+	}
+	// FIXME: configs is not defined here.
+	if (!configs[chainId]) {
+		// @ts-ignore
+		configs[chainId] = {};
+	}
+	configs[chainId] = {
+		...configs[chainId],
+		...newConfig,
+		contracts: {
+			...configs[chainId].contracts,
+			...newConfig.contracts,
+		},
+	};
+};
+
+export const getConfig = (chainId: ChainId) => {
+	const configs = getConfigs();
+	if (!configs[chainId]) {
+		throw new Error(
+			`Unsupported chain ID: ${chainId}. Has ${JSON.stringify(
+				Object.keys(configs)
+			)}`
+		);
+	}
+	return configs[chainId];
+};
+
+export const getContract = (
+	chainId: ChainId,
+	contractName: ContractType,
+	provider: Provider
+) => {
+	const normalizedContractName =
+		contractName.toLowerCase() as keyof typeof ABIS;
+	const address = getContractAddress(chainId, normalizedContractName);
+	const abi = getABI(normalizedContractName);
+	return new ethers.Contract(address, abi, provider);
+};
+
+export const getContractAddress = (chainId: ChainId, contractName: string) => {
+	const normalizedContractName = contractName.toLowerCase();
+	const config = getConfig(chainId);
+	if (!config) {
+		throw new Error(`Unsupported chain ID: ${chainId}`);
+	}
+	const chainKeys = ["contracts", "assets", "pools", "nfts"] as (keyof Chain)[];
+	const keys = (Object.keys(config) as (keyof Chain)[]).filter((key) =>
+		chainKeys.includes(key)
+	);
+	let address = null;
+	for (const key of keys) {
+		if (config[key] && (config[key] as any)[normalizedContractName]) {
+			address = (config[key] as any)[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;
+};
+
+export default {
+	getContract,
+	getContractAddress,
+	setOverrideConfig,
+	getConfig,
+	getConfigs,
+};

package/wallet/assets/approveAsset.ts

@@ -0,0 +1,44 @@
+import { ethers, Signer } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { ABIS, AssetType, getABI } from "../../utils/artifacts";
+import estimateGasPrice from "../../methods/commons/estimateGasPrice";
+import { ChainId } from "../../configs/chains/index";
+
+async function approveAsset(
+	chainId: ChainId,
+	assetId: AssetType,
+	spender: string,
+	amount: string,
+	signer: Signer
+) {
+	if (!signer) {
+		throw new Error("Wallet not connected");
+	}
+
+	try {
+		const tokenAddress = getContractAddress(chainId, assetId);
+		const abi = getABI(assetId);
+		const tokenContract = new ethers.Contract(tokenAddress, abi, signer);
+
+		const amountInWei = 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: any) {
+		console.error(`Approval error for ${assetId}:`, error);
+		throw new Error(`Token approval failed for ${assetId}: ${error.message}`);
+	}
+}
+
+export default approveAsset;

package/wallet/assets/burnAsset.ts

@@ -0,0 +1,55 @@
+import { ethers, Signer } from "ethers";
+import { getConfig } from "../../utils/contracts";
+import estimateGasPrice from "../../methods/commons/estimateGasPrice";
+import { ABIS, AssetType, getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+
+async function burnAsset(
+	chainId: ChainId,
+	assetId: AssetType,
+	amount: bigint,
+	signer: Signer
+) {
+	try {
+		if (!signer) {
+			throw new Error("Wallet not connected");
+		}
+
+		const { assets } = getConfig(chainId);
+		const asset = Object.values(assets).find(
+			(asset) => asset.id.toLowerCase() === (assetId as string).toLowerCase()
+		);
+		if (!asset) {
+			throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
+		}
+
+		const contractAddress = asset.contract;
+		const abi = getABI(assetId);
+		const contract = new ethers.Contract(contractAddress, abi, signer);
+
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+		const amountToBurn = 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: any) {
+		console.error(`Error burning asset ${assetId}:`, error);
+		throw new Error(`Burning failed for ${assetId}: ${error.message}`);
+	}
+}
+
+export default burnAsset;

package/wallet/assets/getAllowance.ts

@@ -0,0 +1,38 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { ABIS, AssetType } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+
+async function getAllowance(
+	chainId: ChainId,
+	assetId: AssetType,
+	owner: string,
+	spender: string,
+	provider: Provider
+) {
+	try {
+		if (assetId === "eth") {
+			// ETH doesn't have an allowance concept, return max uint256 value ?
+			return ethers.formatEther(ethers.MaxUint256);
+		}
+
+		const ALLOWANCE_ABI = [
+			"function allowance(address,address) view returns (uint256)",
+		];
+		const contractAddress = getContractAddress(chainId, assetId);
+		const contract = new ethers.Contract(
+			contractAddress,
+			ALLOWANCE_ABI,
+			provider
+		);
+		const allowance = await contract.allowance(owner, spender);
+		return ethers.formatEther(allowance);
+	} catch (error: any) {
+		console.error(`Error getting allowance for asset ${assetId}:`, error);
+		console.log({ assetId, owner, spender });
+		console.log(error);
+		return 0;
+	}
+}
+
+export default getAllowance;

package/wallet/assets/getAsset.ts

@@ -0,0 +1,33 @@
+import { Provider, Signer } from "ethers";
+import { AssetType } from "../../utils/artifacts";
+import { getConfig } from "../../utils/contracts";
+import { ChainId } from "../../configs/chains/index";
+
+async function getAsset(
+	chainId: ChainId,
+	assetId: string,
+	address: string,
+	provider: Provider
+) {
+	const { assets } = getConfig(chainId);
+	// @ts-ignore
+	const asset = assets[assetId];
+	let response = {
+		...asset,
+		balance: 0,
+	};
+
+	const owner = address;
+
+	try {
+		// @ts-expect-error The method is used in the RPCLibrary class and therefore, it has access to this.
+		const balance = await this.getBalance(chainId, assetId, owner, provider);
+		response.balance = parseFloat(balance).toString();
+	} catch (error: any) {
+		console.log(`Error getting balance: ${error}`);
+	}
+
+	return response;
+}
+
+export default getAsset;

package/wallet/assets/getAssets.ts

@@ -0,0 +1,35 @@
+import { Provider, Signer } from "ethers";
+import { getConfig } from "../../utils/contracts";
+import { ChainId } from "../../configs/chains/index";
+import RPCLibrary from "../../RPCLibrary";
+
+async function getAssets(
+	chainId: ChainId,
+	address: string,
+	provider: Provider
+) {
+	const { assets } = getConfig(chainId);
+	const responses: any = {};
+
+	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;
+}
+
+export default getAssets;

package/wallet/assets/getBalance.ts

@@ -0,0 +1,34 @@
+import { ethers, Provider } from "ethers";
+import { getContractAddress } from "../../utils/contracts";
+import { AssetType, getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+
+async function getBalance(
+	chainId: ChainId,
+	assetId: AssetType,
+	address: string,
+	provider: 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.formatEther(balance));
+			return parsedBalance;
+		}
+		const contractAddress = getContractAddress(chainId, assetId);
+		const contract = new ethers.Contract(
+			contractAddress,
+			BALANCE_OF_ABI,
+			provider
+		);
+		const balance = await contract.balanceOf(address);
+		const parsedBalance = parseFloat(ethers.formatEther(balance));
+		return parsedBalance.toString();
+	} catch (error: any) {
+		console.error(`Error getting balance for asset ${assetId}:`, error);
+		return 0;
+	}
+}
+
+export default getBalance;

package/wallet/assets/mintAsset.ts

@@ -0,0 +1,57 @@
+import { ethers, Signer } from "ethers";
+import { getConfig } from "../../utils/contracts";
+import estimateGasPrice from "../../methods/commons/estimateGasPrice";
+import { AssetType, getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+
+async function mintAsset(
+	chainId: ChainId,
+	assetId: AssetType,
+	amount: bigint,
+	address: string,
+	signer: Signer
+) {
+	try {
+		if (!signer) {
+			throw new Error("Wallet not connected");
+		}
+
+		const { assets } = getConfig(chainId);
+		console.log("assets", assets);
+		const asset = Object.values(assets).find(
+			(asset) => asset.id.toLowerCase() === (assetId as string).toLowerCase()
+		);
+		if (!asset) {
+			throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
+		}
+
+		const contractAddress = asset.contract;
+		let contract;
+
+		const abi = getABI(assetId);
+		contract = new ethers.Contract(contractAddress, abi, signer);
+
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+		if (!contract.mint) {
+			throw new Error(`Mint function not found on contract ${contractAddress}`);
+		}
+		const tx = await contract.mint(
+			address,
+			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: any) {
+		console.error(`Error minting asset ${assetId}:`, error);
+		throw new Error(`Minting failed for ${assetId}: ${error.message}`);
+	}
+}
+
+export default mintAsset;

package/wallet/assets/transferAsset.ts

@@ -0,0 +1,78 @@
+import { ethers, Signer } from "ethers";
+import { getConfig } from "../../utils/contracts";
+import estimateGasPrice from "../../methods/commons/estimateGasPrice";
+import { AssetType, getABI } from "../../utils/artifacts";
+import { ChainId } from "../../configs/chains/index";
+
+async function transferAsset(
+	chainId: ChainId,
+	assetId: AssetType,
+	amount: bigint,
+	fromAddress: string,
+	toAddress: string,
+	signer: Signer
+) {
+	try {
+		if (!signer) {
+			throw new Error("Wallet not connected");
+		}
+
+		const { maxFeePerGas } = await estimateGasPrice(signer);
+		const amountToTransfer = ethers.parseEther(amount.toString());
+
+		if ((assetId as string).toLowerCase() === "eth") {
+			// Handle ETH transfer
+			const tx = await signer.sendTransaction({
+				to: toAddress,
+				value: amountToTransfer,
+				maxFeePerGas,
+				nonce: await signer.getNonce(),
+			});
+
+			console.log(`ETH transfer transaction sent:`, tx.hash);
+			const receipt = await tx.wait();
+			console.log(
+				`Transferred ${amount} ETH from ${fromAddress} to ${toAddress} successfully:`,
+				(await receipt?.getTransaction())?.hash
+			);
+			return receipt;
+		} else {
+			// Handle ERC20 token transfer
+			const { assets } = getConfig(chainId);
+			const asset = Object.values(assets).find(
+				(asset) => asset.id.toLowerCase() === (assetId as string).toLowerCase()
+			);
+			if (!asset) {
+				throw new Error(`Asset ${assetId} not found on chain ${chainId}`);
+			}
+
+			const contractAddress = asset.contract;
+			const abi = getABI(assetId);
+			const contract = new ethers.Contract(contractAddress, abi, signer);
+
+			if (!contract.transfer) {
+				throw new Error(
+					`Transfer function not found on contract ${contractAddress}`
+				);
+			}
+
+			const tx = await contract.transfer(toAddress, amountToTransfer, {
+				maxFeePerGas,
+				nonce: await signer.getNonce(),
+			});
+
+			console.log(`Transfer transaction sent for ${assetId}:`, tx.hash);
+			const receipt = await tx.wait();
+			console.log(
+				`Transferred ${amount} ${assetId} from ${fromAddress} to ${toAddress} successfully:`,
+				receipt.transactionHash
+			);
+			return receipt;
+		}
+	} catch (error: any) {
+		console.error(`Error transferring asset ${assetId}:`, error);
+		throw new Error(`Transfer failed for ${assetId}: ${error.message}`);
+	}
+}
+
+export default transferAsset;