hueso/P2Pix-Front-End
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Adjusted bid selection and improve UX.

Browse Source
This commit is contained in:
Filipe Soccol
2024-11-07 17:53:20 -03:00
parent b487949482
commit 5b49fdcffd
11 changed files with 178 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

29
src/blockchain/addresses.ts
View File

@@ -1,23 +1,22 @@
import { useEtherStore } from "@/store/ether";
import { NetworkEnum, TokenEnum } from "@/model/NetworkEnum";
import { JsonRpcProvider } from "ethers";
const Tokens: { [key in NetworkEnum]: { [key in TokenEnum]: string } } = {
[NetworkEnum.sepolia]: {
BRZ: "0x3eBE67A2C7bdB2081CBd34ba3281E90377462289",
BRX: "0x3eBE67A2C7bdB2081CBd34ba3281E90377462289",
},
[NetworkEnum.polygon]: {
BRZ: "0xC86042E9F2977C62Da8c9dDF7F9c40fde4796A29",
BRX: "0xC86042E9F2977C62Da8c9dDF7F9c40fde4796A29",
// BRX: "0x3eBE67A2C7bdB2081CBd34ba3281E90377462289",
},
[NetworkEnum.rootstock]: {
BRZ: "0xfE841c74250e57640390f46d914C88d22C51e82e",
BRX: "0xfE841c74250e57640390f46d914C88d22C51e82e",
}
// BRX: "0xfE841c74250e57640390f46d914C88d22C51e82e",
},
};
export const getTokenByAddress = (address: string) => {
for (const [, network] of Object.entries(NetworkEnum)) {
for (const network of Object.values(NetworkEnum).filter(
(v) => !isNaN(Number(v))
)) {
for (const token of Object.keys(Tokens[network as NetworkEnum])) {
if (address === Tokens[network as NetworkEnum][token as TokenEnum]) {
return token as TokenEnum;
@@ -37,26 +36,29 @@ const getP2PixAddress = (network?: NetworkEnum): string => {
const etherStore = useEtherStore();
const possibleP2PixAddresses: { [key in NetworkEnum]: string } = {
[NetworkEnum.sepolia]: "0xb7cD135F5eFD9760981e02E2a898790b688939fe",
[NetworkEnum.polygon]: "0x4A2886EAEc931e04297ed336Cc55c4eb7C75BA00",
[NetworkEnum.rootstock]: "0x98ba35eb14b38D6Aa709338283af3e922476dE34",
};
return possibleP2PixAddresses[network ? network : etherStore.networkName];
};
const getProviderUrl = (): string => {
const getProviderUrl = (network?: NetworkEnum): string => {
const etherStore = useEtherStore();
const possibleProvidersUrls: { [key in NetworkEnum]: string } = {
[NetworkEnum.sepolia]: import.meta.env.VITE_SEPOLIA_API_URL,
[NetworkEnum.polygon]: import.meta.env.VITE_MUMBAI_API_URL,
[NetworkEnum.rootstock]: import.meta.env.VITE_RSK_API_URL,
};
return possibleProvidersUrls[etherStore.networkName];
return possibleProvidersUrls[network || etherStore.networkName];
};
const getProviderByNetwork = (network: NetworkEnum): JsonRpcProvider => {
console.log("network", network);
return new JsonRpcProvider(getProviderUrl(network), network);
};
const isPossibleNetwork = (networkChain: NetworkEnum): boolean => {
return (Number(networkChain) in NetworkEnum);
return Number(networkChain) in NetworkEnum;
};
export {
@@ -64,4 +66,5 @@ export {
getProviderUrl,
isPossibleNetwork,
getP2PixAddress,
getProviderByNetwork,
};

107
src/blockchain/events.ts
View File

@@ -1,59 +1,64 @@
import { useEtherStore } from "@/store/ether";
import { Contract, formatEther, Interface, JsonRpcProvider } from "ethers";
import { Contract, formatEther, Interface } from "ethers";
import p2pix from "@/utils/smart_contract_files/P2PIX.json";
import { getContract } from "./provider";
import type { ValidDeposit } from "@/model/ValidDeposit";
import { getP2PixAddress, getTokenAddress } from "./addresses";
import {
getP2PixAddress,
getProviderByNetwork,
getTokenAddress,
} from "./addresses";
import { NetworkEnum } from "@/model/NetworkEnum";
import type { UnreleasedLock } from "@/model/UnreleasedLock";
import type { Pix } from "@/model/Pix";
const getNetworksLiquidity = async (): Promise<void> => {
const etherStore = useEtherStore();
const sepoliaProvider = new JsonRpcProvider(
import.meta.env.VITE_SEPOLIA_API_URL,
11155111
); // sepolia provider
const rootstockProvider = new JsonRpcProvider(
import.meta.env.VITE_RSK_API_URL,
31
); // rootstock provider
const p2pContractSepolia = new Contract(
getP2PixAddress(NetworkEnum.sepolia),
p2pix.abi,
sepoliaProvider
);
const p2pContractRootstock = new Contract(
getP2PixAddress(NetworkEnum.rootstock),
p2pix.abi,
rootstockProvider
);
etherStore.setLoadingNetworkLiquidity(true);
const depositListSepolia = await getValidDeposits(
getTokenAddress(etherStore.selectedToken, NetworkEnum.sepolia),
p2pContractSepolia
);
// const depositListMumbai = await getValidDeposits(
// getTokenAddress(etherStore.selectedToken, NetworkEnum.polygon),
// p2pContractMumbai
// );
const depositListRootstock = await getValidDeposits(
getTokenAddress(etherStore.selectedToken, NetworkEnum.rootstock),
p2pContractRootstock
);
const depositLists: ValidDeposit[][] = [];
etherStore.setDepositsValidListSepolia(depositListSepolia);
// etherStore.setDepositsValidListMumbai(depositListMumbai);
etherStore.setDepositsValidListRootstock(depositListRootstock);
for (const network of Object.values(NetworkEnum).filter(
(v) => !isNaN(Number(v))
)) {
console.log("getNetworksLiquidity", network);
const p2pContract = new Contract(
getP2PixAddress(network as NetworkEnum),
p2pix.abi,
getProviderByNetwork(network as NetworkEnum)
);
depositLists.push(
await getValidDeposits(
getTokenAddress(etherStore.selectedToken, network as NetworkEnum),
network as NetworkEnum,
p2pContract
)
);
}
etherStore.setDepositsValidList(depositLists.flat());
etherStore.setLoadingNetworkLiquidity(false);
};
const getPixKey = async (seller: string, token: string): Promise<string> => {
const p2pContract = await getContract();
const pixKeyHex = await p2pContract.getPixTarget(seller, token);
// Remove '0x' prefix and convert hex to UTF-8 string
const bytes = new Uint8Array(
pixKeyHex
.slice(2)
.match(/.{1,2}/g)
.map((byte: string) => parseInt(byte, 16))
);
// Remove null bytes from the end of the string
return new TextDecoder().decode(bytes).replace(/\0/g, "");
};
const getValidDeposits = async (
token: string,
network: NetworkEnum,
contract?: Contract
): Promise<ValidDeposit[]> => {
let p2pContract: Contract;
@@ -65,8 +70,11 @@ const getValidDeposits = async (
}
const filterDeposits = p2pContract.filters.DepositAdded(null);
const eventsDeposits = await p2pContract.queryFilter(filterDeposits);
const eventsDeposits = await p2pContract.queryFilter(
filterDeposits
// 0,
// "latest"
);
if (!contract) p2pContract = await getContract(); // get metamask provider contract
const depositList: { [key: string]: ValidDeposit } = {};
@@ -78,28 +86,22 @@ const getValidDeposits = async (
});
// Get liquidity only for the selected token
if (decoded?.args.token != token) continue;
const mappedBalance = await p2pContract.getBalance(
decoded.args.seller,
token
);
const mappedPixTarget = await p2pContract.getPixTarget(
decoded.args.seller,
token
);
let validDeposit: ValidDeposit | null = null;
if (mappedBalance._hex) {
if (mappedBalance) {
validDeposit = {
token: token,
blockNumber: deposit.blockNumber,
remaining: Number(formatEther(mappedBalance._hex)),
remaining: Number(formatEther(mappedBalance)),
seller: decoded.args.seller,
pixKey: mappedPixTarget,
network,
pixKey: "",
};
}
if (validDeposit) depositList[decoded.args.seller + token] = validDeposit;
}
@@ -127,4 +129,9 @@ const getUnreleasedLockById = async (
};
};
export { getValidDeposits, getNetworksLiquidity, getUnreleasedLockById };
export {
getValidDeposits,
getNetworksLiquidity,
getUnreleasedLockById,
getPixKey,
};

30
src/blockchain/wallet.ts
View File

@@ -25,9 +25,9 @@ export const updateWalletStatus = async (): Promise<void> => {
const etherStore = useEtherStore();
const provider = await getProvider();
const signer = await provider.getSigner();
const signer = await provider?.getSigner();
const { chainId } = await provider.getNetwork();
const { chainId } = await provider?.getNetwork();
if (!isPossibleNetwork(Number(chainId))) {
window.alert("Invalid chain!:" + chainId);
return;
@@ -40,7 +40,7 @@ export const updateWalletStatus = async (): Promise<void> => {
signer
);
const walletAddress = await provider.send("eth_requestAccounts", []);
const walletAddress = await provider?.send("eth_requestAccounts", []);
const balance = await mockTokenContract.balanceOf(walletAddress[0]);
etherStore.setBalance(formatEther(balance));
@@ -52,9 +52,9 @@ export const listValidDepositTransactionsByWalletAddress = async (
): Promise<ValidDeposit[]> => {
const etherStore = useEtherStore();
const walletDeposits = await getValidDeposits(
getTokenAddress(etherStore.selectedToken)
getTokenAddress(etherStore.selectedToken),
etherStore.networkName
);
if (walletDeposits) {
return walletDeposits
.filter((deposit) => deposit.seller == walletAddress)
@@ -69,7 +69,6 @@ export const listValidDepositTransactionsByWalletAddress = async (
const getLockStatus = async (id: [BigInt]): Promise<number> => {
const p2pContract = await getContract();
const res = await p2pContract.getLocksStatus([id]);
return res[1][0];
};
@@ -113,33 +112,41 @@ export const listAllTransactionByWalletAddress = async (
): Promise<WalletTransaction[]> => {
const p2pContract = await getContract(true);
// Get deposits
const filterDeposits = p2pContract.filters.DepositAdded([walletAddress]);
const eventsDeposits = await p2pContract.queryFilter(
filterDeposits,
0,
"latest"
);
console.log("Fetched all wallet deposits");
// Get locks
const filterAddedLocks = p2pContract.filters.LockAdded([walletAddress]);
const eventsAddedLocks = await p2pContract.queryFilter(
filterAddedLocks,
0,
"latest"
);
console.log("Fetched all wallet locks");
// Get released locks
const filterReleasedLocks = p2pContract.filters.LockReleased([walletAddress]);
const eventsReleasedLocks = await p2pContract.queryFilter(
filterReleasedLocks,
0,
"latest"
);
console.log("Fetched all wallet released locks");
// Get withdrawn deposits
const filterWithdrawnDeposits = p2pContract.filters.DepositWithdrawn([
walletAddress,
]);
const eventsWithdrawnDeposits = await p2pContract.queryFilter(
filterWithdrawnDeposits
);
console.log("Fetched all wallet withdrawn deposits");
const lockStatusFiltered = await filterLockStatus(
[
@@ -210,10 +217,13 @@ const listLockTransactionBySellerAddress = async (
sellerAddress: string
): Promise<LogDescription[]> => {
const p2pContract = await getContract(true);
console.log("Will get locks as seller", sellerAddress);
const filterAddedLocks = p2pContract.filters.LockAdded();
const eventsReleasedLocks = await p2pContract.queryFilter(filterAddedLocks);
const eventsReleasedLocks = await p2pContract.queryFilter(
filterAddedLocks
// 0,
// "latest"
);
return eventsReleasedLocks
.map((lock) => {
const IPix2Pix = new Interface(p2pix.abi);
@@ -264,7 +274,7 @@ export const checkUnreleasedLock = async (
export const getActiveLockAmount = async (
walletAddress: string
): Promise<number> => {
const p2pContract = await getContract();
const p2pContract = await getContract(true);
const lockSeller = await listLockTransactionBySellerAddress(walletAddress);
const lockStatus = await p2pContract.getLocksStatus(