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

Clean up app strucutre deleting blockchain file and add methods on blockchain folder

Browse Source 
Co-authored-by: brunoedcf <brest.dallacosta@outlook.com>
This commit is contained in:
RcleydsonR
2023-01-17 19:31:25 -03:00
parent d78f7f1fdf
commit 8338064dcd
7 changed files with 155 additions and 304 deletions
Download Patch File Download Diff File Expand all files Collapse all files

143
src/blockchain/buyerMethods.ts
View File

@@ -6,7 +6,78 @@ import { getP2PixAddress } from "./addresses";
import p2pix from "../utils/smart_contract_files/P2PIX.json";
import { BigNumber, ethers, type Event } from "ethers";
import { formatEther } from "ethers/lib/utils";
import { formatEther, parseEther } from "ethers/lib/utils";
// Buyer Flow methods //
// Make lock
const addLock = async (
depositId: BigNumber,
amount: number
): Promise<Event> => {
const etherStore = useEtherStore();
const provider = getProvider();
const signer = provider.getSigner();
const p2pContract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
const lock = await p2pContract.lock(
depositId, // BigNumber
etherStore.walletAddress, // String "0x70997970C51812dc3A010C7d01b50e0d17dc79C8" (Example)
ethers.constants.AddressZero, // String "0x0000000000000000000000000000000000000000"
0,
parseEther(String(amount)), // BigNumber
[],
[]
);
lock.wait();
return lock;
};
// Release lock
const releaseLock = async (
pixKey: string,
amount: Number,
e2eId: string,
lockId: string
) => {
const mockBacenSigner = new ethers.Wallet(
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
);
const messageToSign = ethers.utils.solidityKeccak256(
["string", "uint256", "bytes32"],
[
pixKey,
formatEther(String(amount)),
ethers.utils.formatBytes32String(e2eId),
]
);
const messageHashBytes = ethers.utils.arrayify(messageToSign);
const flatSig = await mockBacenSigner.signMessage(messageHashBytes);
const provider = getProvider();
const sig = ethers.utils.splitSignature(flatSig);
const signer = provider.getSigner();
const p2pContract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
const release = await p2pContract.release(
lockId,
ethers.constants.AddressZero,
ethers.utils.formatBytes32String(e2eId),
sig.r,
sig.s,
sig.v
);
release.wait();
return release;
};
const cancelDeposit = async (depositId: BigNumber): Promise<Boolean> => {
const provider = getProvider();
@@ -34,79 +105,9 @@ const withdrawDeposit = async (depositId: BigNumber): Promise<Boolean> => {
return true;
};
const addLock = async (
depositId: BigNumber,
amount: number
): Promise<Event> => {
const etherStore = useEtherStore();
const provider = getProvider();
const signer = provider.getSigner();
const p2pContract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
// Make lock
// const oldEventsLen = etherStore.locksAddedList.length;
const lock = await p2pContract.lock(
depositId, // BigNumber
etherStore.walletAddress, // String "0x70997970C51812dc3A010C7d01b50e0d17dc79C8" (Example)
ethers.constants.AddressZero, // String "0x0000000000000000000000000000000000000000"
0,
formatEther(String(amount)), // BigNumber
[],
[]
);
lock.wait();
// while (etherStore.locksAddedList.length === oldEventsLen) {
// await updateLockAddedEvents();
// await updateValidDeposits();
// }
return lock;
};
// Releases lock by specific ID and other additional data
const releaseLock = async (
pixKey: string,
amount: Number,
e2eId: string,
lockId: string
) => {
const provider = getProvider();
const mockBacenSigner = new ethers.Wallet(
"0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80"
);
const messageToSign = ethers.utils.solidityKeccak256(
["string", "uint256", "bytes32"],
[
pixKey,
formatEther(String(amount)),
ethers.utils.formatBytes32String(e2eId),
]
);
const messageHashBytes = ethers.utils.arrayify(messageToSign);
const flatSig = await mockBacenSigner.signMessage(messageHashBytes);
const sig = ethers.utils.splitSignature(flatSig);
const signer = provider.getSigner();
const p2pContract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
const release = await p2pContract.release(
lockId,
ethers.constants.AddressZero,
ethers.utils.formatBytes32String(e2eId),
sig.r,
sig.s,
sig.v
);
release.wait();
// await updateLockReleasedEvents();
// await updateValidDeposits();
return release;
};
export { cancelDeposit, withdrawDeposit, addLock, releaseLock };

15
src/blockchain/sellerMethods.ts
View File

@@ -3,7 +3,7 @@ import { updateWalletStatus } from "./wallet";
import { getTokenAddress, getP2PixAddress } from "./addresses";
import { parseEther } from "ethers/lib/utils";
import { BigNumber, ethers } from "ethers";
import { ethers } from "ethers";
import p2pix from "../utils/smart_contract_files/P2PIX.json";
import mockToken from "../utils/smart_contract_files/MockToken.json";
@@ -51,15 +51,4 @@ const addDeposit = async (tokenQty: string, pixKey: string) => {
// await updateValidDeposits();
};
// Map deposit
const mapDeposits = async (depositId: BigNumber): Promise<any> => {
const provider = getProvider();
const signer = provider.getSigner();
const contract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
const deposit = await contract.mapDeposits(depositId);
return deposit;
};
export { approveTokens, addDeposit, mapDeposits };
export { approveTokens, addDeposit };

74
src/blockchain/wallet.ts
View File

@@ -1,12 +1,14 @@
import { useEtherStore } from "@/store/ether";
import { getProvider } from "./provider";
import { getTokenAddress, possibleChains } from "./addresses";
import { getP2PixAddress, getTokenAddress, possibleChains } from "./addresses";
import p2pix from "../utils/smart_contract_files/P2PIX.json";
import mockToken from "../utils/smart_contract_files/MockToken.json";
import { ethers } from "ethers";
import { formatEther } from "ethers/lib/utils";
import { getValidDeposits } from "./events";
const updateWalletStatus = async () => {
const etherStore = useEtherStore();
@@ -30,4 +32,72 @@ const updateWalletStatus = async () => {
etherStore.setWalletAddress(ethers.utils.getAddress(walletAddress[0]));
};
export { updateWalletStatus };
const listValidDepositTransactionsByWalletAddress = async (
walletAddress: string
): Promise<any[]> => {
const walletDeposits = await getValidDeposits();
if (walletDeposits) {
return walletDeposits
.filter((deposit) => deposit.seller == walletAddress)
.sort((a, b) => {
return b.blockNumber - a.blockNumber;
});
}
return [];
};
const listAllTransactionByWalletAddress = async (
walletAddress: string
): Promise<any[] | undefined> => {
const provider = getProvider();
if (!provider) return;
const signer = provider.getSigner();
const p2pContract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
const filterDeposits = p2pContract.filters.DepositAdded([walletAddress]);
const eventsDeposits = await p2pContract.queryFilter(filterDeposits);
const filterAddedLocks = p2pContract.filters.LockAdded([walletAddress]);
const eventsAddedLocks = await p2pContract.queryFilter(filterAddedLocks);
const filterReleasedLocks = p2pContract.filters.LockReleased([walletAddress]);
const eventsReleasedLocks = await p2pContract.queryFilter(
filterReleasedLocks
);
return [...eventsDeposits, ...eventsAddedLocks, ...eventsReleasedLocks].sort(
(a, b) => {
return b.blockNumber - a.blockNumber;
}
);
};
// get wallet's release transactions
const listReleaseTransactionByWalletAddress = async (
walletAddress: string
): Promise<any[] | undefined> => {
const provider = getProvider();
if (!provider) return;
const signer = provider.getSigner();
const p2pContract = new ethers.Contract(getP2PixAddress(), p2pix.abi, signer);
const filterReleasedLocks = p2pContract.filters.LockReleased([walletAddress]);
const eventsReleasedLocks = await p2pContract.queryFilter(
filterReleasedLocks
);
return eventsReleasedLocks.sort((a, b) => {
return b.blockNumber - a.blockNumber;
});
};
export {
updateWalletStatus,
listValidDepositTransactionsByWalletAddress,
listAllTransactionByWalletAddress,
listReleaseTransactionByWalletAddress
};