+
+ );
+}
+
+Assets.propTypes = {
+ tokenList: PropTypes.array.isRequired,
+};
diff --git a/wallet/src/components/BridgeComponent/index.tsx b/wallet/src/components/BridgeComponent/index.tsx
new file mode 100644
index 000000000..6e242e934
--- /dev/null
+++ b/wallet/src/components/BridgeComponent/index.tsx
@@ -0,0 +1,450 @@
+import React, { useState } from 'react';
+import Modal from 'react-bootstrap/Modal';
+import Dropdown from 'react-bootstrap/Dropdown';
+import DropdownButton from 'react-bootstrap/DropdownButton';
+import { MdArrowForwardIos } from 'react-icons/md';
+import ToggleButton from 'react-bootstrap/ToggleButton';
+import ButtonGroup from 'react-bootstrap/ButtonGroup';
+import styles from '../../styles/bridge.module.scss';
+import stylesModal from '../../styles/modal.module.scss';
+import polygonChainImage from '../../assets/img/polygon-chain.svg';
+import ethChainImage from '../../assets/img/ethereum-chain.svg';
+import discloserBottomImage from '../../assets/img/discloser-bottom.svg';
+import lightArrowImage from '../../assets/img/light-arrow.svg';
+import matic from '../../assets/svg/matic.svg';
+import { approve, getContractAddress, submitTransaction } from '../../common-files/utils/contract';
+import Web3 from '../../common-files/utils/web3';
+import deposit from '../../nightfall-browser/services/deposit';
+import withdraw from '../../nightfall-browser/services/withdraw';
+import approveImg from '../../assets/img/modalImages/adeposit_approve1.png';
+import depositConfirmed from '../../assets/img/modalImages/adeposit_confirmed.png';
+import successHand from '../../assets/img/modalImages/success-hand.png';
+import transferCompletedImg from '../../assets/img/modalImages/tranferCompleted.png';
+import { pkdGet } from '../../utils/lib/local-storage';
+import { decompressKey } from '../../nightfall-browser/services/keys';
+
+const gen = require('general-number');
+
+const { generalise } = gen;
+
+const BridgeComponent = (props: any) => {
+ const [state] = useState(() => props[Object.keys(props)[1].toString()].value);
+
+ const [transferMethod, setMethod] = useState('On-Chain');
+
+ // const initialTx = location.state?.initialTxType || 'deposit';
+ // const initialTx = location.state ? location.state.initialTxType : 'deposit';
+ const initialTx = 'deposit';
+
+ const [txType, setTxType] = useState(initialTx);
+ const [tokenAmountWei, setTransferValue] = useState(0);
+ const [show, setShow] = useState(false);
+
+ const handleClose = () => setShow(false);
+ const handleShow = () => {
+ setShow(true);
+ };
+
+ const [showModalConfirm, setShowModalConfirm] = useState(false);
+ const [showModalTransferInProgress, setShowModalTransferInProgress] = useState(true);
+ const [showModalTransferEnRoute, setShowModalTransferEnRoute] = useState(false);
+ const [showModalTransferConfirmed, setShowModalTransferConfirmed] = useState(false);
+
+ function timeout(ms: number) {
+ return new Promise(resolve => setTimeout(resolve, ms));
+ }
+
+ // TODO Make this dependent on proof generation time.
+ const handleCloseConfirmModal = () => {
+ setShowModalConfirm(false);
+ setShowModalTransferInProgress(false);
+ setShowModalTransferEnRoute(false);
+ setShowModalTransferConfirmed(false);
+ };
+
+ const handleShowModalConfirm = async () => {
+ setShowModalConfirm(true);
+ setShowModalTransferInProgress(true);
+ await timeout(3000);
+ setShowModalTransferInProgress(false);
+ setShowModalTransferEnRoute(true);
+
+ await timeout(3000);
+ setShowModalTransferEnRoute(false);
+ setShowModalTransferConfirmed(true);
+ };
+
+ async function triggerTx() {
+ console.log('Tx Triggered', txType);
+ const { address: shieldContractAddress } = (await getContractAddress('Shield')).data;
+ const { address: defaultTokenAddress } = (await getContractAddress('ERC20Mock')).data; // TODO Only for testing now
+ const ercAddress = defaultTokenAddress; // TODO Location to be removed later
+ console.log('TokenAddress', ercAddress);
+ switch (txType) {
+ case 'deposit': {
+ const pkd = decompressKey(generalise(pkdGet(await Web3.getAccount())));
+ await approve(ercAddress, shieldContractAddress, 'ERC20', tokenAmountWei.toString());
+ const { rawTransaction } = await deposit(
+ {
+ ercAddress,
+ tokenId: 0,
+ value: tokenAmountWei,
+ pkd,
+ nsk: state.zkpKeys.nsk,
+ fee: 1,
+ tokenType: 'ERC20',
+ },
+ shieldContractAddress,
+ );
+ await submitTransaction(rawTransaction, shieldContractAddress, 1);
+ break;
+ }
+
+ case 'withdraw': {
+ if (transferMethod === 'Direct Transfer') {
+ await withdraw(
+ {
+ offchain: true,
+ ercAddress,
+ tokenId: 0,
+ value: tokenAmountWei,
+ recipientAddress: await Web3.getAccount(),
+ nsk: state.zkpKeys.nsk,
+ ask: state.zkpKeys.ask,
+ tokenType: 'ERC20',
+ fees: 1,
+ },
+ shieldContractAddress,
+ );
+ } else {
+ const { rawTransaction } = await withdraw(
+ {
+ ercAddress,
+ tokenId: 0,
+ value: tokenAmountWei,
+ recipientAddress: await Web3.getAccount(),
+ nsk: state.zkpKeys.nsk,
+ ask: state.zkpKeys.ask,
+ tokenType: 'ERC20',
+ fees: 1,
+ },
+ shieldContractAddress,
+ );
+ console.log('rawTransaction', rawTransaction);
+ await submitTransaction(rawTransaction, shieldContractAddress, 1);
+ break;
+ }
+ break;
+ }
+
+ default:
+ break;
+ }
+ handleCloseConfirmModal();
+ handleClose();
+ return true;
+ }
+
+ return (
+
+
+ {/*
+
+
+
+
+ Nightfall
+ ${total.toFixed(2)}
+
+
+
+
+
+
+
+
+ How it works?
+ {/*
+
+ setShow(false)}>
+
+
+
+
+
+
+ {/* TRANSFER IN PROGRESS MODAL */}
+
+
+
+ {showModalTransferInProgress && (
+
+
+ )}
+
+ {showModalTransferEnRoute && (
+
+
+ )}
+
+ {showModalTransferConfirmed && (
+
+
+ )}
+
+
+ );
+};
+
+export default BridgeComponent;
diff --git a/wallet/src/components/Header/accountDetails.jsx b/wallet/src/components/Header/accountDetails.jsx
new file mode 100644
index 000000000..0feec0320
--- /dev/null
+++ b/wallet/src/components/Header/accountDetails.jsx
@@ -0,0 +1,13 @@
+import React from 'react';
+import metamkaskLogo from '../../assets/svg/metamaskLogo.svg';
+
+import './accountDetails.scss';
+
+export default function AccountDetails() {
+ return (
+
+
+
+
+ setTxType('deposit')}
+ // onChange={e => setRadioValue(e.currentTarget.value)}
+ >
+ Deposit
+
+ setTxType('withdraw')}
+ // onChange={e => setRadioValue(e.currentTarget.value)}
+ >
+ Withdraw
+
+
+ {/*
+
+ {}}>
+ Deposit"outline-secondary"
+ {}}>
+ Withdraw
+
*/}
+
+
+ From
+
+
+
+
+
+ {txType === 'deposit' ? (
+ 
+ ) : (
+ 
+ )}
+
+
+ {txType === 'deposit' ? 'Ethereum Mainnet' : 'Polygon Nightfall L2'}
+
+
+
+
+
+
+ 
+
+
+ {/* {{ isDepositEther ? isDepositEther : selectedToken.name }} */}
+ MATIC
+
+
+ setTransferValue(parseFloat(e.target.value))}
+ />
+
+
+
+ 
+
+ To
+
+
+
+ {txType === 'withdraw' ? (
+
+ ) : (
+
+ )}
+
+
+ {txType === 'deposit' ? 'Polygon Nightfall L2' : 'Ethereum Mainnet'}
+
+
+ Balance:
+ xx MATIC
+
+
+ {/* Transfer Mode:
+ {{ selectedMode }} Bridge */}
+ Transfer Mode:
+
+ {txType.charAt(0).toUpperCase() + txType.slice(1)} Bridge
+
+
+
+
+
+ Confirm transaction
+
+
+
+ {/* d-flex justify-content-center align-self-center mx-auto */}
+
+
+ {/* Buttons */}
+
+ {/* ![Token Image]()
*/}
+ 
+ {/* {{ selectedToken.symbol[0] }} */}
+
+ {/* font-heading-large font-bold ps-t-16 ps-b-6 */}
+
+ {Number(tokenAmountWei).toFixed(2)}
+
+ {/* font-body-small */}
+ $xx.xx
+
+
+
+
+
+
+ {txType === 'deposit' ? 'Ethereum Mainnet' : 'Polygon Nightfall L2'}
+
+
+ {txType === 'deposit' ? 'Polygon Nightfall L2' : 'Ethereum Mainnet'}
+
+
+
+
+
+
+ Transfer Mode
+
+
+ setMethod('On-Chain')}>On-Chain
+ setMethod('Direct Transfer')}>
+ Direct Transfer
+
+ setMethod('Instant Withdrawal')}>
+ Instant Withdrawal
+
+
+
+
+ Transfer security is provided by the Ethereum miners.
+ {/*
+ Plasma provides advanced security with plasma exit
+ mechanism. It will take approximately */}
+
+ {' '}
+ To minimise the risk of chain reorganisations, your transfer will wait for{' '}
+
+ 12 block confirmations before being
+ finalized.
+
+
+
+
+
+
+
+ Estimation Transaction fee
+
+ ~ $x.xx
+ Transfer in progress
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+
+ Creating Transaction
+
+ Retrieving your commitments and generating transaction inputs.
+
+ {/* View on etherscan */}
+
+
+
+ 
+
+
+
+
+
+
+
+
+
+ Generating Zk Proof
+
+ Proof generation may take up to 2 mins to complete. Do not navigate away.
+
+ {/* View on etherscan */}
+
+
+
+ 
+
+
+
+ 
+
+
+
+ Transaction created sucessfully.
+Your transfer is ready to send.
+
+ {/* View on etherscan */}
+
+ 
+
+ );
+}
diff --git a/wallet/src/components/Header/accountDetails.scss b/wallet/src/components/Header/accountDetails.scss
new file mode 100644
index 000000000..098e714f8
--- /dev/null
+++ b/wallet/src/components/Header/accountDetails.scss
@@ -0,0 +1,25 @@
+@import '~/../../../assets/css/theme/theme';
+
+.accountBox {
+ margin-left: 32px;
+ display: flex;
+ align-items: center;
+ background-color: #eee;
+ border-radius: 20px;
+ padding: 10px;
+
+ &:hover {
+ cursor: pointer;
+ background-color: #ddd;
+ }
+
+ .accountAddress {
+ font-size: medium;
+ margin-right: 8px;
+ }
+
+ img {
+ width: 25px;
+ height: 25px;
+ }
+}
\ No newline at end of file
diff --git a/wallet/src/components/Header/header.jsx b/wallet/src/components/Header/header.jsx
new file mode 100644
index 000000000..b8dd8ba10
--- /dev/null
+++ b/wallet/src/components/Header/header.jsx
@@ -0,0 +1,31 @@
+import React from 'react';
+import { useMediaQuery } from 'react-responsive';
+import { CgMenu } from 'react-icons/cg';
+import Logo from './logo.jsx';
+import NavItems from './navItems.jsx';
+
+import './header.scss';
+
+export default function Header() {
+ const isSmallScreen = useMediaQuery({ query: '(max-width: 768px)' });
+
+ if (!isSmallScreen) {
+ return (
+ account
+
+
+ );
+ }
+ return (
+
+
+ );
+}
diff --git a/wallet/src/components/Header/header.scss b/wallet/src/components/Header/header.scss
new file mode 100644
index 000000000..cb3da8a0c
--- /dev/null
+++ b/wallet/src/components/Header/header.scss
@@ -0,0 +1,18 @@
+@import '~/../../../assets/css/theme/theme';
+
+.navHead {
+ display: flex;
+ flex-direction: row;
+ align-items: center;
+ justify-content: space-between;
+
+ width: 100%;
+ padding: 15px;
+
+ background-color: $light-gray-100;
+ position: sticky;
+ top: 0px;
+ z-index: 1;
+
+}
+
\ No newline at end of file
diff --git a/wallet/src/components/Header/logo.jsx b/wallet/src/components/Header/logo.jsx
new file mode 100644
index 000000000..2ff0e0cd4
--- /dev/null
+++ b/wallet/src/components/Header/logo.jsx
@@ -0,0 +1,18 @@
+import React from 'react';
+import logo from '../../assets/img/polygonLogo.png';
+
+import './logo.scss';
+
+export default function Logo() {
+ return (
+
+
+ );
+}
diff --git a/wallet/src/components/Header/logo.scss b/wallet/src/components/Header/logo.scss
new file mode 100644
index 000000000..28baff9bb
--- /dev/null
+++ b/wallet/src/components/Header/logo.scss
@@ -0,0 +1,63 @@
+@import '~/../../../assets/css/theme/theme';
+
+.container {
+ display: flex;
+ align-items: center;
+ margin: 8px 20px;
+}
+
+.boxLogo {
+ display: flex;
+ width: 35px;
+ height: 35px;
+}
+
+.logoText {
+ display: flex;
+
+ .logoTitle {
+ font-size: 30px;
+ font-weight: bold;
+ letter-spacing: normal;
+ margin-left: 8px;
+ margin-right: 8px;
+ width: 100%;
+ }
+
+ span {
+ font-size: 30px;
+ margin-left: 2px;
+ font-weight: lighter;
+ }
+}
+
+@media screen and (max-width: 900px) {
+ .container {
+ margin: 0 5px;
+ }
+
+ .boxLogo {
+ display: flex;
+ width: 25px;
+ height: 25px;
+ }
+
+ .logoText {
+ display: flex;
+
+ .logoTitle {
+ font-size: 20px;
+ font-weight: normal;
+ letter-spacing: normal;
+ margin-left: 4px;
+ margin-right: 4px;
+ width: 100%;
+ }
+
+ span {
+ font-size: 20px;
+ margin-left: 2px;
+ font-weight: lighter;
+ }
+ }
+}
\ No newline at end of file
diff --git a/wallet/src/components/Header/menuItem.jsx b/wallet/src/components/Header/menuItem.jsx
new file mode 100644
index 000000000..48b84cbd6
--- /dev/null
+++ b/wallet/src/components/Header/menuItem.jsx
@@ -0,0 +1,16 @@
+import React from 'react';
+import { CgMenuGridO } from 'react-icons/cg';
+import { useMediaQuery } from 'react-responsive';
+
+import './menuItem.scss';
+
+export default function MenuItem() {
+ const isSmallScreen = useMediaQuery({ query: '(max-width: 900px)' });
+
+ return (
+
+ 
+
+
+
+ nightfall
+ Wallet
+
+
+ );
+}
diff --git a/wallet/src/components/Header/menuItem.scss b/wallet/src/components/Header/menuItem.scss
new file mode 100644
index 000000000..5b9f3798d
--- /dev/null
+++ b/wallet/src/components/Header/menuItem.scss
@@ -0,0 +1,34 @@
+@import '~/../../../assets/css/theme/theme';
+
+.menuBox {
+ display: flex;
+ align-items: center;
+ color: $light-gray-900;
+
+ svg {
+ font-size: 36px;
+ margin-right: 4px;
+ }
+
+ p {
+ font-size: medium;
+ font-weight: normal;
+ }
+
+ &:hover {
+ cursor: pointer;
+ }
+}
+
+@media screen and (max-width: 900px) {
+ .menuBox {
+ svg {
+ font-size: 24px;
+ }
+
+ p {
+ font-size: small;
+ font-weight: normal;
+ }
+ }
+}
\ No newline at end of file
diff --git a/wallet/src/components/Header/navItems.jsx b/wallet/src/components/Header/navItems.jsx
new file mode 100644
index 000000000..8cb2732ee
--- /dev/null
+++ b/wallet/src/components/Header/navItems.jsx
@@ -0,0 +1,17 @@
+import React from 'react';
+import { useMediaQuery } from 'react-responsive';
+import MenuItem from './menuItem.jsx';
+import AccountDetails from './accountDetails.jsx';
+
+import './navItems.scss';
+
+export default function NavItems() {
+ const isSmallScreen = useMediaQuery({ query: '(max-width: 900px)' });
+
+ return (
+ Apps
} +
+
+ {!isSmallScreen &&
+ );
+}
diff --git a/wallet/src/components/Header/navItems.scss b/wallet/src/components/Header/navItems.scss
new file mode 100644
index 000000000..d1cb2ab20
--- /dev/null
+++ b/wallet/src/components/Header/navItems.scss
@@ -0,0 +1,5 @@
+.navItems {
+ display: flex;
+ justify-content: space-between;
+ margin-right: 20px;
+}
\ No newline at end of file
diff --git a/wallet/src/components/SideBar/index.jsx b/wallet/src/components/SideBar/index.jsx
new file mode 100644
index 000000000..2c30c8a21
--- /dev/null
+++ b/wallet/src/components/SideBar/index.jsx
@@ -0,0 +1,60 @@
+import React from 'react';
+
+import { GiElectric } from 'react-icons/gi';
+import { RiWallet3Line } from 'react-icons/ri';
+import { MdOutlineSupport } from 'react-icons/md';
+import { useMediaQuery } from 'react-responsive';
+import TransactionImg from '../../assets/svg/transactions-side.svg';
+import TransactionImgGrey from '../../assets/svg/transactions-side-grey.svg';
+import WalletImg from '../../assets/svg/wallet-side.svg';
+import WalletImgGrey from '../../assets/svg/wallet-side-grey.svg';
+import BridgeImg from '../../assets/svg/bridge-side.svg';
+import BridgeImgGrey from '../../assets/svg/bridge-side-grey.svg';
+import SideItem from './sideItem.jsx';
+
+import './index.scss';
+import { getContractAddress } from '../../common-files/utils/contract';
+
+export default function SideBar() {
+ const isSmallScreen = useMediaQuery({ query: '(min-width: 768px)' });
+ const [tokenAddress, setTokenAddres] = React.useState('');
+ React.useEffect(async () => {
+ const { address } = (await getContractAddress('ERC20Mock')).data; // TODO Temporary while we use ERC20 Mocks.
+ setTokenAddres(address);
+ });
+ if (isSmallScreen) {
+ return (
+
+
+ );
+ }
+ return ;
+}
diff --git a/wallet/src/components/SideBar/index.scss b/wallet/src/components/SideBar/index.scss
new file mode 100644
index 000000000..839ca7010
--- /dev/null
+++ b/wallet/src/components/SideBar/index.scss
@@ -0,0 +1,49 @@
+@import '~/../../../assets/css/theme/theme';
+
+
+a {
+ text-decoration: none;
+}
+a:hover{
+ text-decoration: none;
+}
+
+.sideBar{
+ display: flex;
+ flex-direction: column;
+ align-content: space-between;
+ justify-content: space-between;
+ min-height: calc(90vh - #{$navbar-local-height});
+
+}
+.sideItems {
+ display: flex;
+ flex-direction: column;
+ padding: 0 10px 200px;
+}
+
+.links {
+ display: flex;
+
+ align-items: center;
+ margin-top: 20px;
+ border-radius: 10px;
+ width: 250px;
+ height: 40px;
+ padding: 0 20px;
+ margin-left: 10px;
+ color: #555;
+
+ .linkText {
+ margin-left: 20px;
+ }
+
+
+ font-size: medium;
+
+ &:hover {
+ background-color: #eee;
+ cursor: pointer;
+ }
+
+}
\ No newline at end of file
diff --git a/wallet/src/components/SideBar/sideItem.jsx b/wallet/src/components/SideBar/sideItem.jsx
new file mode 100644
index 000000000..9eede2329
--- /dev/null
+++ b/wallet/src/components/SideBar/sideItem.jsx
@@ -0,0 +1,34 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import { Link } from 'react-router-dom';
+
+import './sideItem.scss';
+
+export default function SideItem({ text, link, Icon, SideState }) {
+ return (
+
+
+
+
+
+
+
+ {"What's new?"}
+
+
+ Main Wallet
+
+
+ Support
+
+ {/* 
+
+
+ );
+}
+
+SideItem.propTypes = {
+ text: PropTypes.element.isRequired,
+ link: PropTypes.element.isRequired,
+ Icon: PropTypes.element.isRequired,
+ SideState: PropTypes.element.optionalString,
+};
diff --git a/wallet/src/components/SideBar/sideItem.scss b/wallet/src/components/SideBar/sideItem.scss
new file mode 100644
index 000000000..d523d0524
--- /dev/null
+++ b/wallet/src/components/SideBar/sideItem.scss
@@ -0,0 +1,53 @@
+@import '~/../../../assets/css/theme/theme';
+
+.itemInactive {
+ display: flex;
+
+ align-items: center;
+
+ border-radius: 10px;
+ width: 250px;
+ height: 40px;
+ padding: 0 20px;
+ margin-top: 20px;
+ color: #555;
+
+ .itemText {
+ margin-left: 20px;
+ }
+
+ font-size: medium;
+
+ &:hover {
+ background-color: #eee;
+ }
+
+}
+
+.itemActive {
+ display: flex;
+
+ align-items: center;
+ background-color: #eee;
+ border-radius: 10px;
+ width: 250px;
+ height: 40px;
+ padding: 0 20px;
+ margin-top: 20px;
+ color: #555;
+
+ .itemText {
+ margin-left: 20px;
+ }
+
+ svg {
+ color: $light-primary-500;
+ }
+
+ font-size: medium;
+
+ &:hover {
+ background-color: #eee;
+ }
+
+}
\ No newline at end of file
diff --git a/wallet/src/components/TokenItem/index.jsx b/wallet/src/components/TokenItem/index.jsx
new file mode 100644
index 000000000..e39e849c1
--- /dev/null
+++ b/wallet/src/components/TokenItem/index.jsx
@@ -0,0 +1,254 @@
+import React, { useState } from 'react';
+import PropTypes from 'prop-types';
+import Modal from 'react-bootstrap/Modal';
+import { AiOutlineDown } from 'react-icons/ai';
+import { Link } from 'react-router-dom';
+import styles from '../../styles/tokenItem.module.scss';
+import stylesModal from '../../styles/modal.module.scss';
+import matic from '../../assets/svg/matic.svg';
+import usdt from '../../assets/svg/usdt.svg';
+import link from '../../assets/svg/link.svg';
+import aave from '../../assets/svg/aave.svg';
+import metamaskIcon from '../../assets/svg/metamask.svg';
+import maticImg from '../../assets/img/polygon-chain.svg';
+import { UserContext } from '../../hooks/User/index.jsx';
+import transfer from '../../nightfall-browser/services/transfer';
+import { getContractAddress } from '../../common-files/utils/contract';
+
+const symbols = {
+ matic,
+ usdt,
+ link,
+ aave,
+};
+
+export default function TokenItem({
+ maticChainUsdBalance,
+ maticChainBalance,
+ name,
+ symbol,
+ tokenAddress,
+}) {
+ const [showSendModal, setShowSendModal] = useState(false);
+ const [state] = React.useContext(UserContext);
+ const defaultSend = state?.zkpKeys?.compressedPkd;
+ const [valueToSend, setTransferValue] = useState(0);
+
+ async function sendTx() {
+ const { address: shieldContractAddress } = (await getContractAddress('Shield')).data;
+ await transfer(
+ {
+ offchain: true,
+ ercAddress: tokenAddress,
+ tokenId: 0,
+ recipientData: {
+ recipientCompressedPkds: [defaultSend],
+ values: [valueToSend],
+ },
+ nsk: state.zkpKeys.nsk,
+ ask: state.zkpKeys.ask,
+ fee: 1,
+ },
+ shieldContractAddress,
+ );
+ console.log('Transfer Complete');
+ setShowSendModal(false);
+ }
+ const tokenNameId = `TokenItem_tokenName${symbol}`;
+ const tokenBalanceId = `TokenItem_tokenBalance${symbol}`;
+ const tokenBalanceUsdId = `TokenItem_tokenBalanceUsd${symbol}`;
+ const tokenDepositId = `TokenItem_tokenDeposit${symbol}`;
+ const tokenWithdrawId = `TokenItem_tokenWithdraw${symbol}`;
+ const tokenSendId = `TokenItem_tokenSend${symbol}`;
+ return (
+
+ {text}
+
+
+ {/*
*/}
+
+ {children}
+
+ );
+};
diff --git a/wallet/src/index.jsx b/wallet/src/index.jsx
index 12344a8de..ee4c484a0 100644
--- a/wallet/src/index.jsx
+++ b/wallet/src/index.jsx
@@ -1,28 +1,20 @@
+/* eslint-disable @babel/no-unused-expressions */
import React from 'react';
import ReactDOM from 'react-dom';
-import { BrowserRouter } from 'react-router-dom';
-import { Provider } from 'react-redux';
-import configureStore from './store';
+
+import './utils/parseConfigs';
import 'bootstrap/dist/css/bootstrap.min.css';
import 'font-awesome/css/font-awesome.min.css';
import 'bootstrap-social/bootstrap-social.css';
-import 'semantic-ui-less/semantic.less';
import './index.css';
import './views/app.style.css';
+
import App from './views/app.view.jsx';
import reportWebVitals from './reportWebVitals';
-const store = configureStore();
-
ReactDOM.render(
-
-
-
-
+ ,
document.getElementById('root'),
);
diff --git a/wallet/src/nightfall-browser/classes/commitment.js b/wallet/src/nightfall-browser/classes/commitment.js
new file mode 100644
index 000000000..a6c59eaa8
--- /dev/null
+++ b/wallet/src/nightfall-browser/classes/commitment.js
@@ -0,0 +1,54 @@
+// ignore unused exports default
+
+/**
+A commitment class
+*/
+import gen from 'general-number';
+import sha256 from '../../common-files/utils/crypto/sha256';
+
+const { generalise } = gen;
+
+class Commitment {
+ preimage;
+
+ hash;
+
+ isNullified = false;
+
+ isNullifiedOnChain = -1;
+
+ constructor({ ercAddress, tokenId, value, pkd = [], compressedPkd, salt }) {
+ const items = { ercAddress, tokenId, value, pkd, compressedPkd, salt };
+ const keys = Object.keys(items);
+ for (const key of keys)
+ if (items[key] === undefined)
+ throw new Error(
+ `Property ${key} was undefined. Did you pass the wrong object to the constructor?`,
+ );
+ this.preimage = generalise({
+ ercAddress,
+ tokenId,
+ value,
+ pkd,
+ compressedPkd,
+ salt,
+ });
+ this.hash = sha256([
+ this.preimage.ercAddress,
+ this.preimage.tokenId,
+ this.preimage.value,
+ this.preimage.compressedPkd,
+ this.preimage.salt,
+ ]);
+ }
+
+ // sometimes (e.g. going over http) the general-number class is inconvenient
+ toHex() {
+ return {
+ preimage: this.preimage.all.hex(),
+ hash: this.hash.hex(),
+ };
+ }
+}
+
+export default Commitment;
diff --git a/wallet/src/nightfall-browser/classes/index.js b/wallet/src/nightfall-browser/classes/index.js
new file mode 100644
index 000000000..dfa722f9b
--- /dev/null
+++ b/wallet/src/nightfall-browser/classes/index.js
@@ -0,0 +1,8 @@
+// ignore unused exports Transaction, Commitment, Nullifier, Secrets
+import Transaction from '../../common-files/classes/transaction';
+
+import Commitment from './commitment';
+import Nullifier from './nullifier';
+import Secrets from './secrets';
+
+export { Transaction, Commitment, Nullifier, Secrets };
diff --git a/wallet/src/nightfall-browser/classes/nullifier.js b/wallet/src/nightfall-browser/classes/nullifier.js
new file mode 100644
index 000000000..12e79abaf
--- /dev/null
+++ b/wallet/src/nightfall-browser/classes/nullifier.js
@@ -0,0 +1,25 @@
+// ignore unused exports default
+
+/**
+A nullifier class
+*/
+import gen from 'general-number';
+import sha256 from '../../common-files/utils/crypto/sha256';
+
+const { generalise } = gen;
+
+class Nullifier {
+ preimage;
+
+ hash;
+
+ constructor(commitment, nsk) {
+ this.preimage = generalise({
+ nsk,
+ commitment: commitment.hash,
+ });
+ this.hash = sha256([this.preimage.nsk, this.preimage.commitment]);
+ }
+}
+
+export default Nullifier;
diff --git a/wallet/src/nightfall-browser/classes/secrets.js b/wallet/src/nightfall-browser/classes/secrets.js
new file mode 100644
index 000000000..415331f27
--- /dev/null
+++ b/wallet/src/nightfall-browser/classes/secrets.js
@@ -0,0 +1,109 @@
+// ignore unused exports default
+
+/**
+ A secrets class
+ */
+import { GN, generalise } from 'general-number';
+import rand from '../../common-files/utils/crypto/crypto-random';
+import Commitment from './commitment';
+import { enc, dec, edwardsCompress, edwardsDecompress } from '../utils/crypto/encryption/elgamal';
+import { calculatePkd } from '../services/keys';
+
+const { ZKP_KEY_LENGTH, BN128_GROUP_ORDER } = global.config;
+
+class Secrets {
+ ephemeralKeys; // random secret used in shared secret creation
+
+ cipherText;
+
+ squareRootsElligator2; // instead of calculating a square root using Tonelli Shanks algorithm which is required in Elligator 2,
+ // we pass the square root and prove that it is indeed the square root of a square number. We do this because Tonelli Shanks require
+ // modular exponentiation and we can't do dynamic exponent modular exponentiation in a circuit
+
+ compressedSecrets;
+
+ constructor(ephemeralKeys, cipherText, squareRootsElligator2) {
+ this.ephemeralKeys = generalise(ephemeralKeys);
+ this.cipherText = generalise(cipherText);
+ this.squareRootsElligator2 = generalise(squareRootsElligator2);
+ this.compressedSecrets = generalise(
+ cipherText.map(text => {
+ return edwardsCompress([text[0].bigInt, text[1].bigInt]);
+ }),
+ );
+ }
+
+ // function used to compress secrets to save gas on chain
+ static compressSecrets(secrets) {
+ return generalise(
+ secrets.cipherText.map(text => {
+ return edwardsCompress([text[0].bigInt, text[1].bigInt]);
+ }),
+ );
+ }
+
+ // function used to decompress compressed secrets
+ static decompressSecrets(secrets) {
+ return generalise(secrets).map(secret => {
+ return edwardsDecompress(secret.bigInt);
+ });
+ }
+
+ // function to encrypt secrets
+ static async encryptSecrets(messages, publicKey) {
+ let ephemeralKeys = [];
+ while (ephemeralKeys.length < 4) ephemeralKeys.push(rand(ZKP_KEY_LENGTH));
+ ephemeralKeys = (await Promise.all(ephemeralKeys)).map(key => key.bigInt);
+
+ const { cipherText, squareRootsElligator2 } = enc(ephemeralKeys, messages, publicKey);
+ const compressedSecrets = cipherText.map(text => {
+ return edwardsCompress([text[0], text[1]]);
+ });
+
+ return {
+ ephemeralKeys: generalise(ephemeralKeys),
+ cipherText: generalise(cipherText),
+ squareRootsElligator2: generalise(squareRootsElligator2),
+ compressedSecrets: generalise(compressedSecrets),
+ };
+ }
+
+ // function to decrypt secrets
+ static decryptSecrets(cipherText, privateKey, newCommitment) {
+ const tokenIdProbable = [];
+ const saltProbable = [];
+ try {
+ const decryptedMessages = dec(cipherText, privateKey);
+ const ercAddress = generalise(decryptedMessages[0]).hex(32);
+ // Since the encrypted message could be an encryption of the positive or the negative congruent form of the same number, we check which of the two
+ // satisfy commitment calculation. We do this for both token ID and salt
+ tokenIdProbable.push(decryptedMessages[1]);
+ tokenIdProbable.push((BN128_GROUP_ORDER - BigInt(decryptedMessages[1])) % BN128_GROUP_ORDER);
+ const value = decryptedMessages[2];
+ saltProbable.push(decryptedMessages[3]);
+ saltProbable.push((BN128_GROUP_ORDER - BigInt(decryptedMessages[3])) % BN128_GROUP_ORDER);
+ const { pkd, compressedPkd } = calculatePkd(new GN(privateKey));
+ let commitment = {};
+ for (let i = 0; i < tokenIdProbable.length; i++) {
+ for (let j = 0; j < saltProbable.length; j++) {
+ const commitmentProbable = new Commitment({
+ compressedPkd,
+ pkd,
+ ercAddress,
+ tokenId: tokenIdProbable[i],
+ value,
+ salt: saltProbable[j],
+ });
+ if (commitmentProbable.hash.hex(32) === newCommitment) {
+ commitment = commitmentProbable;
+ }
+ }
+ }
+ return commitment;
+ } catch (err) {
+ throw new Error('Decryption error', err);
+ }
+ }
+}
+
+export default Secrets;
diff --git a/wallet/src/nightfall-browser/event-handlers/block-proposed.js b/wallet/src/nightfall-browser/event-handlers/block-proposed.js
new file mode 100644
index 000000000..5b52f4961
--- /dev/null
+++ b/wallet/src/nightfall-browser/event-handlers/block-proposed.js
@@ -0,0 +1,96 @@
+// ignore unused exports default
+
+import logger from '../../common-files/utils/logger';
+import Timber from '../../common-files/classes/timber';
+import {
+ markNullifiedOnChain,
+ markOnChain,
+ storeCommitment,
+ countCommitments,
+ setSiblingInfo,
+ countTransactionHashes,
+} from '../services/commitment-storage';
+// import getProposeBlockCalldata from '../services/process-calldata';
+import Secrets from '../classes/secrets';
+// import { ivks, nsks } from '../services/keys';
+import { getTreeByBlockNumberL2, saveTree, saveTransaction, saveBlock } from '../services/database';
+
+const { ZERO } = global.config;
+
+/**
+This handler runs whenever a BlockProposed event is emitted by the blockchain
+*/
+async function blockProposedEventHandler(data, ivks, nsks) {
+ console.log(`Received Block Proposed event: ${JSON.stringify(data)}`);
+ // ivk will be used to decrypt secrets whilst nsk will be used to calculate nullifiers for commitments and store them
+ const { blockNumber: currentBlockCount, transactionHash: transactionHashL1 } = data;
+ // const { transactions, block } = await getProposeBlockCalldata(data);
+ const { transactions, block } = data;
+ const latestTree = await getTreeByBlockNumberL2(block.blockNumberL2 - 1);
+ const blockCommitments = transactions.map(t => t.commitments.filter(c => c !== ZERO)).flat();
+
+ if ((await countTransactionHashes(block.transactionHashes)) > 0) {
+ await saveBlock({ blockNumber: currentBlockCount, transactionHashL1, ...block });
+ await Promise.all(transactions.map(t => saveTransaction({ transactionHashL1, ...t })));
+ }
+ const dbUpdates = transactions.map(async transaction => {
+ // filter out non zero commitments and nullifiers
+ const nonZeroCommitments = transaction.commitments.flat().filter(n => n !== ZERO);
+ const nonZeroNullifiers = transaction.nullifiers.flat().filter(n => n !== ZERO);
+ const storeCommitments = [];
+ if (
+ (transaction.transactionType === '1' || transaction.transactionType === '2') &&
+ (await countCommitments(nonZeroCommitments)) === 0
+ ) {
+ ivks.forEach((key, i) => {
+ // decompress the secrets first and then we will decryp t the secrets from this
+ const decompressedSecrets = Secrets.decompressSecrets(transaction.compressedSecrets);
+ try {
+ const commitment = Secrets.decryptSecrets(
+ decompressedSecrets,
+ key,
+ nonZeroCommitments[0],
+ );
+ if (commitment === {}) logger.info("This encrypted message isn't for this recipient");
+ else {
+ storeCommitments.push(storeCommitment(commitment, nsks[i]));
+ }
+ } catch (err) {
+ logger.info(err);
+ logger.info("This encrypted message isn't for this recipient");
+ }
+ });
+ }
+ await Promise.all(storeCommitments).catch(function (err) {
+ logger.info(err);
+ }); // control errors when storing commitments in order to ensure next Promise being executed
+ return [
+ Promise.all(storeCommitments),
+ markOnChain(nonZeroCommitments, block.blockNumberL2, data.blockNumber, data.transactionHash),
+ markNullifiedOnChain(
+ nonZeroNullifiers,
+ block.blockNumberL2,
+ data.blockNumber,
+ data.transactionHash,
+ ),
+ ];
+ });
+
+ // await Promise.all(toStore);
+ await Promise.all(dbUpdates);
+ const updatedTimber = Timber.statelessUpdate(latestTree, blockCommitments);
+ await saveTree(data.blockNumber, block.blockNumberL2, updatedTimber);
+
+ await Promise.all(
+ // eslint-disable-next-line consistent-return
+ blockCommitments.map(async (c, i) => {
+ const count = await countCommitments([c]);
+ if (count > 0) {
+ const siblingPath = Timber.statelessSiblingPath(latestTree, blockCommitments, i);
+ return setSiblingInfo(c, siblingPath, latestTree.leafCount + i, updatedTimber.root);
+ }
+ }),
+ );
+}
+
+export default blockProposedEventHandler;
diff --git a/wallet/src/nightfall-browser/event-handlers/chain-reorg.js b/wallet/src/nightfall-browser/event-handlers/chain-reorg.js
new file mode 100644
index 000000000..2569fcf5b
--- /dev/null
+++ b/wallet/src/nightfall-browser/event-handlers/chain-reorg.js
@@ -0,0 +1,38 @@
+// ignore unused exports default
+
+/**
+@module chain-reorg
+@desc This module contains functions for handling updates to the layer 2 state as
+the result of a layer 1 chain reorganisation.
+*/
+
+/**
+function to update the state of a commitment following the removal of a
+BlockProposed event.
+*/
+import logger from '../../common-files/utils/logger';
+import {
+ getCommitmentsByTransactionHashL1,
+ getNullifiedByTransactionHashL1,
+ updateCommitment,
+} from '../services/commitment-storage';
+
+async function removeBlockProposedEventHandler(eventObject) {
+ logger.info('Received block proposed removal event');
+ // let's get the L1 transactionHash that created the block, we can use this
+ // to pull the commitments and nullifiers in the block from the L2 database
+ const { transactionHash } = eventObject;
+ const commitmentsAddedInBlock = await getCommitmentsByTransactionHashL1(transactionHash);
+ const commitmentsNullifiedInBlock = await getNullifiedByTransactionHashL1(transactionHash);
+ logger.debug(
+ `Found these commitments in the db ${JSON.stringify(commitmentsAddedInBlock, null, 2)}`,
+ );
+ // now we have these commitments, we need to reset their properties according to the
+ // instructions in doc/chain-reorgs.md.
+ return Promise.all([
+ ...commitmentsAddedInBlock.map(c => updateCommitment(c, { isOnChain: -1 })),
+ ...commitmentsNullifiedInBlock.map(c => updateCommitment(c, { isNullifiedOnChain: -1 })),
+ ]);
+}
+
+export default removeBlockProposedEventHandler;
diff --git a/wallet/src/nightfall-browser/event-handlers/index.js b/wallet/src/nightfall-browser/event-handlers/index.js
new file mode 100644
index 000000000..c5f5462f2
--- /dev/null
+++ b/wallet/src/nightfall-browser/event-handlers/index.js
@@ -0,0 +1,20 @@
+// ignore unused exports startEventQueue, eventHandlers
+
+import { startEventQueue } from './subscribe';
+import blockProposedEventHandler from './block-proposed';
+import rollbackEventHandler from './rollback';
+import removeBlockProposedEventHandler from './chain-reorg';
+
+const eventHandlers = {
+ BlockProposed: blockProposedEventHandler,
+ Rollback: rollbackEventHandler,
+ removers: {
+ BlockProposed: removeBlockProposedEventHandler,
+ },
+ priority: {
+ BlockProposed: 0,
+ Rollback: 0,
+ },
+};
+
+export { startEventQueue, eventHandlers };
diff --git a/wallet/src/nightfall-browser/event-handlers/rollback.js b/wallet/src/nightfall-browser/event-handlers/rollback.js
new file mode 100644
index 000000000..50bc600e4
--- /dev/null
+++ b/wallet/src/nightfall-browser/event-handlers/rollback.js
@@ -0,0 +1,52 @@
+// ignore unused exports default
+
+/**
+Each time the Shield contract removes a block from the blockHash linked-list,
+as a result of a rollback, this event gets fired. We can use it to remove the
+same blocks from our local database record and to reset cached Frontier and
+leafCount values in the Block class
+*/
+import logger from '../../common-files/utils/logger';
+import {
+ clearNullified,
+ clearOnChain,
+ deleteCommitments,
+ getCommitmentsFromBlockNumberL2,
+} from '../services/commitment-storage';
+import {
+ deleteTreeByBlockNumberL2,
+ deleteBlocksByBlockNumberL2,
+ findBlocksFromBlockNumberL2,
+ deleteTransactionsByTransactionHashes,
+} from '../services/database';
+
+async function rollbackEventHandler(data) {
+ const { blockNumberL2 } = data.returnValues;
+ logger.info(`Received Rollback event, with layer 2 block number ${blockNumberL2}`);
+
+ // We get the commitments from blockNumberL2 + 1 because the bad block itself (except
+ // the reason it is bad) contains valid transactions, we should not drop these.
+ // If we clear the commitments in blockNumberL2, we may spend them again while they are in an optimist mempool.
+ const commitments = await getCommitmentsFromBlockNumberL2(Number(blockNumberL2) + 1);
+ // Deposit transactions should not be dropped because they are always valid even post-rollback.
+ const nonDeposit = commitments.filter(t => t.transactionType !== '0').map(c => c._id);
+ logger.debug(`nonDeposit: ${JSON.stringify(nonDeposit)}`);
+ // Any commitments that have been nullified and are now no longer spent because
+ // of the rollback should be made available to be spent again.
+ const { result } = await clearNullified(Number(blockNumberL2));
+ logger.debug(`Rollback removed ${result.nModified} nullfiers`);
+ const cResult = await clearOnChain(Number(blockNumberL2));
+ logger.debug(`Rollback moved ${cResult.result.nModified} commitments off-chain`);
+
+ const blocksToDelete = await findBlocksFromBlockNumberL2(Number(blockNumberL2));
+ const txsToDelete = blocksToDelete.map(b => b.transactionHashes).flat(Infinity);
+
+ await Promise.all([
+ deleteTreeByBlockNumberL2(Number(blockNumberL2)),
+ deleteCommitments(nonDeposit),
+ deleteBlocksByBlockNumberL2(Number(blockNumberL2)),
+ deleteTransactionsByTransactionHashes(txsToDelete),
+ ]);
+}
+
+export default rollbackEventHandler;
diff --git a/wallet/src/nightfall-browser/event-handlers/subscribe.js b/wallet/src/nightfall-browser/event-handlers/subscribe.js
new file mode 100644
index 000000000..3b60bda26
--- /dev/null
+++ b/wallet/src/nightfall-browser/event-handlers/subscribe.js
@@ -0,0 +1,49 @@
+/* eslint-disable no-await-in-loop */
+
+// ignore unused exports startEventQueue
+
+/**
+ * Module to subscribe to blockchain events
+ */
+import { getContractInstance, getContractAddress } from '../../common-files/utils/contract';
+import logger from '../../common-files/utils/logger';
+
+const { STATE_CONTRACT_NAME, RETRIES } = global.config;
+
+/**
+ * Function that tries to get a (named) contract instance and, if it fails, will
+ * retry after 3 seconds. After RETRIES attempts, it will give up and throw.
+ * This is useful in case nightfall-client comes up before the contract
+ * is fully deployed.
+ */
+async function waitForContract(contractName) {
+ let errorCount = 0;
+ let error;
+ let instance;
+ while (errorCount < RETRIES) {
+ try {
+ error = undefined;
+ const address = await getContractAddress(contractName);
+ logger.debug(`${contractName} contract address is ${address}`);
+ if (address === undefined) throw new Error(`${contractName} contract address was undefined`);
+ instance = getContractInstance(contractName, address);
+ return instance;
+ } catch (err) {
+ error = err;
+ errorCount++;
+ logger.warn(`Unable to get a ${contractName} contract instance will try again in 3 seconds`);
+ await new Promise(resolve => setTimeout(() => resolve(), 3000));
+ }
+ }
+ if (error) throw error;
+ return instance;
+}
+
+// eslint-disable-next-line import/prefer-default-export
+export async function startEventQueue(callback, ...args) {
+ const emitter = (await waitForContract(STATE_CONTRACT_NAME)).events.allEvents();
+ emitter.on('data', event => callback(event, args));
+ emitter.on('changed', event => callback(event, args));
+ logger.debug('Subscribed to layer 2 state events');
+ return emitter;
+}
diff --git a/wallet/src/nightfall-browser/index.js b/wallet/src/nightfall-browser/index.js
new file mode 100644
index 000000000..3f26ca173
--- /dev/null
+++ b/wallet/src/nightfall-browser/index.js
@@ -0,0 +1,17 @@
+import logger from '../common-files/utils/logger';
+import { queueManager } from '../common-files/utils/event-queue';
+import { initialClientSync } from './services/state-sync';
+import { startEventQueue, eventHandlers } from './event-handlers/index';
+
+const main = async () => {
+ try {
+ initialClientSync().then(async () => {
+ await startEventQueue(queueManager, eventHandlers);
+ });
+ } catch (err) {
+ logger.error(err);
+ process.exit(1);
+ }
+};
+
+main();
diff --git a/wallet/src/nightfall-browser/services/commitment-storage.js b/wallet/src/nightfall-browser/services/commitment-storage.js
new file mode 100644
index 000000000..f884f1651
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/commitment-storage.js
@@ -0,0 +1,687 @@
+/* ignore unused exports */
+
+/**
+Logic for storing and retrieving commitments from a mongo DB. Abstracted from
+deposit/transfer/withdraw
+*/
+import { Mutex } from 'async-mutex';
+import gen from 'general-number';
+import { openDB } from 'idb';
+import logger from '../../common-files/utils/logger';
+import { Commitment, Nullifier } from '../classes/index';
+import { isValidWithdrawal } from './valid-withdrawal';
+import { getBlockByBlockNumberL2, getTransactionByTransactionHash } from './database';
+
+const {
+ COMMITMENTS_DB,
+ TIMBER_COLLECTION,
+ SUBMITTED_BLOCKS_COLLECTION,
+ TRANSACTIONS_COLLECTION,
+ COMMITMENTS_COLLECTION,
+} = global.config;
+
+const { generalise } = gen;
+const mutex = new Mutex();
+
+const connectDB = async () => {
+ return openDB(COMMITMENTS_DB, 1, {
+ upgrade(newDb) {
+ newDb.createObjectStore(COMMITMENTS_COLLECTION);
+ newDb.createObjectStore(TIMBER_COLLECTION);
+ newDb.createObjectStore(SUBMITTED_BLOCKS_COLLECTION);
+ newDb.createObjectStore(TRANSACTIONS_COLLECTION);
+ },
+ });
+};
+
+// function to format a commitment for a mongo db and store it
+export async function storeCommitment(commitment, nsk) {
+ const nullifierHash = new Nullifier(commitment, nsk).hash.hex(32);
+ const data = {
+ _id: commitment.hash.hex(32),
+ preimage: commitment.preimage.all.hex(32),
+ isDeposited: commitment.isDeposited || false,
+ isOnChain: Number(commitment.isOnChain) || -1,
+ isPendingNullification: false, // will not be pending when stored
+ isNullified: commitment.isNullified,
+ isNullifiedOnChain: Number(commitment.isNullifiedOnChain) || -1,
+ nullifier: nullifierHash,
+ blockNumber: -1,
+ };
+ const db = await connectDB();
+ return db.put(COMMITMENTS_COLLECTION, data, data._id);
+}
+// function to update an existing commitment
+export async function updateCommitment(commitment, updates) {
+ const db = await connectDB();
+ return db.put(COMMITMENTS_COLLECTION, updates, commitment._id);
+}
+
+// function to get count of commitments. Can also be used to check if it exists
+export async function countCommitments(commitments) {
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ const filtered = res.filter(r => commitments.includes(r._id));
+ return filtered.length;
+}
+
+// function to get count of transaction hashes. Used to decide if we should store
+// incoming blocks or transactions.
+export async function countTransactionHashes(transactionHashes) {
+ const db = await connectDB();
+ // const res = await db.getAll(COMMITMENTS_COLLECTION);
+ const txs = await db.getAll(TRANSACTIONS_COLLECTION);
+ const filtered = txs.filter(tx => transactionHashes.includes(tx.transactionHash));
+ // const filtered = res.filter(r => transactionHashes.includes(r.transactionHash));
+ return filtered.length;
+}
+
+// function to mark a commitments as on chain for a mongo db
+export async function markOnChain(
+ commitments,
+ blockNumberL2,
+ blockNumber,
+ transactionHashCommittedL1,
+) {
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ const filtered = res.filter(r => commitments.includes(r._id) && r.isOnChain === -1);
+ return Promise.all(
+ filtered.map(f => {
+ const { isOnChain, blockNumber: oldBN, transactionHashCommittedL1: oldTxHash, ...rest } = f;
+ return db.put(
+ COMMITMENTS_COLLECTION,
+ {
+ isOnChain: Number(blockNumberL2),
+ blockNumber,
+ transactionHashCommittedL1,
+ ...rest,
+ },
+ f._id,
+ );
+ }),
+ );
+}
+
+// function to mark a commitments as on chain for a mongo db
+export async function setSiblingInfo(commitment, siblingPath, leafIndex, root) {
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ const filtered = res.filter(r => r._id === commitment && r.isOnChain !== -1);
+ if (filtered.length === 1) {
+ const { siblingPath: a, leafIndex: b, root: c, ...rest } = filtered[0];
+ return db.put(
+ COMMITMENTS_COLLECTION,
+ {
+ siblingPath,
+ leafIndex,
+ root,
+ ...rest,
+ },
+ filtered[0]._id,
+ );
+ }
+ return null;
+}
+
+// function to mark a commitment as pending nullication for a mongo db
+async function markPending(commitment) {
+ const db = await connectDB();
+ const { isPendingNullification, ...rest } = await db.get(
+ COMMITMENTS_COLLECTION,
+ commitment.hash.hex(32),
+ );
+ return db.put(
+ COMMITMENTS_COLLECTION,
+ {
+ isPendingNullification: true,
+ ...rest,
+ },
+ commitment.hash.hex(32),
+ );
+}
+
+// function to mark a commitment as nullified for a mongo db
+export async function markNullified(commitment, transaction) {
+ const db = await connectDB();
+ const {
+ isPendingNullification,
+ isNullified,
+ nullifierTransactionType,
+ transactionHash,
+ ...rest
+ } = await db.get(COMMITMENTS_COLLECTION, commitment.hash.hex(32));
+ return db.put(
+ COMMITMENTS_COLLECTION,
+ {
+ isPendingNullification: false,
+ isNullified: true,
+ nullifierTransactionType: BigInt(transaction.transactionType).toString(),
+ transactionHash: transaction.transactionHash,
+ ...rest,
+ },
+ commitment.hash.hex(32),
+ );
+}
+
+// function to retrieve commitment with a specified salt
+export async function getCommitmentBySalt(salt) {
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ return res.filter(r => r.preimage.salt === generalise(salt).hex(32));
+}
+
+// function to retrieve commitments by transactionHash of the block in which they were
+// committed to
+export async function getCommitmentsByTransactionHashL1(transactionHashCommittedL1) {
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ return res.filter(r => r.transactionHashCommittedL1 === transactionHashCommittedL1);
+}
+// function to retrieve commitments by transactionhash of the block in which they were
+// nullified
+export async function getNullifiedByTransactionHashL1(transactionHashNullifiedL1) {
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ return res.filter(r => r.transactionHashNullifiedL1 === transactionHashNullifiedL1);
+}
+export async function getSiblingInfo(commitment) {
+ const db = await connectDB();
+ return db.get(COMMITMENTS_COLLECTION, commitment.hash.hex(32));
+}
+
+/*
+function to clear a commitments nullified status after a rollback.
+commitments have two stages of nullification (1) when they are spent by Client
+they are marked as isNullified==true to stop them being used in another
+transaction but also as isNullifiedOnChain when we know that they've actually
+made it into an on-chain L2 block. This contains the number of the L2 block that
+they are in. We need this if they are ever rolled back because the Rollback
+event only broadcasts the number of the block that was successfully challenged.
+Without that number, we can't tell which spends to roll back.
+Once these properties are cleared, the commitment will automatically become
+available for spending again.
+*/
+export async function clearNullified(blockNumberL2) {
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ const filtered = res.filter(r => r.isNullifiedOnChain >= Number(blockNumberL2));
+ if (filtered.length > 0) {
+ return Promise.all(
+ filtered.map(f => {
+ const { isNullifiedOnChain: a, blockNumber: b, ...rest } = f;
+ return db.put(
+ COMMITMENTS_COLLECTION,
+ {
+ isNullifiedOnChain: -1,
+ blockNumber: -1,
+ ...rest,
+ },
+ f._id,
+ );
+ }),
+ );
+ }
+ return null;
+}
+
+// as above, but removes isOnChain for deposit commitments
+export async function clearOnChain(blockNumberL2) {
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ const filtered = res.filter(r => r.isNullifiedOnChain >= Number(blockNumberL2));
+ if (filtered.length > 0) {
+ return Promise.all(
+ filtered.map(f => {
+ const { isNullifiedOnChain: a, blockNumber: b, ...rest } = f;
+ return db.put(
+ COMMITMENTS_COLLECTION,
+ {
+ isOnChain: -1,
+ blockNumber: -1,
+ ...rest,
+ },
+ f._id,
+ );
+ }),
+ );
+ }
+ return null;
+}
+
+// function to clear a commitment as pending nullication for a mongo db
+export async function clearPending(commitment) {
+ const db = await connectDB();
+ const { isPendingNullification: a, ...rest } = await db.get(
+ COMMITMENTS_COLLECTION,
+ commitment.hash.hex(32),
+ );
+ return db.put(
+ COMMITMENTS_COLLECTION,
+ {
+ isPendingNullification: false,
+ ...rest,
+ },
+ commitment.hash.hex(32),
+ );
+}
+
+// function to mark a commitments as nullified on chain for a mongo db
+export async function markNullifiedOnChain(
+ nullifiers,
+ blockNumberL2,
+ blockNumber,
+ transactionHashNullifiedL1, // the tx in which the nullification happened
+) {
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ const filtered = res.filter(r => nullifiers.includes(r.nullifier) && r.isNullifiedOnChain === -1);
+ if (filtered.length > 0) {
+ return Promise.all(
+ filtered.map(f => {
+ return db.put(
+ COMMITMENTS_COLLECTION,
+ {
+ ...f,
+ isNullifiedOnChain: Number(blockNumberL2),
+ blockNumber,
+ transactionHashNullifiedL1,
+ },
+ f._id,
+ );
+ }),
+ );
+ }
+ return null;
+}
+
+// function to get the balance of commitments for each ERC address
+export async function getWalletBalance(pkd) {
+ const db = await connectDB();
+ const vals = await db.getAll(COMMITMENTS_COLLECTION);
+ const wallet =
+ Object.keys(vals).length > 0
+ ? vals.filter(v => !v.isNullified && v.isOnChain >= 0 && v.preimage.compressedPkd === pkd)
+ : [];
+ // the below is a little complex. First we extract the ercAddress, tokenId and value
+ // from the preimage. Then we format them nicely. We don't care about the value of the
+ // tokenId, other than if it's zero or not (indicating the token type). Then we filter
+ // any commitments of zero value and tokenId (meaningless commitments), then we
+ // work out the balance contribution of each commitment - a 721 token has no value field in the
+ // commitment but each 721 token counts as a balance of 1. Then finally add up the individual
+ // commitment balances to get a balance for each erc address.
+ return wallet
+ .map(e => ({
+ ercAddress: `0x${BigInt(e.preimage.ercAddress).toString(16).padStart(40, '0')}`, // Pad this to actual address length
+ compressedPkd: e.preimage.compressedPkd,
+ tokenId: !!BigInt(e.preimage.tokenId),
+ value: Number(BigInt(e.preimage.value)),
+ }))
+ .filter(e => e.tokenId || e.value > 0) // there should be no commitments with tokenId and value of ZERO
+ .map(e => ({
+ compressedPkd: e.compressedPkd,
+ ercAddress: e.ercAddress,
+ balance: e.tokenId ? 1 : e.value,
+ }))
+ .reduce((acc, e) => {
+ if (!acc[e.compressedPkd]) acc[e.compressedPkd] = {};
+ if (!acc[e.compressedPkd][e.ercAddress]) acc[e.compressedPkd][e.ercAddress] = 0;
+ acc[e.compressedPkd][e.ercAddress] += e.balance;
+ return acc;
+ }, {});
+}
+
+// function to get the balance of pending deposits commitments for each ERC address
+export async function getWalletPendingDepositBalance() {
+ const db = await connectDB();
+ const vals = await db.getAll(COMMITMENTS_COLLECTION);
+ const wallet =
+ Object.keys(vals).length > 0
+ ? vals.filter(v => v.isDeposited && !v.isNullified && v.isOnChain === -1)
+ : [];
+ // the below is a little complex. First we extract the ercAddress, tokenId and value
+ // from the preimage. Then we format them nicely. We don't care about the value of the
+ // tokenId, other than if it's zero or not (indicating the token type). Then we filter
+ // any commitments of zero value and tokenId (meaningless commitments), then we
+ // work out the balance contribution of each commitment - a 721 token has no value field in the
+ // commitment but each 721 token counts as a balance of 1. Then finally add up the individual
+ // commitment balances to get a balance for each erc address.
+ console.log(`Wallet: ${JSON.stringify(wallet)}`);
+ return wallet
+ .map(e => ({
+ ercAddress: `0x${BigInt(e.preimage.ercAddress).toString(16).padStart(40, '0')}`, // Pad this to actual address length
+ compressedPkd: e.preimage.compressedPkd,
+ tokenId: !!BigInt(e.preimage.tokenId),
+ value: Number(BigInt(e.preimage.value)),
+ }))
+ .filter(e => e.tokenId || e.value > 0) // there should be no commitments with tokenId and value of ZERO
+ .map(e => ({
+ compressedPkd: e.compressedPkd,
+ ercAddress: e.ercAddress,
+ balance: e.tokenId ? 1 : e.value,
+ }))
+ .reduce((acc, e) => {
+ if (!acc[e.compressedPkd]) acc[e.compressedPkd] = {};
+ if (!acc[e.compressedPkd][e.ercAddress]) acc[e.compressedPkd][e.ercAddress] = 0;
+ acc[e.compressedPkd][e.ercAddress] += e.balance;
+ return acc;
+ }, {});
+}
+
+export async function getWalletPendingSpentBalance() {
+ const db = await connectDB();
+ const vals = await db.getAll(COMMITMENTS_COLLECTION);
+ const wallet =
+ Object.keys(vals).length > 0 ? vals.filter(v => v.isNullified && v.isOnChain === -1) : [];
+ // the below is a little complex. First we extract the ercAddress, tokenId and value
+ // from the preimage. Then we format them nicely. We don't care about the value of the
+ // tokenId, other than if it's zero or not (indicating the token type). Then we filter
+ // any commitments of zero value and tokenId (meaningless commitments), then we
+ // work out the balance contribution of each commitment - a 721 token has no value field in the
+ // commitment but each 721 token counts as a balance of 1. Then finally add up the individual
+ // commitment balances to get a balance for each erc address.
+ return wallet
+ .map(e => ({
+ ercAddress: `0x${BigInt(e.preimage.ercAddress).toString(16).padStart(40, '0')}`, // Pad this to actual address length
+ compressedPkd: e.preimage.compressedPkd,
+ tokenId: !!BigInt(e.preimage.tokenId),
+ value: Number(BigInt(e.preimage.value)),
+ }))
+ .filter(e => e.tokenId || e.value > 0) // there should be no commitments with tokenId and value of ZERO
+ .map(e => ({
+ compressedPkd: e.compressedPkd,
+ ercAddress: e.ercAddress,
+ balance: e.tokenId ? 1 : e.value,
+ }))
+ .reduce((acc, e) => {
+ if (!acc[e.compressedPkd]) acc[e.compressedPkd] = {};
+ if (!acc[e.compressedPkd][e.ercAddress]) acc[e.compressedPkd][e.ercAddress] = 0;
+ acc[e.compressedPkd][e.ercAddress] += e.balance;
+ return acc;
+ }, {});
+}
+
+// function to get the balance of commitments for each ERC address
+export async function getWalletBalanceDetails(compressedPkd, ercList) {
+ let ercAddressList = ercList || [];
+ ercAddressList = ercAddressList.map(e => e.toUpperCase());
+ const db = await connectDB();
+ const vals = await db.getAll(COMMITMENTS_COLLECTION);
+ const wallet =
+ Object.keys(vals).length > 0 ? vals.filter(v => !v.isNullified && v.isOnChain >= 0) : [];
+
+ // the below is a little complex. First we extract the ercAddress, tokenId and value
+ // from the preimage. Then we format them nicely. We don't care about the value of the
+ // tokenId, other than if it's zero or not (indicating the token type). Then we filter
+ // any commitments of zero value and tokenId (meaningless commitments), then we
+ // work out the balance contribution of each commitment - a 721 token has no value field in the
+ // commitment but each 721 token counts as a balance of 1. Then finally add up the individual
+ // commitment balances to get a balance for each erc address.
+ const res1 = wallet.map(e => ({
+ ercAddress: `0x${BigInt(e.preimage.ercAddress).toString(16).padStart(40, '0')}`, // Pad this to actual address length
+ compressedPkd: e.preimage.compressedPkd,
+ tokenId: !!BigInt(e.preimage.tokenId),
+ value: Number(BigInt(e.preimage.value)),
+ id: Number(BigInt(e.preimage.tokenId)),
+ }));
+ const res2 = res1.filter(
+ e =>
+ (e.tokenId || e.value > 0) &&
+ e.compressedPkd === compressedPkd &&
+ (ercAddressList.length === 0 || ercAddressList.includes(e.ercAddress.toUpperCase())),
+ );
+ console.log('RES2: ', res2);
+ const res = wallet
+ .map(e => ({
+ ercAddress: `0x${BigInt(e.preimage.ercAddress).toString(16).padStart(40, '0')}`, // Pad this to actual address length
+ compressedPkd: e.preimage.compressedPkd,
+ tokenId: !!BigInt(e.preimage.tokenId),
+ value: Number(BigInt(e.preimage.value)),
+ id: Number(BigInt(e.preimage.tokenId)),
+ }))
+ .filter(
+ e =>
+ (e.tokenId || e.value > 0) &&
+ e.compressedPkd === compressedPkd &&
+ (ercAddressList.length === 0 || ercAddressList.includes(e.ercAddress.toUpperCase())),
+ ) // there should be no commitments with tokenId and value of ZERO
+ .map(e => ({
+ compressedPkd: e.compressedPkd,
+ ercAddress: e.ercAddress,
+ balance: e.tokenId ? 1 : e.value,
+ tokenId: e.id,
+ }))
+ .reduce((acc, e) => {
+ if (!acc[e.compressedPkd]) acc[e.compressedPkd] = {};
+ if (!acc[e.compressedPkd][e.ercAddress]) acc[e.compressedPkd][e.ercAddress] = [];
+ if (e.tokenId === 0 && acc[e.compressedPkd][e.ercAddress].length > 0) {
+ acc[e.compressedPkd][e.ercAddress][0].balance += e.balance;
+ } else {
+ acc[e.compressedPkd][e.ercAddress].push({ balance: e.balance, tokenId: e.tokenId });
+ }
+ return acc;
+ }, {});
+
+ return res;
+}
+
+// function to get the commitments for each ERC address of a pkd
+export async function getWalletCommitments() {
+ const db = await connectDB();
+ const vals = await db.getAll(COMMITMENTS_COLLECTION);
+ const wallet =
+ Object.keys(vals).length > 0 ? vals.filter(v => !v.isNullified && v.isOnChain >= 0) : [];
+ // the below is a little complex. First we extract the ercAddress, tokenId and value
+ // from the preimage. Then we format them nicely. We don't care about the value of the
+ // tokenId, other than if it's zero or not (indicating the token type). Then we filter
+ // any commitments of zero value and tokenId (meaningless commitments), then we
+ // work out the balance contribution of each commitment - a 721 token has no value field in the
+ // commitment but each 721 token counts as a balance of 1. Then finally add up the individual
+ // commitment balances to get a balance for each erc address.
+ return wallet
+ .map(e => ({
+ ercAddress: `0x${BigInt(e.preimage.ercAddress).toString(16).padStart(40, '0')}`,
+ compressedPkd: e.preimage.compressedPkd,
+ tokenId: !!BigInt(e.preimage.tokenId),
+ value: Number(BigInt(e.preimage.value)),
+ }))
+ .filter(e => e.tokenId || e.value > 0) // there should be no commitments with tokenId and value of ZERO
+ .map(e => ({
+ compressedPkd: e.compressedPkd,
+ ercAddress: e.ercAddress,
+ balance: e.tokenId ? 1 : e.value,
+ }))
+ .reduce((acc, e) => {
+ if (!acc[e.compressedPkd]) acc[e.compressedPkd] = {};
+ if (!acc[e.compressedPkd][e.ercAddress]) acc[e.compressedPkd][e.ercAddress] = [];
+ acc[e.compressedPkd][e.ercAddress].push(e);
+ return acc;
+ }, {});
+}
+
+// function to get the withdraw commitments for each ERC address of a pkd
+export async function getWithdrawCommitments() {
+ const db = await connectDB();
+ const vals = await db.getAll(COMMITMENTS_COLLECTION);
+ const withdraws =
+ Object.keys(vals).length > 0
+ ? vals.filter(v => v.isNullified && v.isOnChain >= 0 && v.nullifierTransactionType === '3')
+ : [];
+
+ // To check validity we need the withdrawal transaction, the block the transaction is in and all other
+ // transactions in the block. We need this for on-chain validity checks.
+ const blockTxs = await Promise.all(
+ withdraws.map(async w => {
+ const block = await getBlockByBlockNumberL2(w.isNullifiedOnChain);
+ const transactions = await Promise.all(
+ block.transactionHashes.map(t => getTransactionByTransactionHash(t)),
+ );
+ const index = block.transactionHashes.findIndex(t => t === w.transactionHash);
+ return {
+ block,
+ transactions,
+ index,
+ compressedPkd: w.preimage.compressedPkd,
+ ercAddress: `0x${BigInt(w.preimage.ercAddress).toString(16).padStart(40, '0')}`, // Pad this to be a correct address length
+ balance: w.preimage.tokenId ? 1 : w.preimage.value,
+ };
+ }),
+ );
+
+ // Run the validity check for each of the potential withdraws we have.
+ const withdrawsDetailsValid = await Promise.all(
+ blockTxs.map(async wt => {
+ const { block, transactions, index } = wt;
+ const valid = await isValidWithdrawal({ block, transactions, index });
+ return {
+ compressedPkd: wt.compressedPkd,
+ ercAddress: wt.ercAddress,
+ balance: wt.balance,
+ valid,
+ };
+ }),
+ );
+
+ return withdrawsDetailsValid.reduce((acc, e) => {
+ if (!acc[e.compressedPkd]) acc[e.compressedPkd] = {};
+ if (!acc[e.compressedPkd][e.ercAddress]) acc[e.compressedPkd][e.ercAddress] = [];
+ acc[e.compressedPkd][e.ercAddress].push(e);
+ return acc;
+ }, {});
+}
+
+// as above, but removes output commitments
+export async function deleteCommitments(commitments) {
+ const db = await connectDB();
+ const vals = await db.getAll(COMMITMENTS_COLLECTION);
+ const f = vals.filter(v => commitments.includes(v._id) && v.isOnChain === -1);
+ return Promise.all(f.map(deleteC => db.delete(COMMITMENTS_COLLECTION, deleteC._id)));
+}
+
+export async function getCommitmentsFromBlockNumberL2(blockNumberL2) {
+ const db = await connectDB();
+ const vals = await db.getAll(COMMITMENTS_COLLECTION);
+ const f = vals.filter(v => v.isOnChain >= blockNumberL2);
+ return f;
+}
+
+// function to find commitments that can be used in the proposed transfer
+// We want to make sure that only one process runs this at a time, otherwise
+// two processes may pick the same commitment. Thus we'll use a mutex lock and
+// also mark any found commitments as nullified (TODO mark them as un-nullified
+// if the transaction errors). The mutex lock is in the function
+// findUsableCommitmentsMutex, which calls this function.
+async function findUsableCommitments(compressedPkd, ercAddress, tokenId, _value, onlyOne) {
+ const value = generalise(_value); // sometimes this is sent as a BigInt.
+ // eslint-disable-next-line no-undef
+ const db = await connectDB();
+ const res = await db.getAll(COMMITMENTS_COLLECTION);
+ const commitmentArray = res.filter(
+ r =>
+ r.preimage.compressedPkd === compressedPkd.hex(32) &&
+ r.preimage.ercAddress === ercAddress.hex(32) &&
+ r.preimage.tokenId === tokenId.hex(32) &&
+ !r.isNullified &&
+ !r.isPendingNullification,
+ );
+
+ if (commitmentArray === []) return null;
+ // turn the commitments into real commitment objects
+ const commitments = commitmentArray
+ .filter(commitment => Number(commitment.isOnChain) > Number(-1)) // filters for on chain commitments
+ .map(ct => new Commitment(ct.preimage));
+ // if we have an exact match, we can do a single-commitment transfer.
+ console.log(`Looking for ${value.hex(32)}`);
+ const [singleCommitment] = commitments.filter(c => {
+ console.log(`COmmitment: ${c.preimage.value.hex(32)}`);
+ return c.preimage.value.hex(32) === value.hex(32);
+ });
+ if (singleCommitment) {
+ logger.info('Found commitment suitable for single transfer or withdraw');
+ await markPending(singleCommitment);
+ return [singleCommitment];
+ }
+ // If we get here it means that we have not been able to find a single commitment that matches the required value
+ if (onlyOne) return null; // sometimes we require just one commitment
+
+ /* if not, maybe we can do a two-commitment transfer. The current strategy aims to prioritise smaller commitments while also
+ minimising the creation of low value commitments (dust)
+
+ 1) Sort all commitments by value
+ 2) Split commitments into two sets based of if their values are less than or greater than the target value. LT & GT respectively.
+ 3) If the sum of the two largest values in set LT is LESS than the target value:
+ i) We cannot arrive at the target value with two elements in this set.
+ ii) Our two selected commitments will be the smallest commitment in LT and in smallest commitment in GT.
+ iii) It is guaranteed that the output (change) commitments will be larger than the input commitment from LT.
+
+ 5) If the sum of the two largest values in set LT is GREATER than the target value:
+ i) We use a standard inward search whereby we begin with a pointer, lhs & rhs at the start and end of the LT.
+ ii) We also track the change difference, this is the change in size of the smallest commitment in this set resulting from this transaction's output.
+ iii) If the sum of the commitments at the pointers is greater than the target value, we move pointer rhs to the left.
+ iv) Otherwise, we move pointer lhs to the right.
+ v) The selected commitments are the pair that minimise the change difference. The best case in this scenario is a change difference of -1.
+ */
+
+ // sorting will help with making the search easier
+ const sortedCommits = commitments.sort((a, b) =>
+ Number(a.preimage.value.bigInt - b.preimage.value.bigInt),
+ );
+
+ // get all commitments less than the target value
+ const commitsLessThanTargetValue = sortedCommits.filter(
+ s => s.preimage.value.bigInt < value.bigInt,
+ );
+ // get the sum of the greatest two values in this set
+ const twoGreatestSum = commitsLessThanTargetValue
+ .slice(commitsLessThanTargetValue.length - 2)
+ .reduce((acc, curr) => acc + curr.preimage.value.bigInt, 0n);
+ // If the sum of the two greatest values that are less than the target value is STILL less than the target value
+ // then we will need to use a commitment of greater value than the target
+ if (twoGreatestSum < value.bigInt) {
+ if (commitsLessThanTargetValue.length === sortedCommits.length) return null; // We don't have any more commitments
+ return [sortedCommits[commitsLessThanTargetValue.length], sortedCommits[0]]; // This should guarantee that we will replace our smallest commitment with a greater valued one.
+ }
+
+ // If we are here than we can use our commitments less than the target value to sum to greater than the target value
+ let lhs = 0;
+ let rhs = commitsLessThanTargetValue.length - 1;
+ let changeDiff = -Infinity;
+ let commitmentsToUse = null;
+ while (lhs < rhs) {
+ const tempSum =
+ commitsLessThanTargetValue[lhs].preimage.value.bigInt +
+ commitsLessThanTargetValue[rhs].preimage.value.bigInt;
+ // Work out what the change to the value smallest commit we used is
+ // This value will always be negative,
+ // this is equivalent to tempSum - value.bigInt - commitsLessThanTargetValue[lhs].preimage.value.bigInt
+ const tempChangeDiff = commitsLessThanTargetValue[rhs].preimage.value.bigInt - value.bigInt;
+ if (tempSum > value.bigInt) {
+ if (tempChangeDiff > changeDiff) {
+ // We have a set of commitments that has a lower negative change in our outputs.
+ changeDiff = tempChangeDiff;
+ commitmentsToUse = [commitsLessThanTargetValue[lhs], commitsLessThanTargetValue[rhs]];
+ }
+ rhs--;
+ } else lhs++;
+ }
+ if (commitmentsToUse) {
+ logger.info(
+ `Found commitments suitable for two-token transfer: ${JSON.stringify(commitmentsToUse)}`,
+ );
+ }
+ await Promise.all(commitmentsToUse.map(commitment => markPending(commitment)));
+ return commitmentsToUse;
+}
+
+// mutex for the above function to ensure it only runs with a concurrency of one
+export async function findUsableCommitmentsMutex(
+ compressedPkd,
+ ercAddress,
+ tokenId,
+ _value,
+ onlyOne,
+) {
+ return mutex.runExclusive(async () =>
+ findUsableCommitments(compressedPkd, ercAddress, tokenId, _value, onlyOne),
+ );
+}
diff --git a/wallet/src/nightfall-browser/services/database.js b/wallet/src/nightfall-browser/services/database.js
new file mode 100644
index 000000000..1896c8d93
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/database.js
@@ -0,0 +1,220 @@
+/* ignore unused exports */
+
+/**
+Functions for interacting with the local client data stores
+// TODO move functionality from commitment-storage.
+*/
+import { openDB } from 'idb';
+import Timber from '../../common-files/classes/timber';
+
+const {
+ COMMITMENTS_DB,
+ TIMBER_COLLECTION,
+ SUBMITTED_BLOCKS_COLLECTION,
+ TRANSACTIONS_COLLECTION,
+ COMMITMENTS_COLLECTION,
+} = global.config;
+
+// This needs to have better indexDB performance.
+
+const connectDB = async () => {
+ return openDB(COMMITMENTS_DB, 1, {
+ upgrade(newDb) {
+ newDb.createObjectStore(COMMITMENTS_COLLECTION);
+ newDb.createObjectStore(TIMBER_COLLECTION);
+ newDb.createObjectStore(SUBMITTED_BLOCKS_COLLECTION);
+ newDb.createObjectStore(TRANSACTIONS_COLLECTION);
+ },
+ });
+};
+
+/**
+Timber functions
+*/
+
+export async function saveTree(blockNumber, blockNumberL2, timber) {
+ const db = await connectDB();
+ return db.put(
+ TIMBER_COLLECTION,
+ {
+ _id: blockNumber,
+ blockNumberL2,
+ frontier: timber.frontier,
+ leafCount: timber.leafCount,
+ root: timber.root,
+ },
+ blockNumberL2,
+ );
+}
+
+export async function getLatestTree() {
+ const db = await connectDB();
+ const keys = await db.getAllKeys(TIMBER_COLLECTION);
+ const maxKey = Math.max(...keys);
+ const timberObjArr = await db.get(TIMBER_COLLECTION, maxKey);
+
+ const timberObj = timberObjArr || { root: 0, frontier: [], leafCount: 0 };
+ const t = new Timber(timberObj.root, timberObj.frontier, timberObj.leafCount);
+ return t;
+}
+
+export async function getTreeByRoot(treeRoot) {
+ const db = await connectDB();
+ const vals = await db.getAll(TIMBER_COLLECTION);
+ const { root, frontier, leafCount } = vals.filter(v => v.root === treeRoot);
+ if (!root) return new Timber(0, [], 0);
+ const t = new Timber(root, frontier, leafCount);
+ return t;
+}
+
+export async function getTreeByBlockNumberL2(blockNumberL2) {
+ const db = await connectDB();
+ if (blockNumberL2 < 0) return new Timber(0, [], 0);
+ try {
+ const { root, frontier, leafCount } = await db.get(TIMBER_COLLECTION, blockNumberL2);
+ const t = new Timber(root, frontier, leafCount);
+ return t;
+ } catch (error) {
+ throw Error('Tree not Found');
+ // TODO Should handle this throw
+ }
+}
+
+export async function deleteTreeByBlockNumberL2(blockNumberL2) {
+ const db = await connectDB();
+ return db.delete(TIMBER_COLLECTION, blockNumberL2);
+}
+
+/**
+Blocks Collection
+*/
+
+/**
+function to save a block, so that we can later search the block, for example to
+find which block a transaction went into. Note, we'll save all blocks, that get
+posted to the blockchain, not just ours.
+*/
+export async function saveBlock(_block) {
+ const block = { _id: _block.blockNumberL2, ..._block };
+ if (!block.transactionHashL1)
+ throw new Error('Layer 2 blocks must be saved with a valid Layer 1 transactionHash');
+ if (!block.blockNumber)
+ throw new Error('Layer 2 blocks must be saved with a valid Layer 1 block number');
+ const db = await connectDB();
+ const existing = await db.get(SUBMITTED_BLOCKS_COLLECTION, block._id);
+ // there are three possibilities here:
+ // 1) We're just saving a block for the first time. This is fine
+ // 2) We're trying to save a replayed block. This will correctly fail because the _id will be duplicated
+ // 3) We're trying to save a block that we've seen before but it was re-mined due to a chain reorg. In
+ // this case, it's fine, we just update the layer 1 blocknumber and transactionHash to the new values
+ if (!existing || !existing.blockNumber) {
+ return db.put(SUBMITTED_BLOCKS_COLLECTION, block, block._id);
+ }
+ throw new Error('Attempted to replay existing layer 2 block');
+}
+
+/**
+function to get a block by blockNumberL2, if you know the number of the block. This is useful for rolling back Timber.
+*/
+export async function getBlockByBlockNumberL2(blockNumberL2) {
+ const db = await connectDB();
+ return db.get(SUBMITTED_BLOCKS_COLLECTION, blockNumberL2);
+}
+
+/**
+function to delete a block. This is useful after a rollback event, whereby the
+block no longer exists
+*/
+export async function deleteBlocksByBlockNumberL2(blockNumberL2) {
+ const db = await connectDB();
+ const res = await db.getAll(SUBMITTED_BLOCKS_COLLECTION);
+ const toDelete = res.filter(r => r.blockNumberL2 >= blockNumberL2);
+ return Promise.all(toDelete.map(d => db.delete(SUBMITTED_BLOCKS_COLLECTION, d._id)));
+}
+
+/**
+function to find blocks with a layer 2 blockNumber >= blockNumberL2
+*/
+export async function findBlocksFromBlockNumberL2(blockNumberL2) {
+ const db = await connectDB();
+ const res = await db.getAll(SUBMITTED_BLOCKS_COLLECTION);
+ return res.filter(r => r.blockNumberL2 >= blockNumberL2);
+}
+
+export async function getBlockByTransactionHash(transactionHash) {
+ const db = await connectDB();
+ const res = await db.getAll(SUBMITTED_BLOCKS_COLLECTION);
+ return res.filter(r => r.transactionHashes.include(transactionHash));
+}
+
+export async function getMaxBlock() {
+ const db = await connectDB();
+ const timbers = await db.getAll(TIMBER_COLLECTION);
+ if (timbers.length === 0) return -1;
+ const keys = timbers.map(t => t.blockNumberL2);
+ const maxKey = Math.max(...keys);
+ return maxKey;
+ // return db.get(SUBMITTED_BLOCKS_COLLECTION, maxKey);
+}
+
+/**
+Transaction Collection
+*/
+
+/**
+Function to save a (unprocessed) Transaction
+*/
+export async function saveTransaction(_transaction) {
+ const transaction = {
+ _id: _transaction.transactionHash,
+ ..._transaction,
+ };
+ // there are three possibilities here:
+ // 1) We're just saving a transaction for the first time. This is fine
+ // 2) We're trying to save a replayed transaction. This will correctly fail because the _id will be duplicated
+ // 3) We're trying to save a transaction that we've seen before but it was re-mined due to a chain reorg. In
+ // this case, it's fine, we just update the layer 1 blocknumber and transactionHash to the new values
+ const db = await connectDB();
+ const query = await db.getAll(TRANSACTIONS_COLLECTION);
+ const existing = query.filter(q => q.transactionHash === transaction.transactionHash);
+ transaction.createdTime = Date.now(); // TODO REMOVE THIS ONCE WE HAVE A BETTER SOLUTION.
+ if (!existing) return db.put(TRANSACTIONS_COLLECTION, transaction, transaction._id);
+ if (!existing.blockNumber) {
+ return db.put(TRANSACTIONS_COLLECTION, transaction, transaction._id);
+ }
+ throw new Error('Attempted to replay existing transaction');
+}
+
+/*
+For added safety we only delete mempool: true, we should never be deleting
+transactions from our local db that have been spent.
+*/
+export async function deleteTransactionsByTransactionHashes(transactionHashes) {
+ const db = await connectDB();
+ const res = await db.getAll(TRANSACTIONS_COLLECTION);
+ const toDelete = transactionHashes.map(t => res.findIndex(r => t === r.transactionHash));
+ return Promise.all(toDelete.map(i => db.delete(TRANSACTIONS_COLLECTION, res[i]._id)));
+}
+
+export async function getTransactionByCommitment(commitmentHash) {
+ const db = await connectDB();
+ const res = await db.getAll(TRANSACTIONS_COLLECTION);
+ return res.filter(r => r.commitments.include(commitmentHash));
+}
+
+export async function getTransactionByNullifier(nullifierHash) {
+ const db = await connectDB();
+ const res = await db.getAll(TRANSACTIONS_COLLECTION);
+ return res.filter(r => r.nullifiers.include(nullifierHash));
+}
+export async function getTransactionByTransactionHash(transactionHash) {
+ const db = await connectDB();
+ return db.get(TRANSACTIONS_COLLECTION, transactionHash);
+}
+
+export async function getAllTransactions() {
+ const db = await connectDB();
+ const res = await db.getAll(TRANSACTIONS_COLLECTION);
+ if (Object.keys(res).length > 0) return res;
+ return [];
+}
diff --git a/wallet/src/nightfall-browser/services/deposit.js b/wallet/src/nightfall-browser/services/deposit.js
new file mode 100644
index 000000000..d8d0c3070
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/deposit.js
@@ -0,0 +1,120 @@
+// ignore unused exports default
+
+/**
+ This module contains the logic needed create a zkp deposit, i.e. to pay
+ a token to the Shield contract and have it create a zkp commitment for the
+ same value. It is agnostic to whether we are dealing with an ERC20 or ERC721
+ (or ERC1155).
+ * @module deposit
+ * @author westlad, Chaitanya-Konda, iAmMichaelConnor, will-kim
+ */
+
+import gen from 'general-number';
+import { initialize } from 'zokrates-js';
+
+import rand from '../../common-files/utils/crypto/crypto-random';
+import { getContractInstance } from '../../common-files/utils/contract';
+import logger from '../../common-files/utils/logger';
+// import { generateProof, computeWitness } from 'zokrates-js';
+import { Commitment, Transaction } from '../classes/index';
+import { storeCommitment } from './commitment-storage';
+import { compressPublicKey } from './keys';
+
+// eslint-disable-next-line
+import abi from '../../zokrates/deposit_stub/artifacts/deposit_stub-abi.json';
+// eslint-disable-next-line
+import programFile from '../../zokrates/deposit_stub/artifacts/deposit_stub-program';
+// eslint-disable-next-line
+import pkFile from '../../zokrates/deposit_stub/keypair/deposit_stub_pk.key';
+import { parseData, mergeUint8Array } from '../../utils/lib/file-reader-utils';
+import { saveTransaction } from './database';
+
+const { ZKP_KEY_LENGTH, SHIELD_CONTRACT_NAME, BN128_GROUP_ORDER } = global.config;
+const { generalise } = gen;
+
+async function deposit(items, shieldContractAddress) {
+ logger.info('Creating a deposit transaction');
+ // before we do anything else, long hex strings should be generalised to make
+ // subsequent manipulations easier
+ const { ercAddress, tokenId, value, pkd, nsk, fee } = generalise(items);
+ const compressedPkd = compressPublicKey(pkd);
+
+ let commitment;
+ let salt;
+ do {
+ // we also need a salt to make the commitment unique and increase its entropy
+ // eslint-disable-next-line
+ salt = await rand(ZKP_KEY_LENGTH);
+ // next, let's compute the zkp commitment we're going to store and the hash of the public inputs (truncated to 248 bits)
+ commitment = new Commitment({ ercAddress, tokenId, value, compressedPkd, salt });
+ } while (commitment.hash.bigInt > BN128_GROUP_ORDER);
+
+ logger.debug(`Hash of new commitment is ${commitment.hash.hex()}`);
+ // now we can compute a Witness so that we can generate the proof
+ const witnessInput = [
+ ercAddress.integer,
+ tokenId.integer,
+ value.integer,
+ compressedPkd.limbs(32, 8),
+ salt.limbs(32, 8),
+ commitment.hash.integer,
+ ];
+ logger.debug(`witness input is ${witnessInput.join(' ')}`);
+ // call a zokrates worker to generate the proof
+ // let folderpath = 'deposit';
+ // eslint-disable-next-line no-unused-vars
+ // if (USE_STUBS) folderpath = `${folderpath}_stub`;
+
+ const zokratesProvider = await initialize();
+ const program = await fetch(programFile)
+ .then(response => response.body.getReader())
+ .then(parseData)
+ .then(mergeUint8Array);
+ const pk = await fetch(pkFile)
+ .then(response => response.body.getReader())
+ .then(parseData)
+ .then(mergeUint8Array);
+
+ const artifacts = { program: new Uint8Array(program), abi };
+ const keypair = { pk: new Uint8Array(pk) };
+
+ // computation
+ const { witness } = zokratesProvider.computeWitness(artifacts, witnessInput);
+ // generate proof
+ const { proof } = zokratesProvider.generateProof(artifacts.program, witness, keypair.pk);
+ const shieldContractInstance = await getContractInstance(
+ SHIELD_CONTRACT_NAME,
+ shieldContractAddress,
+ );
+
+ // next we need to compute the optimistic Transaction object
+ const optimisticDepositTransaction = new Transaction({
+ fee,
+ transactionType: 0,
+ tokenType: items.tokenType,
+ tokenId,
+ value,
+ ercAddress,
+ commitments: [commitment],
+ proof,
+ });
+ logger.silly(
+ `Optimistic deposit transaction ${JSON.stringify(optimisticDepositTransaction, null, 2)}`,
+ );
+ // and then we can create an unsigned blockchain transaction
+ try {
+ const rawTransaction = await shieldContractInstance.methods
+ .submitTransaction(Transaction.buildSolidityStruct(optimisticDepositTransaction))
+ .encodeABI();
+
+ // store the commitment on successful computation of the transaction
+ commitment.isDeposited = true;
+ await storeCommitment(commitment, nsk);
+ await saveTransaction(optimisticDepositTransaction);
+ return { rawTransaction, transaction: optimisticDepositTransaction };
+ } catch (err) {
+ throw new Error(err); // let the caller handle the error
+ }
+}
+
+export default deposit;
diff --git a/wallet/src/nightfall-browser/services/finalise-withdrawal.js b/wallet/src/nightfall-browser/services/finalise-withdrawal.js
new file mode 100644
index 000000000..b5171c7c1
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/finalise-withdrawal.js
@@ -0,0 +1,51 @@
+/* ignore unused exports */
+
+/**
+Module to endable withdrawal of funds from the Shield contract to the user's
+address.
+*/
+import { getContractInstance } from '../../common-files/utils/contract';
+import { Transaction } from '../classes/index';
+import { getTransactionByTransactionHash, getBlockByTransactionHash } from './database';
+
+const { SHIELD_CONTRACT_NAME } = global.config;
+
+// TODO move classes to their own folder so this is not needed (it's already a
+// static function in the Block class)
+export function buildSolidityStruct(block) {
+ const { proposer, root, leafCount, blockNumberL2, previousBlockHash } = block;
+ return {
+ proposer,
+ root,
+ leafCount: Number(leafCount),
+ blockNumberL2: Number(blockNumberL2),
+ previousBlockHash,
+ };
+}
+
+export async function finaliseWithdrawal({ transactionHash }, shieldContractAddress) {
+ const block = await getBlockByTransactionHash(transactionHash);
+ const transactions = await Promise.all(
+ block.transactionHashes.map(t => getTransactionByTransactionHash(t)),
+ );
+ const index = transactions.findIndex(f => f.transactionHash === transactionHash);
+
+ const shieldContractInstance = await getContractInstance(
+ SHIELD_CONTRACT_NAME,
+ shieldContractAddress,
+ );
+ try {
+ const rawTransaction = await shieldContractInstance.methods
+ .finaliseWithdrawal(
+ buildSolidityStruct(block),
+ block.blockNumberL2,
+ transactions.map(t => Transaction.buildSolidityStruct(t)),
+ index,
+ )
+ .encodeABI();
+ // store the commitment on successful computation of the transaction
+ return { rawTransaction };
+ } catch (err) {
+ throw new Error(err); // let the caller handle the error
+ }
+}
diff --git a/wallet/src/nightfall-browser/services/instant-withdrawal.js b/wallet/src/nightfall-browser/services/instant-withdrawal.js
new file mode 100644
index 000000000..e7d6bd442
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/instant-withdrawal.js
@@ -0,0 +1,37 @@
+/* ignore unused exports */
+
+/**
+ * This module enables setting instant withdrawals fees
+ */
+import { getContractInstance } from '../../common-files/utils/contract';
+import { Transaction } from '../classes/index';
+import { buildSolidityStruct } from './finalise-withdrawal';
+import { getTransactionByTransactionHash, getBlockByTransactionHash } from './database';
+
+const { SHIELD_CONTRACT_NAME } = global.config;
+
+const setInstantWithdrawl = async ({ transactionHash }, shieldContractAddress) => {
+ const block = await getBlockByTransactionHash(transactionHash);
+ const transactions = await Promise.all(
+ block.transactionHashes.map(t => getTransactionByTransactionHash(t)),
+ );
+ const index = transactions.findIndex(f => f.transactionHash === transactionHash);
+ const shieldContractInstance = await getContractInstance(
+ SHIELD_CONTRACT_NAME,
+ shieldContractAddress,
+ );
+ try {
+ const rawTransaction = await shieldContractInstance.methods
+ .setAdvanceWithdrawalFee(
+ buildSolidityStruct(block),
+ block.blockNumberL2,
+ transactions.map(t => Transaction.buildSolidityStruct(t)),
+ index,
+ )
+ .encodeABI();
+ return { rawTransaction };
+ } catch (error) {
+ throw new Error(error);
+ }
+};
+export default setInstantWithdrawl;
diff --git a/wallet/src/nightfall-browser/services/keys.js b/wallet/src/nightfall-browser/services/keys.js
new file mode 100644
index 000000000..929bc63aa
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/keys.js
@@ -0,0 +1,89 @@
+/* ignore unused exports */
+
+import { GN, generalise } from 'general-number';
+import { validateMnemonic, mnemonicToSeed } from 'bip39';
+import { hdkey } from 'ethereumjs-wallet';
+
+import mimcHash from '../../common-files/utils/crypto/mimc/mimc';
+import { scalarMult, edwardsCompress, edwardsDecompress } from '../utils/crypto/encryption/elgamal';
+
+export const ivks = [];
+export const nsks = [];
+const { BABYJUBJUB, BN128_GROUP_ORDER } = global.config;
+
+function generateHexSeed(mnemonic) {
+ return mnemonicToSeed(mnemonic);
+}
+
+// generate key from a seed based on path
+function generatePrivateKey(seed, path) {
+ return (
+ new GN(hdkey.fromMasterSeed(seed).derivePath(path).getWallet().getPrivateKey()).bigInt %
+ BN128_GROUP_ORDER
+ );
+}
+
+function calculatePublicKey(privateKey) {
+ return generalise(scalarMult(privateKey.hex(), BABYJUBJUB.GENERATOR));
+}
+
+export function compressPublicKey(publicKey) {
+ return new GN(edwardsCompress([publicKey[0].bigInt, publicKey[1].bigInt]));
+}
+
+export function decompressKey(key) {
+ return generalise(edwardsDecompress(key.bigInt));
+}
+
+// path structure is m / purpose' / coin_type' / account' / change / address_index
+// the path we use is m/44'/60'/account'/0/address_index
+// address will change incrementally for every new set of keys to be created from the same seed
+// address_index will define if the key is ask or nsk
+// path for ask is m/44'/60'/account'/0/0
+// path for nsk is m/44'/60'/account'/0/1
+async function generateASKAndNSK(seed, path) {
+ const ask = generalise(generatePrivateKey(seed, `${path}/0`), 'bigInt');
+ const nsk = generalise(generatePrivateKey(seed, `${path}/1`), 'bigInt');
+ return { ask, nsk };
+}
+
+// Calculate ivk from ask and nsk such as ivk = MiMC(ask, nsk)
+function calculateIVK(ask, nsk) {
+ return new GN(mimcHash([ask.bigInt, nsk.bigInt]));
+}
+
+// Calculate pkd from ivk such as pkd = ivk.G
+export function calculatePkd(ivk) {
+ const pkd = calculatePublicKey(ivk);
+ const compressedPkd = compressPublicKey(pkd);
+ return { pkd, compressedPkd };
+}
+
+// function to generate all the required keys deterministically from a random mnemonic
+// Use mnemonic to generate seed which will then be used to generate sets of ask and nsk based on different account numbers
+export async function generateKeys(mnemonic, path) {
+ if (validateMnemonic(mnemonic)) {
+ const seed = (await generateHexSeed(mnemonic)).toString('hex');
+ const { ask, nsk } = await generateASKAndNSK(seed, path);
+ const ivk = calculateIVK(ask, nsk);
+ const { pkd, compressedPkd } = calculatePkd(ivk);
+ return {
+ ask: ask.hex(),
+ nsk: nsk.hex(),
+ ivk: ivk.hex(),
+ pkd: [pkd[0].hex(), pkd[1].hex()],
+ compressedPkd: compressedPkd.hex(),
+ };
+ }
+ throw new Error('invalid mnemonic');
+}
+
+export function storeMemoryKeysForDecryption(ivk, nsk) {
+ return Promise.all([ivks.push(...ivk), nsks.push(...nsk)]);
+}
+
+export function calculateIvkPkdfromAskNsk(ask, nsk) {
+ const ivk = calculateIVK(ask, nsk);
+ const { pkd, compressedPkd } = calculatePkd(ivk);
+ return { ivk, pkd, compressedPkd };
+}
diff --git a/wallet/src/nightfall-browser/services/process-calldata.js b/wallet/src/nightfall-browser/services/process-calldata.js
new file mode 100644
index 000000000..90c28b0d2
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/process-calldata.js
@@ -0,0 +1,70 @@
+// ignore unused exports default
+
+/**
+Function to retreive calldata associated with a blockchain event.
+This is used, rather than re-emmiting the calldata in the event because it's
+much cheaper, although the offchain part is more complex.
+*/
+import Web3 from '../../common-files/utils/web3';
+import Transaction from '../../common-files/classes/transaction';
+import { decompressProof } from '../../common-files/utils/curve-maths/curves';
+
+const { PROPOSE_BLOCK_TYPES } = global.config;
+
+async function getProposeBlockCalldata(eventData) {
+ const web3 = Web3.connection();
+ const { transactionHash } = eventData;
+ const tx = await web3.eth.getTransaction(transactionHash);
+ // Remove the '0x' and function signature to recove rhte abi bytecode
+ const abiBytecode = `0x${tx.input.slice(10)}`;
+ const decoded = web3.eth.abi.decodeParameters(PROPOSE_BLOCK_TYPES, abiBytecode);
+ const blockData = decoded['0'];
+ const transactionsData = decoded['1'];
+ const [leafCount, proposer, root, blockNumberL2, previousBlockHash] = blockData;
+ const block = {
+ proposer,
+ root,
+ leafCount: Number(leafCount),
+ blockNumberL2: Number(blockNumberL2),
+ previousBlockHash,
+ };
+ const transactions = transactionsData.map(t => {
+ const [
+ value,
+ historicRootBlockNumberL2,
+ transactionType,
+ tokenType,
+ publicInputHash,
+ tokenId,
+ ercAddress,
+ recipientAddress,
+ commitments,
+ nullifiers,
+ compressedSecrets,
+ proof,
+ ] = t;
+ const transaction = {
+ value,
+ historicRootBlockNumberL2,
+ transactionType,
+ tokenType,
+ publicInputHash,
+ tokenId,
+ ercAddress,
+ recipientAddress,
+ commitments,
+ nullifiers,
+ compressedSecrets,
+ proof: decompressProof(proof),
+ };
+ // note, this transaction is incomplete in that the 'fee' field is empty.
+ // that shouldn't matter as it's not needed.
+ transaction.transactionHash = Transaction.calcHash(transaction);
+ return transaction;
+ });
+ block.transactionHashes = transactions.map(t => t.transactionHash);
+
+ return { transactions, block };
+}
+
+export default getProposeBlockCalldata;
diff --git a/wallet/src/nightfall-browser/services/state-sync.js b/wallet/src/nightfall-browser/services/state-sync.js
new file mode 100644
index 000000000..5f4ef7c8f
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/state-sync.js
@@ -0,0 +1,67 @@
+// ignore unused exports initialClientSync
+
+/**
+Resync code so that restarted client instances are able to read past events and update
+their local commitments databsae.
+*/
+import logger from '../../common-files/utils/logger';
+import { getContractInstance } from '../../common-files/utils/contract';
+// import mongo from '../../common-files/utils/mongo';
+import blockProposedEventHandler from '../event-handlers/block-proposed';
+import rollbackEventHandler from '../event-handlers/rollback';
+
+const { MONGO_URL, COMMITMENTS_DB, COMMITMENTS_COLLECTION, STATE_CONTRACT_NAME } = global.config;
+
+const syncState = async (
+ shieldContractAddress,
+ fromBlock = 'earliest',
+ toBlock = 'latest',
+ eventFilter = 'allEvents',
+) => {
+ const stateContractInstance = await getContractInstance(
+ STATE_CONTRACT_NAME,
+ shieldContractAddress,
+ ); // Rollback, BlockProposed
+
+ const pastStateEvents = await stateContractInstance.getPastEvents(eventFilter, {
+ fromBlock,
+ toBlock,
+ });
+ logger.info(`pastStateEvents: ${JSON.stringify(pastStateEvents)}`);
+
+ for (let i = 0; i < pastStateEvents.length; i++) {
+ switch (pastStateEvents[i].event) {
+ case 'BlockProposed':
+ // eslint-disable-next-line no-await-in-loop
+ await blockProposedEventHandler(pastStateEvents[i]);
+ break;
+ case 'Rollback':
+ // eslint-disable-next-line no-await-in-loop
+ await rollbackEventHandler(pastStateEvents[i]);
+ break;
+ default:
+ break;
+ }
+ }
+};
+
+const genGetCommitments = async (query = {}, proj = {}) => {
+ // eslint-disable-next-line no-undef
+ const connection = await mongo.connection(MONGO_URL);
+ const db = connection.db(COMMITMENTS_DB);
+ return db.collection(COMMITMENTS_COLLECTION).find(query, proj).toArray();
+};
+
+// eslint-disable-next-line import/prefer-default-export
+export const initialClientSync = async () => {
+ const allCommitments = await genGetCommitments();
+ if (allCommitments.length === 0) return {};
+
+ const commitmentBlockNumbers = allCommitments.map(a => a.blockNumber).filter(n => n >= 0);
+ logger.info(`commitmentBlockNumbers: ${commitmentBlockNumbers}`);
+ const firstSeenBlockNumber = Math.min(...commitmentBlockNumbers);
+ logger.info(`firstSeenBlockNumber: ${firstSeenBlockNumber}`);
+ // fistSeenBlockNumber can be infinity if the commitmentBlockNumbers array is empty
+ if (firstSeenBlockNumber === Infinity) return syncState();
+ return syncState(firstSeenBlockNumber);
+};
diff --git a/wallet/src/nightfall-browser/services/transfer.js b/wallet/src/nightfall-browser/services/transfer.js
new file mode 100644
index 000000000..cdfc33a6a
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/transfer.js
@@ -0,0 +1,296 @@
+/* ignore unused exports */
+
+/**
+This module contains the logic needed create a zkp transfer, i.e. to nullify
+two input commitments and create two new output commitments to the same value.
+It is agnostic to whether we are dealing with an ERC20 or ERC721 (or ERC1155).
+ * @module deposit
+ * @author westlad, Chaitanya-Konda, iAmMichaelConnor, will-kim
+ */
+
+import gen from 'general-number';
+import { initialize } from 'zokrates-js';
+
+import axios from 'axios';
+import rand from '../../common-files/utils/crypto/crypto-random';
+import { getContractInstance } from '../../common-files/utils/contract';
+import logger from '../../common-files/utils/logger';
+import { Secrets, Nullifier, Commitment, Transaction } from '../classes/index';
+import {
+ findUsableCommitmentsMutex,
+ storeCommitment,
+ markNullified,
+ clearPending,
+ getSiblingInfo,
+} from './commitment-storage';
+import { parseData, mergeUint8Array } from '../../utils/lib/file-reader-utils';
+import { decompressKey, calculateIvkPkdfromAskNsk } from './keys';
+
+// zokrates/single_transfer_stub/artifacts/single_transfer_stub-abi.json';
+// eslint-disable-next-line
+import singleTransferAbi from '../../zokrates/single_transfer_stub/artifacts/single_transfer_stub-abi.json';
+// eslint-disable-next-line
+import singleTransferProgramFile from '../../zokrates/single_transfer_stub/artifacts/single_transfer_stub-program';
+// eslint-disable-next-line
+import singleTransferPkFile from '../../zokrates/single_transfer_stub/keypair/single_transfer_stub_pk.key';
+// eslint-disable-next-line
+import doubleTransferAbi from '../../zokrates/double_transfer_stub/artifacts/double_transfer_stub-abi.json';
+// eslint-disable-next-line
+import doubleTransferProgramFile from '../../zokrates/double_transfer_stub/artifacts/double_transfer_stub-program';
+// eslint-disable-next-line
+import doubleTransferPkFile from '../../zokrates/double_transfer_stub/keypair/double_transfer_stub_pk.key';
+import { saveTransaction } from './database';
+
+const { BN128_GROUP_ORDER, ZKP_KEY_LENGTH, SHIELD_CONTRACT_NAME, proposerUrl, ZERO } =
+ global.config;
+const { generalise, GN } = gen;
+
+async function transfer(transferParams, shieldContractAddress) {
+ logger.info('Creating a transfer transaction');
+ // let's extract the input items
+ const { offchain = false, ...items } = transferParams;
+ const { ercAddress, tokenId, recipientData, nsk, ask, fee } = generalise(items);
+ const { pkd, compressedPkd } = calculateIvkPkdfromAskNsk(ask, nsk);
+ const { recipientCompressedPkds, values } = recipientData;
+ const recipientPkds = recipientCompressedPkds.map(key => decompressKey(key));
+ if (recipientCompressedPkds.length > 1)
+ throw new Error(`Batching is not supported yet: only one recipient is allowed`); // this will not always be true so we try to make the following code agnostic to the number of commitments
+
+ // the first thing we need to do is to find some input commitments which
+ // will enable us to conduct our transfer. Let's rummage in the db...
+ const totalValueToSend = values.reduce((acc, value) => acc + value.bigInt, 0n);
+ const oldCommitments = await findUsableCommitmentsMutex(
+ compressedPkd,
+ ercAddress,
+ tokenId,
+ totalValueToSend,
+ );
+ if (oldCommitments) logger.debug(`Found commitments ${JSON.stringify(oldCommitments, null, 2)}`);
+ else throw new Error('No suitable commitments were found'); // caller to handle - need to get the user to make some commitments or wait until they've been posted to the blockchain and Timber knows about them
+ // Having found either 1 or 2 commitments, which are suitable inputs to the
+ // proof, the next step is to compute their nullifiers;
+ const nullifiers = oldCommitments.map(commitment => new Nullifier(commitment, nsk));
+ // then the new output commitment(s)
+ const totalInputCommitmentValue = oldCommitments.reduce(
+ (acc, commitment) => acc + commitment.preimage.value.bigInt,
+ 0n,
+ );
+ // we may need to return change to the recipient
+ const change = totalInputCommitmentValue - totalValueToSend;
+ // if so, add an output commitment to do that
+ if (change !== 0n) {
+ values.push(new GN(change));
+ recipientPkds.push(pkd);
+ recipientCompressedPkds.push(compressedPkd);
+ }
+ const newCommitments = [];
+ let secrets = [];
+ const salts = [];
+ let potentialSalt;
+ let potentialCommitment;
+ for (let i = 0; i < recipientCompressedPkds.length; i++) {
+ // loop to find a new salt until the commitment hash is smaller than the BN128_GROUP_ORDER
+ do {
+ // eslint-disable-next-line no-await-in-loop
+ potentialSalt = new GN((await rand(ZKP_KEY_LENGTH)).bigInt % BN128_GROUP_ORDER);
+ potentialCommitment = new Commitment({
+ ercAddress,
+ tokenId,
+ value: values[i],
+ pkd: recipientPkds[i],
+ compressedPkd: recipientCompressedPkds[i],
+ salt: potentialSalt,
+ });
+ // encrypt secrets such as erc20Address, tokenId, value, salt for recipient
+ if (i === 0) {
+ // eslint-disable-next-line no-await-in-loop
+ secrets = await Secrets.encryptSecrets(
+ [ercAddress.bigInt, tokenId.bigInt, values[i].bigInt, potentialSalt.bigInt],
+ [recipientPkds[0][0].bigInt, recipientPkds[0][1].bigInt],
+ );
+ }
+ } while (potentialCommitment.hash.bigInt > BN128_GROUP_ORDER);
+ salts.push(potentialSalt);
+ newCommitments.push(potentialCommitment);
+ }
+
+ // compress the secrets to save gas
+ const compressedSecrets = Secrets.compressSecrets(secrets);
+
+ const commitmentTreeInfo = await Promise.all(oldCommitments.map(c => getSiblingInfo(c)));
+ const localSiblingPaths = commitmentTreeInfo.map(l => {
+ const path = l.siblingPath.path.map(p => p.value);
+ return generalise([l.root].concat(path.reverse()));
+ });
+ const leafIndices = commitmentTreeInfo.map(l => l.leafIndex);
+ const blockNumberL2s = commitmentTreeInfo.map(l => l.isOnChain);
+
+ // time for a quick sanity check. We expect the number of old commitments,
+ // new commitments and nullifiers to be equal.
+ if (nullifiers.length !== oldCommitments.length || nullifiers.length !== newCommitments.length) {
+ logger.error(
+ `number of old commitments: ${oldCommitments.length}, number of new commitments: ${newCommitments.length}, number of nullifiers: ${nullifiers.length}`,
+ );
+ throw new Error(
+ 'Commitment or nullifier numbers are mismatched. There should be equal numbers of each',
+ );
+ }
+
+ // now we have everything we need to create a Witness and compute a proof
+ const witnessInput = [
+ oldCommitments.map(commitment => commitment.preimage.ercAddress.integer).flat(),
+ oldCommitments.map(commitment => {
+ return {
+ id: commitment.preimage.tokenId.limbs(32, 8),
+ value: commitment.preimage.value.limbs(32, 8),
+ salt: commitment.preimage.salt.limbs(32, 8),
+ hash: commitment.hash.limbs(32, 8),
+ ask: ask.field(BN128_GROUP_ORDER),
+ };
+ }),
+ newCommitments.map(commitment => {
+ return {
+ pkdRecipient: [
+ commitment.preimage.pkd[0].field(BN128_GROUP_ORDER),
+ commitment.preimage.pkd[1].field(BN128_GROUP_ORDER),
+ ],
+ value: commitment.preimage.value.limbs(32, 8),
+ salt: commitment.preimage.salt.limbs(32, 8),
+ };
+ }),
+ newCommitments.map(commitment => commitment.hash.integer),
+ nullifiers.map(nullifier => nullifier.preimage.nsk.limbs(32, 8)),
+ nullifiers.map(nullifier => generalise(nullifier.hash.hex(32, 31)).integer),
+ localSiblingPaths.map(siblingPath => siblingPath[0].field(BN128_GROUP_ORDER, false)),
+ localSiblingPaths.map(siblingPath =>
+ siblingPath.slice(1).map(node => node.field(BN128_GROUP_ORDER, false)),
+ ), // siblingPAth[32] is a sha hash and will overflow a field but it's ok to take the mod here - hence the 'false' flag
+ leafIndices.map(leaf => leaf.toString()),
+ {
+ ephemeralKey1: secrets.ephemeralKeys[0].limbs(32, 8),
+ ephemeralKey2: secrets.ephemeralKeys[1].limbs(32, 8),
+ ephemeralKey3: secrets.ephemeralKeys[2].limbs(32, 8),
+ ephemeralKey4: secrets.ephemeralKeys[3].limbs(32, 8),
+ cipherText: secrets.cipherText.flat().map(text => text.field(BN128_GROUP_ORDER)),
+ sqrtMessage1: secrets.squareRootsElligator2[0].field(BN128_GROUP_ORDER),
+ sqrtMessage2: secrets.squareRootsElligator2[1].field(BN128_GROUP_ORDER),
+ sqrtMessage3: secrets.squareRootsElligator2[2].field(BN128_GROUP_ORDER),
+ sqrtMessage4: secrets.squareRootsElligator2[3].field(BN128_GROUP_ORDER),
+ },
+ compressedSecrets.map(text => generalise(text.hex(32, 31)).field(BN128_GROUP_ORDER)),
+ ];
+
+ const flattenInput = witnessInput.map(w => {
+ if (w.length === 1) {
+ const [w_] = w;
+ return w_;
+ }
+ return w;
+ });
+
+ console.log(`witness input is ${JSON.stringify(flattenInput)}`);
+ // call a zokrates worker to generate the proof
+ // This is (so far) the only place where we need to get specific about the
+ // circuit
+ let transactionType;
+ let program;
+ let pk;
+ let abi;
+ const zokratesProvider = await initialize();
+ if (oldCommitments.length === 1) {
+ transactionType = 1;
+ program = await fetch(singleTransferProgramFile)
+ .then(response => response.body.getReader())
+ .then(parseData)
+ .then(mergeUint8Array);
+ pk = await fetch(singleTransferPkFile)
+ .then(response => response.body.getReader())
+ .then(parseData)
+ .then(mergeUint8Array);
+ abi = singleTransferAbi;
+ blockNumberL2s.push(0); // We need top pad block numbers if we do a single transfer
+ } else if (oldCommitments.length === 2) {
+ transactionType = 2;
+ program = await fetch(doubleTransferProgramFile)
+ .then(response => response.body.getReader())
+ .then(parseData)
+ .then(mergeUint8Array);
+ pk = await fetch(doubleTransferPkFile)
+ .then(response => response.body.getReader())
+ .then(parseData)
+ .then(mergeUint8Array);
+ abi = doubleTransferAbi;
+ } else throw new Error('Unsupported number of commitments');
+
+ const artifacts = { program: new Uint8Array(program), abi };
+ const keypair = { pk: new Uint8Array(pk) };
+ const { witness } = zokratesProvider.computeWitness(artifacts, flattenInput);
+ // generate proof
+ let { proof } = zokratesProvider.generateProof(artifacts.program, witness, keypair.pk);
+ proof = [...proof.a, ...proof.b, ...proof.c];
+ proof = proof.flat(Infinity);
+ // and work out the ABI encoded data that the caller should sign and send to the shield contract
+ const shieldContractInstance = await getContractInstance(
+ SHIELD_CONTRACT_NAME,
+ shieldContractAddress,
+ );
+ const optimisticTransferTransaction = new Transaction({
+ fee,
+ historicRootBlockNumberL2: blockNumberL2s,
+ transactionType,
+ ercAddress: ZERO,
+ commitments: newCommitments,
+ nullifiers,
+ compressedSecrets,
+ proof,
+ });
+ try {
+ if (offchain) {
+ await axios
+ .post(
+ `${proposerUrl}/proposer/offchain-transaction`,
+ { transaction: optimisticTransferTransaction },
+ { timeout: 3600000 },
+ )
+ .catch(err => {
+ throw new Error(err);
+ });
+ // we only want to store our own commitments so filter those that don't
+ // have our public key
+ newCommitments
+ .filter(commitment => commitment.preimage.compressedPkd.hex(32) === compressedPkd.hex(32))
+ .forEach(commitment => storeCommitment(commitment, nsk)); // TODO insertMany
+ // mark the old commitments as nullified
+ await Promise.all(
+ oldCommitments.map(commitment => markNullified(commitment, optimisticTransferTransaction)),
+ );
+ await saveTransaction(optimisticTransferTransaction);
+ return {
+ transaction: optimisticTransferTransaction,
+ salts: salts.map(salt => salt.hex(32)),
+ };
+ }
+ const rawTransaction = await shieldContractInstance.methods
+ .submitTransaction(Transaction.buildSolidityStruct(optimisticTransferTransaction))
+ .encodeABI();
+ // store the commitment on successful computation of the transaction
+ newCommitments
+ .filter(commitment => commitment.preimage.compressedPkd.hex(32) === compressedPkd.hex(32))
+ .forEach(commitment => storeCommitment(commitment, nsk)); // TODO insertMany
+ // mark the old commitments as nullified
+ await Promise.all(
+ oldCommitments.map(commitment => markNullified(commitment, optimisticTransferTransaction)),
+ );
+ await saveTransaction(optimisticTransferTransaction);
+ return {
+ rawTransaction,
+ transaction: optimisticTransferTransaction,
+ salts: salts.map(salt => salt.hex(32)),
+ };
+ } catch (err) {
+ await Promise.all(oldCommitments.map(commitment => clearPending(commitment)));
+ throw new Error(err); // let the caller handle the error
+ }
+}
+
+export default transfer;
diff --git a/wallet/src/nightfall-browser/services/valid-withdrawal.js b/wallet/src/nightfall-browser/services/valid-withdrawal.js
new file mode 100644
index 000000000..e0f90dcf5
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/valid-withdrawal.js
@@ -0,0 +1,32 @@
+// ignore unused exports isValidWithdrawal
+
+/**
+Module to endable withdrawal of funds from the Shield contract to the user's
+address.
+*/
+import { getContractInstance } from '../../common-files/utils/contract';
+import { Transaction } from '../classes/index';
+import { buildSolidityStruct } from './finalise-withdrawal';
+
+const { SHIELD_CONTRACT_NAME } = global.config;
+
+// eslint-disable-next-line import/prefer-default-export
+export async function isValidWithdrawal({ block, transactions, index }, shieldContractAddress) {
+ const shieldContractInstance = await getContractInstance(
+ SHIELD_CONTRACT_NAME,
+ shieldContractAddress,
+ );
+ try {
+ const valid = await shieldContractInstance.methods
+ .isValidWithdrawal(
+ buildSolidityStruct(block),
+ block.blockNumberL2,
+ transactions.map(t => Transaction.buildSolidityStruct(t)),
+ index,
+ )
+ .call();
+ return valid;
+ } catch (err) {
+ return false;
+ }
+}
diff --git a/wallet/src/nightfall-browser/services/withdraw.js b/wallet/src/nightfall-browser/services/withdraw.js
new file mode 100644
index 000000000..886a33d63
--- /dev/null
+++ b/wallet/src/nightfall-browser/services/withdraw.js
@@ -0,0 +1,154 @@
+/* ignore unused exports */
+
+/**
+This module contains the logic needed create a zkp transfer, i.e. to nullify
+two input commitments and create two new output commitments to the same value.
+It is agnostic to whether we are dealing with an ERC20 or ERC721 (or ERC1155).
+ * @module deposit
+ * @author westlad, Chaitanya-Konda, iAmMichaelConnor, will-kim
+ */
+import gen from 'general-number';
+import { initialize } from 'zokrates-js';
+import axios from 'axios';
+import { getContractInstance } from '../../common-files/utils/contract';
+import logger from '../../common-files/utils/logger';
+import { Nullifier, Transaction } from '../classes/index';
+import {
+ findUsableCommitmentsMutex,
+ markNullified,
+ clearPending,
+ getSiblingInfo,
+} from './commitment-storage';
+import { calculateIvkPkdfromAskNsk } from './keys';
+
+// eslint-disable-next-line
+import abi from '../../zokrates/withdraw_stub/artifacts/withdraw_stub-abi.json';
+// eslint-disable-next-line
+import programFile from '../../zokrates/withdraw_stub/artifacts/withdraw_stub-program';
+// eslint-disable-next-line
+import pkFile from '../../zokrates/withdraw_stub/keypair/withdraw_stub_pk.key';
+import { parseData, mergeUint8Array } from '../../utils/lib/file-reader-utils';
+import { saveTransaction } from './database';
+
+const { BN128_GROUP_ORDER, SHIELD_CONTRACT_NAME, proposerUrl } = global.config;
+const { generalise } = gen;
+
+async function withdraw(withdrawParams, shieldContractAddress) {
+ logger.info('Creating a withdraw transaction');
+ // let's extract the input items
+ const { offchain = false, ...items } = withdrawParams;
+ const { ercAddress, tokenId, value, recipientAddress, nsk, ask, fee } = generalise(items);
+ const { compressedPkd } = await calculateIvkPkdfromAskNsk(ask, nsk);
+
+ // the first thing we need to do is to find and input commitment which
+ // will enable us to conduct our withdraw. Let's rummage in the db...
+ const [oldCommitment] = (await findUsableCommitmentsMutex(
+ compressedPkd,
+ ercAddress,
+ tokenId,
+ value,
+ true,
+ )) || [null];
+ if (oldCommitment) logger.debug(`Found commitment ${JSON.stringify(oldCommitment, null, 2)}`);
+ else throw new Error('No suitable commitments were found'); // caller to handle - need to get the user to make some commitments or wait until they've been posted to the blockchain and Timber knows about them
+ // Having found 1 commitment, which is a suitable input to the
+ // proof, the next step is to compute its nullifier;
+ const nullifier = new Nullifier(oldCommitment, nsk);
+ // and the Merkle path from the commitment to the root
+ const commitmentTreeInfo = await getSiblingInfo(oldCommitment);
+ const siblingPath = generalise(
+ [commitmentTreeInfo.root].concat(
+ commitmentTreeInfo.siblingPath.path.map(p => p.value).reverse(),
+ ),
+ );
+
+ // public inputs
+ const { leafIndex, isOnChain } = commitmentTreeInfo;
+
+ // now we have everything we need to create a Witness and compute a proof
+ const witnessInput = [
+ oldCommitment.preimage.ercAddress.integer,
+ oldCommitment.preimage.tokenId.integer,
+ oldCommitment.preimage.value.integer,
+ {
+ salt: oldCommitment.preimage.salt.limbs(32, 8),
+ hash: oldCommitment.hash.limbs(32, 8),
+ ask: ask.field(BN128_GROUP_ORDER),
+ },
+ nullifier.preimage.nsk.limbs(32, 8),
+ generalise(nullifier.hash.hex(32, 31)).integer,
+ recipientAddress.field(BN128_GROUP_ORDER),
+ siblingPath[0].field(BN128_GROUP_ORDER),
+ siblingPath.slice(1).map(node => node.field(BN128_GROUP_ORDER, false)), // siblingPAth[32] is a sha hash and will overflow a field but it's ok to take the mod here - hence the 'false' flag
+ leafIndex.toString(),
+ ];
+
+ logger.debug(`witness input is ${JSON.stringify(witnessInput)}`);
+ // call a zokrates worker to generate the proof
+ const zokratesProvider = await initialize();
+ const program = await fetch(programFile)
+ .then(response => response.body.getReader())
+ .then(parseData)
+ .then(mergeUint8Array);
+ const pk = await fetch(pkFile)
+ .then(response => response.body.getReader())
+ .then(parseData)
+ .then(mergeUint8Array);
+
+ const artifacts = { program: new Uint8Array(program), abi };
+ const keypair = { pk: new Uint8Array(pk) };
+ // computation
+ const { witness } = zokratesProvider.computeWitness(artifacts, witnessInput);
+ // generate proof
+ let { proof } = zokratesProvider.generateProof(artifacts.program, witness, keypair.pk);
+ proof = [...proof.a, ...proof.b, ...proof.c];
+ proof = proof.flat(Infinity);
+ // and work out the ABI encoded data that the caller should sign and send to the shield contract
+ const shieldContractInstance = await getContractInstance(
+ SHIELD_CONTRACT_NAME,
+ shieldContractAddress,
+ );
+ const optimisticWithdrawTransaction = new Transaction({
+ fee,
+ historicRootBlockNumberL2: [isOnChain, 0],
+ transactionType: 3,
+ tokenType: items.tokenType,
+ tokenId,
+ value,
+ ercAddress,
+ recipientAddress,
+ nullifiers: [nullifier],
+ proof,
+ });
+ try {
+ if (offchain) {
+ await axios
+ .post(
+ `${proposerUrl}/proposer/offchain-transaction`,
+ { transaction: optimisticWithdrawTransaction },
+ { timeout: 3600000 },
+ )
+ .catch(err => {
+ throw new Error(err);
+ });
+ const th = optimisticWithdrawTransaction.transactionHash;
+ delete optimisticWithdrawTransaction.transactionHash;
+ optimisticWithdrawTransaction.transactionHash = th;
+ await markNullified(oldCommitment, optimisticWithdrawTransaction);
+ await saveTransaction(optimisticWithdrawTransaction);
+ return { transaction: optimisticWithdrawTransaction };
+ }
+ const rawTransaction = await shieldContractInstance.methods
+ .submitTransaction(Transaction.buildSolidityStruct(optimisticWithdrawTransaction))
+ .encodeABI();
+ // on successful computation of the transaction mark the old commitments as nullified
+ await markNullified(oldCommitment, optimisticWithdrawTransaction);
+ await saveTransaction(optimisticWithdrawTransaction);
+ return { rawTransaction, transaction: optimisticWithdrawTransaction };
+ } catch (err) {
+ await clearPending(oldCommitment);
+ throw new Error(err); // let the caller handle the error
+ }
+}
+
+export default withdraw;
diff --git a/wallet/src/nightfall-browser/utils/crypto/encryption/elgamal.js b/wallet/src/nightfall-browser/utils/crypto/encryption/elgamal.js
new file mode 100644
index 000000000..24c034cfb
--- /dev/null
+++ b/wallet/src/nightfall-browser/utils/crypto/encryption/elgamal.js
@@ -0,0 +1,211 @@
+// ignore unused exports dec, enc, scalarMult, edwardsCompress, edwardsDecompress
+
+/**
+functions to support El-Gamal cipherText over a BabyJubJub curve
+*/
+
+import utils from '../../../../common-files/utils/crypto/merkle-tree/utils';
+import {
+ squareRootModPrime,
+ addMod,
+ mulMod,
+} from '../../../../common-files/utils/crypto/number-theory';
+import modDivide from './modular-division'; // TODO REPLACE WITH NPM VERSION
+import { hashToCurve, hashToCurveYSqrt, curveToHash } from './elligator2';
+
+const { BABYJUBJUB, BN128_GROUP_ORDER } = global.config;
+
+const one = BigInt(1);
+const { JUBJUBE, JUBJUBC, JUBJUBD, JUBJUBA, GENERATOR } = BABYJUBJUB;
+const Fp = BN128_GROUP_ORDER; // the prime field used with the curve E(Fp)
+const Fq = JUBJUBE / JUBJUBC;
+
+function isOnCurve(p) {
+ const { JUBJUBA: a, JUBJUBD: d } = BABYJUBJUB;
+ const uu = (p[0] * p[0]) % Fp;
+ const vv = (p[1] * p[1]) % Fp;
+ const uuvv = (uu * vv) % Fp;
+ return (a * uu + vv) % Fp === (one + d * uuvv) % Fp;
+}
+
+// // is On Montgomery curve By^2 = x^3 + Ax^2 + x
+// function isOnCurveMF(p) {
+// const { MONTA: a, MONTB: b } = BABYJUBJUB;
+// const u = p[0];
+// const uu = (p[0] * p[0]) % Fp;
+// const uuu = (p[0] * p[0] * p[0]) % Fp;
+// const vv = (p[1] * p[1]) % Fp;
+// return (b * vv) % Fp === (uuu + a * uu + u) % Fp;
+// }
+
+function negate(g) {
+ return [Fp - g[0], g[1]]; // this is wierd - we negate the x coordinate, not the y with babyjubjub!
+}
+
+/**
+Point addition on the babyjubjub curve TODO - MOD P THIS
+*/
+function add(p, q) {
+ const { JUBJUBA: a, JUBJUBD: d } = BABYJUBJUB;
+ const u1 = p[0];
+ const v1 = p[1];
+ const u2 = q[0];
+ const v2 = q[1];
+ const uOut = modDivide(u1 * v2 + v1 * u2, one + d * u1 * u2 * v1 * v2, Fp);
+ const vOut = modDivide(v1 * v2 - a * u1 * u2, one - d * u1 * u2 * v1 * v2, Fp);
+ if (!isOnCurve([uOut, vOut])) throw new Error('Addition point is not on the babyjubjub curve');
+ return [uOut, vOut];
+}
+
+/**
+Scalar multiplication on a babyjubjub curve
+@param {String} scalar - scalar mod q (will wrap if greater than mod q, which is probably ok)
+@param {Object} h - curve point in u,v coordinates
+*/
+function scalarMult(scalar, h, form = 'Edwards') {
+ const { INFINITY } = BABYJUBJUB;
+ const a = ((BigInt(scalar) % Fq) + Fq) % Fq; // just in case we get a value that's too big or negative
+ const exponent = a.toString(2).split(''); // extract individual binary elements
+ let doubledP = [...h]; // shallow copy h to prevent h being mutated by the algorithm
+ let accumulatedP = INFINITY;
+ for (let i = exponent.length - 1; i >= 0; i--) {
+ const candidateP = add(accumulatedP, doubledP, form);
+ accumulatedP = exponent[i] === '1' ? candidateP : accumulatedP;
+ doubledP = add(doubledP, doubledP, form);
+ }
+ if (!isOnCurve(accumulatedP))
+ throw new Error('Scalar multiplication point is not on the babyjubjub curve');
+ return accumulatedP;
+}
+
+/**
+Converting Montgomery point to Twisted Edwards point
+@param {String} p - point in Montgomery form
+*/
+function montgomeryToTwistedEdwards(p) {
+ if (p[0] === BigInt(0) && p[1] === BigInt(0) && p.length === 2)
+ return [BigInt(0), BigInt(Fp - BigInt(1))]; // M -> T [0,0] -> [0,-1]
+ const u = p[0];
+ const v = p[1];
+ const x = modDivide(u, v, Fp);
+ const y = modDivide(u - one, u + one, Fp);
+ return [x, y];
+}
+
+/**
+Converting Twisted Edwards point to Montgomery point
+@param {String} p - point in Twisted Edwards form
+*/
+function twistedEdwardsToMontgomery(p) {
+ if (p[0] === BigInt(0) && p[1] === BigInt(Fp - BigInt(1)) && p.length === 2)
+ return [BigInt(0), BigInt(0)]; // T -> M [0,-1] -> [0,0]
+ const x = p[0];
+ const y = p[1];
+ const u = modDivide(one + y, one - y, Fp);
+ const v = modDivide(one + y, (one - y) * x, Fp);
+ return [u, v];
+}
+
+/**
+Performs El-Gamal cipherText
+@param {Array(String)} strings - array containing the hex strings to be encrypted
+@param {String} ephemeralKeys - random values mod Fq. They must be unique and changed each time this function is called
+@param {String} publicKey - public key to encrypt with
+*/
+function enc(ephemeralKeys, strings, publicKey) {
+ if (ephemeralKeys.length < strings.length) {
+ throw new Error(
+ 'The number of random secrets must be greater than or equal to the number of messages',
+ );
+ }
+ // We can't directly encrypt hex strings. We can encrypt a curve point however,
+ // so we convert a string to a curve point using hash to curve
+ const messages = strings.map(e => hashToCurve(e));
+ // We convert this to Twisted Edwards point because Elligator 2 is applied on top of TE and not Montgomery curves
+ const messagesTE = messages.map(e => {
+ return montgomeryToTwistedEdwards(e);
+ });
+ // we get square roots calculated in hash to curve because it is quicker to prove squaring of two numbers than the square root value in zk circuits
+ const squareRootsElligator2 = strings.map(e => hashToCurveYSqrt(e));
+ // now we use the public keys and random number to generate shared secrets
+ const sharedSecrets = ephemeralKeys.map(e => {
+ // eslint-disable-next-line valid-typeof
+ if (typeof e !== 'bigint')
+ throw new Error(
+ 'The random secret chosen for cipherText should be a BigInt, unlike the messages, which are hex strings',
+ );
+ if (publicKey === undefined) throw new Error('Trying to encrypt with a undefined public key');
+ return scalarMult(e, publicKey);
+ });
+ // finally, we can encrypt the messages using the shared secrets
+ const c = ephemeralKeys.map(ephemeralKey => {
+ return scalarMult(ephemeralKey, GENERATOR);
+ });
+ const encryptedMessages = messagesTE.map((message, i) => {
+ return add(message, sharedSecrets[i]);
+ });
+ const cipherText = [...c, ...encryptedMessages];
+ return { ephemeralKeys, cipherText, squareRootsElligator2 };
+}
+
+/**
+Decrypt the above
+*/
+function dec(cipherText, privateKey) {
+ const c = cipherText.slice(0, cipherText.length / 2); // this encrypts the sender's random secret, needed for shared-secret generation
+ const encryptedMessages = cipherText.slice(cipherText.length / 2, cipherText.length);
+ // recover the shared secrets
+ const sharedSecrets = c.map(sharedSecret => {
+ if (privateKey === undefined)
+ throw new Error('Trying to decrypt with an undefined private key');
+ return scalarMult(privateKey, sharedSecret);
+ });
+ // then decrypt
+ const messagePoints = encryptedMessages.map((encryptedMessage, i) =>
+ add(encryptedMessage, negate(sharedSecrets[i])),
+ );
+ const messagesMONT = messagePoints.map(messagePoint => twistedEdwardsToMontgomery(messagePoint));
+ const messages = messagesMONT.map(messagePoint => curveToHash(messagePoint));
+ return messages;
+}
+
+/** A useful function that takes a curve point and throws away the x coordinate
+retaining only the y coordinate and the odd/eveness of the x coordinate (plays the
+part of a sign in mod arithmetic with a prime field). This loses no information
+because we know the curve that relates x to y and the odd/eveness disabiguates the two
+possible solutions. So it's a useful data compression.
+TODO - probably simpler to use integer arithmetic rather than binary manipulations
+*/
+function edwardsCompress(p) {
+ const px = p[0];
+ const py = p[1];
+ const xBits = px.toString(2).padStart(256, '0');
+ const yBits = py.toString(2).padStart(256, '0');
+ const sign = xBits[255] === '1' ? '1' : '0';
+ const yBitsC = sign.concat(yBits.slice(1)); // add in the sign bit
+ const y = utils.ensure0x(BigInt('0b'.concat(yBitsC)).toString(16).padStart(64, '0')); // put yBits into hex
+ return y;
+}
+
+function edwardsDecompress(y) {
+ const py = BigInt(y).toString(2).padStart(256, '0');
+ const sign = py[0];
+ const yfield = BigInt(`0b${py.slice(1)}`); // remove the sign encoding
+ if (yfield > Fp || yfield < 0) throw new Error(`y cordinate ${yfield} is not a field element`);
+ // 168700.x^2 + y^2 = 1 + 168696.x^2.y^2
+ const y2 = mulMod([yfield, yfield], Fp);
+ const x2 = modDivide(
+ addMod([y2, BigInt(-1)], Fp),
+ addMod([mulMod([JUBJUBD, y2], Fp), -JUBJUBA], Fp),
+ Fp,
+ );
+ if (x2 === 0n && sign === '0') return BABYJUBJUB.INFINITY;
+ let xfield = squareRootModPrime(x2, Fp);
+ const px = BigInt(xfield).toString(2).padStart(256, '0');
+ if (px[255] !== sign) xfield = Fp - xfield;
+ const p = [xfield, yfield];
+ if (!isOnCurve(p)) throw new Error('The computed point was not on the Babyjubjub curve');
+ return p;
+}
+
+export { dec, enc, scalarMult, edwardsCompress, edwardsDecompress };
diff --git a/wallet/src/nightfall-browser/utils/crypto/encryption/elligator2.js b/wallet/src/nightfall-browser/utils/crypto/encryption/elligator2.js
new file mode 100644
index 000000000..a436089ca
--- /dev/null
+++ b/wallet/src/nightfall-browser/utils/crypto/encryption/elligator2.js
@@ -0,0 +1,107 @@
+// ignore unused exports hashToCurve, hashToCurveYSqrt, curveToHash
+
+import {
+ squareRootModPrime,
+ addMod,
+ mulMod,
+ powerMod,
+} from '../../../../common-files/utils/crypto/number-theory';
+import modDivide from './modular-division';
+
+const { BABYJUBJUB, BN128_GROUP_ORDER, ELLIGATOR2 } = global.config;
+
+const one = BigInt(1);
+const { MONTA, MONTB } = BABYJUBJUB;
+const { U } = ELLIGATOR2;
+const Fp = BN128_GROUP_ORDER; // the prime field used with the curve E(Fp)
+
+// χ : Fq → Fq by χ(a) = a^((q−1)/2)
+function chi(a) {
+ return powerMod(a, (Fp - one) / BigInt(2), Fp);
+}
+
+// // if value <= p-1//2, then positive
+// function isPositive(value) {
+// return value % Fp <= modDivide(BN128_GROUP_ORDER - BigInt(1), BigInt(2), Fp);
+// }
+
+// if value > p-1//2, then negative
+function isNegative(value) {
+ return value % Fp > modDivide(Fp - BigInt(1), BigInt(2), Fp);
+}
+
+// if value == 0 or chi(value) == 1
+function isSquare(value) {
+ return value === BigInt(0) || chi(value) === BigInt(1);
+}
+
+// r∈Fq :1+ur^2!=0, A^2ur^2!=B(1+ur^2)^2
+function checkR(r) {
+ return (
+ (BigInt(1) + ((U * r * r) % Fp)) % Fp !== BigInt(0) &&
+ (MONTA * MONTA * U * r * r) % Fp !==
+ (MONTB * (BigInt(1) + ((U * r * r) % Fp)) * (BigInt(1) + ((U * r * r) % Fp))) % Fp
+ );
+}
+
+// v = −A/(1+ur^2),
+// ε = χ(v3 +Av2 +Bv),
+// x = εv − (1 − ε)A/2,
+// y = −ε sqrt(x3 +Ax2 +Bx)
+// r has to be BigInt
+export function hashToCurve(r) {
+ if (r === BigInt(0)) return [BigInt(0), BigInt(0)];
+ if (checkR(r) !== true) throw new Error(`This value can't be hashed to curve using Elligator2`);
+ const v = modDivide(-MONTA, one + U * r * r, Fp);
+ const e = chi((v * v * v + MONTA * v * v + MONTB * v) % Fp);
+ const x = ((e * v) % Fp) - modDivide((one - e) * MONTA, BigInt(2), Fp);
+ let y2 = squareRootModPrime((x * x * x + MONTA * x * x + MONTB * x) % Fp, Fp);
+ // Ensure returned value is the principal root (i.e. sqrt(x) ∈ [0, (Fp -1) / 2] )
+ if (y2 > (Fp - BigInt(1)) / BigInt(2)) y2 = Fp - y2;
+ const y = mulMod([-e, y2], Fp);
+ return [x, y];
+}
+
+// required for SNARK where we don't calculate the square root rather prove that the square of two
+// square roots is the number for constraint efficiency
+export function hashToCurveYSqrt(r) {
+ const v = modDivide(-MONTA, one + U * r * r, Fp);
+ const e = chi((v * v * v + MONTA * v * v + MONTB * v) % Fp);
+ const x = ((e * v) % Fp) - modDivide((one - e) * MONTA, BigInt(2), Fp);
+ let y2 = squareRootModPrime((x * x * x + MONTA * x * x + MONTB * x) % Fp, Fp);
+ // Ensure returned value is the principal root (i.e. sqrt(x) ∈ [0, (Fp -1) / 2] )
+ if (y2 > (Fp - BigInt(1)) / BigInt(2)) y2 = Fp - y2;
+ return y2;
+}
+
+// x=−A,
+// if y=0 then x=0,and
+// −ux(x+A) is a square in Fq.
+function canCurveToHash(point) {
+ const x = point[0];
+ const y = point[1];
+ if (x === BigInt(0)) {
+ if (y !== BigInt(0)) {
+ return false;
+ }
+ }
+ return x !== -MONTA && isSquare(mulMod([mulMod([-U, x], Fp), addMod([x, MONTA], Fp)], Fp));
+}
+
+// r = sqrt(-x/(x+A)u), if y ∈ F2q
+// r = sqrt(-(x+A)/ux), if y ∈/ F2q
+export function curveToHash(point) {
+ if (point[0] === BigInt(0) && point[1] === BigInt(0) && point.length === 2) return BigInt(0);
+ if (!canCurveToHash(point)) throw new Error('cannot curve to hash');
+ const x = point[0];
+ const y = point[1];
+ let r;
+ if (isNegative(y)) {
+ r = squareRootModPrime(modDivide(-(x + MONTA), U * x, Fp), Fp);
+ } else {
+ r = squareRootModPrime(modDivide(-x, U * (x + MONTA), Fp), Fp);
+ }
+ // Ensure returned value is the principal root (i.e. sqrt(x) ∈ [0, (Fp -1) / 2] )
+ if (r > (Fp - BigInt(1)) / BigInt(2)) r = Fp - r;
+ return r;
+}
diff --git a/wallet/src/nightfall-browser/utils/crypto/encryption/modular-division.js b/wallet/src/nightfall-browser/utils/crypto/encryption/modular-division.js
new file mode 100644
index 000000000..4ee2ce0ed
--- /dev/null
+++ b/wallet/src/nightfall-browser/utils/crypto/encryption/modular-division.js
@@ -0,0 +1,42 @@
+// ignore unused exports default
+
+// modular division
+
+const one = BigInt(1);
+const zero = BigInt(0);
+
+// function for extended Euclidean Algorithm
+// (used to find modular inverse.
+function gcdExtended(a, b, _xy) {
+ const xy = _xy;
+ if (a === zero) {
+ xy[0] = zero;
+ xy[1] = one;
+ return b;
+ }
+ const xy1 = [zero, zero];
+ const gcd = gcdExtended(b % a, a, xy1);
+
+ // Update x and y using results of recursive call
+ xy[0] = xy1[1] - (b / a) * xy1[0];
+ xy[1] = xy1[0]; // eslint-disable-line prefer-destructuring
+
+ return gcd;
+}
+
+// Function to find modulo inverse of b.
+function modInverse(b, m) {
+ const xy = [zero, zero]; // used in extended GCD algorithm
+ const g = gcdExtended(b, m, xy);
+ if (g !== one) throw new Error('Numbers were not relatively prime');
+ // m is added to handle negative x
+ return ((xy[0] % m) + m) % m;
+}
+
+// Function to compute a/b mod m
+export default function modDivide(a, b, m) {
+ const aa = ((a % m) + m) % m; // check the numbers are mod m and not negative
+ const bb = ((b % m) + m) % m; // do we really need this?
+ const inv = modInverse(bb, m);
+ return (inv * aa) % m;
+}
diff --git a/wallet/src/react-app-env.d.ts b/wallet/src/react-app-env.d.ts
new file mode 100644
index 000000000..6431bc5fc
--- /dev/null
+++ b/wallet/src/react-app-env.d.ts
@@ -0,0 +1 @@
+///
+ ,
+ );
const linkElement = screen.getByText(/learn react/i);
expect(linkElement).toBeInTheDocument();
});
diff --git a/wallet/src/views/app.view.jsx b/wallet/src/views/app.view.jsx
index 0c366852d..efdc8e955 100644
--- a/wallet/src/views/app.view.jsx
+++ b/wallet/src/views/app.view.jsx
@@ -1,65 +1,52 @@
-import React from 'react';
-import { Route, Redirect, Switch } from 'react-router-dom';
-import { connect } from 'react-redux';
-import PropTypes from 'prop-types';
-import * as Nf3 from 'nf3';
-
-import Transactions from './transactions/transactions.view.jsx';
-import Login from './login/login.view.jsx';
+/* eslint-disable no-unused-vars */
+import React, { useEffect, useState } from 'react';
+import { Route, Switch, Redirect, BrowserRouter } from 'react-router-dom';
import { NF3_GITHUB_ISSUES_URL } from '../constants';
-import * as loginActions from '../store/login/login.actions';
-
-function App({ onDeleteWallet }) {
- Nf3.Environment.setEnvironment(process.env.REACT_APP_ENVIRONMENT);
-
- // Detect page refresh
- React.useEffect(() => {
- window.addEventListener('beforeunload', () => {
- onDeleteWallet();
+import MainPage from './initialPage/index.jsx';
+import Wallet from './wallet/index.jsx';
+import { UserContext, UserProvider } from '../hooks/User/index.jsx';
+import TransactionPage from './transactionPage/index.jsx';
+import Web3 from '../common-files/utils/web3';
+import Bridge from './bridge/index.jsx';
+import generateWebComponents from '../utils/generateWebComponents';
+
+export default function App() {
+ // eslint-disable-next-line no-unused-vars
+ const [, setIsWeb3Connected] = useState(false);
+
+ useEffect(async () => {
+ await Web3.connect();
+ setIsWeb3Connected({
+ isWeb3Connected: true,
});
- }, [onDeleteWallet]);
-
- // TODO:Detect network is online/offline
-
- // Detect accounts changed and chain changed on metamask
- React.useEffect(() => {
- if (window.ethereum) {
- window.ethereum.on('accountsChanged', () => {
- onDeleteWallet();
- });
- window.ethereum.on('chainChanged', () => {
- onDeleteWallet();
- });
- }
- }, [onDeleteWallet]);
-
+ generateWebComponents();
+ }, []);
+
+ /*
+ * TODO: for path /wallet and /bridge component should render when web3connect is complete
+ * like implement a loader till web3connect is not complete
+ * for example with blank page:
+ * const web3Boiler =
-
- {
- window.location = NF3_GITHUB_ISSUES_URL;
- }}
- />
-
-
+
+
+
+ {
+ window.location = NF3_GITHUB_ISSUES_URL;
+ }}
+ />
+
+
+
);
}
-
-App.propTypes = {
- onDeleteWallet: PropTypes.func.isRequired,
-};
-
-const mapStateToProps = state => ({
- login: state.login,
-});
-
-const mapDispatchToProps = dispatch => ({
- onDeleteWallet: () => dispatch(loginActions.deleteWallet()),
-});
-
-export default connect(mapStateToProps, mapDispatchToProps)(App);
diff --git a/wallet/src/views/bridge/index.jsx b/wallet/src/views/bridge/index.jsx
new file mode 100644
index 000000000..10c355167
--- /dev/null
+++ b/wallet/src/views/bridge/index.jsx
@@ -0,0 +1,93 @@
+/* eslint-disable react/jsx-no-undef */
+/* eslint-disable react/jsx-pascal-case */
+import React, { useContext } from 'react';
+import styles from '../../styles/bridge.module.scss';
+import bridgeInfoImage from '../../assets/img/bridge-info.png';
+import Header from '../../components/Header/header.jsx';
+import SideBar from '../../components/SideBar/index.jsx';
+// eslint-disable-next-line import/no-unresolved
+import { UserContext } from '../../hooks/User/index.jsx';
+
+const Bridge = () => {
+ const [state] = useContext(UserContext);
+
+ return (
+ // containerFluid
+
+
- Enter Polygon Nightfall Mnemonic
-
-
+ setShowSendModal(false)}
+ >
+
+ Send
+
+
+
+
+
+ );
+}
+
+TokenItem.propTypes = {
+ maticChainUsdBalance: PropTypes.string.isRequired,
+ maticChainBalance: PropTypes.string.isRequired,
+ name: PropTypes.string.isRequired,
+ symbol: PropTypes.string.isRequired,
+ tokenAddress: PropTypes.string.isRequired,
+};
diff --git a/wallet/src/components/Tokens/index.jsx b/wallet/src/components/Tokens/index.jsx
new file mode 100644
index 000000000..b40702713
--- /dev/null
+++ b/wallet/src/components/Tokens/index.jsx
@@ -0,0 +1,273 @@
+import React from 'react';
+import PropTypes from 'prop-types';
+import styles from '../../styles/tokens.module.scss';
+import TokenItem from '../TokenItem/index.jsx';
+
+export default function Tokens(token) {
+ return (
+ {/* 
*/}
+
+ ]})
+
+
+
+
+ {/*
+
+ {/* cursor-pointer below */}
+ {/* class="{ 'hide-it': !isLoginStrategyMetaMask }" */}
+ {/* @click="handleAddTokenToMetamask" */}
+
+ {/*
+ */}
+
+
+ {symbol}
+
+ {/* styles.mobileView See how to do it */}
+
+ plasma
+
+
+ •
+ {name}
+
+ {true && plasma
}
+
+
+
+
+
+ {/* {{ token.getMaticChainBalance | fixed(4) }} */}
+ {Number(maticChainBalance).toFixed(4)}
+
+ {/* */}
+
+ {/* {{ token.maticChainUsdBalance | fixed(2) | dollarSymbol }} */}
+
+ {' '}
+ •{' '}
+
+ ${(Number(maticChainUsdBalance) * Number(maticChainBalance)).toFixed(2)}
+
+
+ {/* :to="{
+ name: 'bridge',
+ params: { type: TRANSACTION_TYPE.DEPOSIT, token },
+ }"
+ :event="isDepositDisabled(token) ? '' : 'click'"
+ v-tooltip="isDepositDisabled(token) ? 'Not Supported' : null" */}
+
+ Deposit
+
+ {/* v-tooltip="isWithdrawDisabled(token) ? 'Not Supported' : null"
+ :to="{
+ name: 'bridge',
+ params: { type: TRANSACTION_TYPE.WITHDRAW, token },
+ }"
+ :event="isWithdrawDisabled(token) ? '' : 'click'" */}
+
+ Withdraw
+
+ {/* onClick="handleSendToken" */}
+
+
+
+ {/* 
+
+ {/*
+ {{ token }}
+
*/}
+
+
*/}
+
+ {/* SEND BUTTON */}
+ Hellp {{ isMobileScreen }} {{ screenInnerWidth }}
+
+
+
+
+
+
+
+
+ Enter a valid address existing on the Polygon Nightfall L2
+
+
+
+ setTransferValue(e.target.value)}
+ id="TokenItem_modalSend_tokenAmount"
+ />
+
+ MAX
+
+ 
+
+ Matic (L2)
+
+
+
+ $ 0
+
+
+ Available Balance:
+0.0105 ETH
+
+
+
+ x.xxx {name} Gas Fee
+
+
+ );
+}
+
+Tokens.propTypes = {
+ tokenList: PropTypes.array.isRequired,
+};
diff --git a/wallet/src/components/Transactions/index.jsx b/wallet/src/components/Transactions/index.jsx
new file mode 100644
index 000000000..d0dc30625
--- /dev/null
+++ b/wallet/src/components/Transactions/index.jsx
@@ -0,0 +1,249 @@
+import React, { useEffect } from 'react';
+import { Col, Row } from 'react-bootstrap';
+import styles from '../../styles/transactionPage.module.scss';
+import bridgeInfoImage from '../../assets/img/bridge-info.png';
+import polygonChainImage from '../../assets/img/polygon-chain.svg';
+import maticImage from '../../assets/svg/matic.svg';
+import {
+ getAllTransactions,
+ findBlocksFromBlockNumberL2,
+} from '../../nightfall-browser/services/database.js';
+
+const txTypeOptions = ['Deposit', 'Transfer', 'Transfer', 'Withdraw'];
+const txTypeDest = [
+ 'From Ethereum to L2',
+ 'Private Transfer',
+ 'Private Transfer',
+ 'From L2 to Ethereum',
+];
+
+const displayTime = (start, end) => {
+ const diff = (Number(end) - Number(start)) / 1000;
+ if (diff < 60) return `${Math.floor(diff)} secs ago`;
+ if (diff < 3600) return `${Math.floor(diff / 60)} mins ago`;
+ return `${Math.floor(diff / 3600)} mins ago`;
+};
+
+const Transactions = () => {
+ const [txs, setTxs] = React.useState([]);
+
+ useEffect(async () => {
+ const transactionsDB = await getAllTransactions();
+ const transactions = Array.from(new Set(transactionsDB));
+ console.log('Transaction', transactions);
+
+ const blocks = await findBlocksFromBlockNumberL2(-1);
+ // console.log()
+ const mappedTxs = transactions
+ .map(tx => {
+ const trucString = `${tx._id.slice(0, 5)}...${tx._id.slice(-5)}`;
+ const safeTransactionType = BigInt(tx.transactionType).toString();
+ const safeValue = BigInt(tx.value).toString();
+ blocks.forEach(b => {
+ console.log('b.transactionHashes', b.transactionHashes);
+ console.log('tx_id', tx._id);
+ if (tx.isOnChain >= 0) return;
+ if (b.transactionHashes.includes(tx._id)) {
+ // eslint-disable-next-line no-param-reassign
+ tx.isOnChain = b.blockNumberL2;
+ }
+ // eslint-disable-next-line no-param-reassign
+ else tx.isOnChain = -1;
+ });
+ console.log('isOnChain', tx.isOnChain);
+ return {
+ transactionHash: tx._id,
+ truncTransactionHash: trucString,
+ txType: safeTransactionType,
+ value: safeValue,
+ isOnChain: tx.isOnChain,
+ createdTime: tx.createdTime,
+ now: Date.now(),
+ };
+ })
+ .sort((a, b) => b.createdTime - a.createdTime);
+
+ console.log('Transactions', transactions);
+ setTxs(mappedTxs);
+ }, []);
+
+ return (
+
+
+
+
+
+
+ {/* Balances on Polygon Nightfall
+ {/*
+
*/}
+
+
+
*/}
+
+
+
+
+
+ {/* */}
+
+ {/*
+
+ {token.tokenList.map((t, index) => (
+ Name
+ Balance
+ Actions
+
+
*/}
+ {/*
+
+
+
+ Showing {{ currentItemStartCount }}-{{ currentItemEndCount }} of
+ {{ totalItems }}
+
+ |
+
+
+
+ Show:
+
+
+ No tokens found
+
+
+
+
+ */}
+
+
+
+ ![token icon]()
+ {{ selectedToken.symbol }}
+ •
+
+ {{ selectedToken.name }}
+
+
+
+ Actions
+
+
+
+
+
+
+
+
+
+ );
+};
+
+export default Transactions;
diff --git a/wallet/src/constants.js b/wallet/src/constants.js
index 4284f5701..89f4c3458 100644
--- a/wallet/src/constants.js
+++ b/wallet/src/constants.js
@@ -1,7 +1,16 @@
/* ignore unused exports */
const DEFAULT_NF_ADDRESS_INDEX = 0;
const NF3_GITHUB_ISSUES_URL = 'https://github.com/EYBlockchain/nightfall_3/issues';
-const DEFAULT_TOKEN_TYPE = 'ERC20';
+
+const TOKEN_TYPE = {
+ ERC20: 'ERC20',
+ ERC721: 'ERC721',
+ ERC1155: 'ERC1155',
+};
+
+const APPROVE_AMOUNT =
+ '115792089237316195423570985008687907853269984665640564039457584007913129639935';
+
const DEFAULT_TOKEN_ADDRESS = {
ERC20: '0xb5acbe9a0f1f8b98f3fc04471f7fe5d2c222cb44'.toLowerCase(),
ERC721: '0x103ac4b398bca487df8b27fd484549e33c234b0d'.toLowerCase(),
@@ -29,7 +38,8 @@ const BALANCE_INTERVAL = 60000;
export {
DEFAULT_NF_ADDRESS_INDEX,
NF3_GITHUB_ISSUES_URL,
- DEFAULT_TOKEN_TYPE,
+ TOKEN_TYPE,
+ APPROVE_AMOUNT,
DEFAULT_TOKEN_ADDRESS,
DEFAULT_DEPOSIT_FEE,
DEFAULT_INSTANT_WITHDRAW_FEE,
diff --git a/wallet/src/contract-abis/ERC1155.json b/wallet/src/contract-abis/ERC1155.json
new file mode 100644
index 000000000..b01d955c6
--- /dev/null
+++ b/wallet/src/contract-abis/ERC1155.json
@@ -0,0 +1,331 @@
+[
+ {
+ "inputs":[
+ {
+ "internalType":"string",
+ "name":"uri_",
+ "type":"string"
+ }
+ ],
+ "stateMutability":"nonpayable",
+ "type":"constructor"
+ },
+ {
+ "anonymous":false,
+ "inputs":[
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"account",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"operator",
+ "type":"address"
+ },
+ {
+ "indexed":false,
+ "internalType":"bool",
+ "name":"approved",
+ "type":"bool"
+ }
+ ],
+ "name":"ApprovalForAll",
+ "type":"event"
+ },
+ {
+ "anonymous":false,
+ "inputs":[
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"operator",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"from",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "indexed":false,
+ "internalType":"uint256[]",
+ "name":"ids",
+ "type":"uint256[]"
+ },
+ {
+ "indexed":false,
+ "internalType":"uint256[]",
+ "name":"values",
+ "type":"uint256[]"
+ }
+ ],
+ "name":"TransferBatch",
+ "type":"event"
+ },
+ {
+ "anonymous":false,
+ "inputs":[
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"operator",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"from",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "indexed":false,
+ "internalType":"uint256",
+ "name":"id",
+ "type":"uint256"
+ },
+ {
+ "indexed":false,
+ "internalType":"uint256",
+ "name":"value",
+ "type":"uint256"
+ }
+ ],
+ "name":"TransferSingle",
+ "type":"event"
+ },
+ {
+ "anonymous":false,
+ "inputs":[
+ {
+ "indexed":false,
+ "internalType":"string",
+ "name":"value",
+ "type":"string"
+ },
+ {
+ "indexed":true,
+ "internalType":"uint256",
+ "name":"id",
+ "type":"uint256"
+ }
+ ],
+ "name":"URI",
+ "type":"event"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"bytes4",
+ "name":"interfaceId",
+ "type":"bytes4"
+ }
+ ],
+ "name":"supportsInterface",
+ "outputs":[
+ {
+ "internalType":"bool",
+ "name":"",
+ "type":"bool"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"uint256",
+ "name":"",
+ "type":"uint256"
+ }
+ ],
+ "name":"uri",
+ "outputs":[
+ {
+ "internalType":"string",
+ "name":"",
+ "type":"string"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"account",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"id",
+ "type":"uint256"
+ }
+ ],
+ "name":"balanceOf",
+ "outputs":[
+ {
+ "internalType":"uint256",
+ "name":"",
+ "type":"uint256"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address[]",
+ "name":"accounts",
+ "type":"address[]"
+ },
+ {
+ "internalType":"uint256[]",
+ "name":"ids",
+ "type":"uint256[]"
+ }
+ ],
+ "name":"balanceOfBatch",
+ "outputs":[
+ {
+ "internalType":"uint256[]",
+ "name":"",
+ "type":"uint256[]"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"operator",
+ "type":"address"
+ },
+ {
+ "internalType":"bool",
+ "name":"approved",
+ "type":"bool"
+ }
+ ],
+ "name":"setApprovalForAll",
+ "outputs":[
+
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"account",
+ "type":"address"
+ },
+ {
+ "internalType":"address",
+ "name":"operator",
+ "type":"address"
+ }
+ ],
+ "name":"isApprovedForAll",
+ "outputs":[
+ {
+ "internalType":"bool",
+ "name":"",
+ "type":"bool"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"from",
+ "type":"address"
+ },
+ {
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"id",
+ "type":"uint256"
+ },
+ {
+ "internalType":"uint256",
+ "name":"amount",
+ "type":"uint256"
+ },
+ {
+ "internalType":"bytes",
+ "name":"data",
+ "type":"bytes"
+ }
+ ],
+ "name":"safeTransferFrom",
+ "outputs":[
+
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"from",
+ "type":"address"
+ },
+ {
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256[]",
+ "name":"ids",
+ "type":"uint256[]"
+ },
+ {
+ "internalType":"uint256[]",
+ "name":"amounts",
+ "type":"uint256[]"
+ },
+ {
+ "internalType":"bytes",
+ "name":"data",
+ "type":"bytes"
+ }
+ ],
+ "name":"safeBatchTransferFrom",
+ "outputs":[
+
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ }
+]
\ No newline at end of file
diff --git a/wallet/src/contract-abis/ERC165.json b/wallet/src/contract-abis/ERC165.json
new file mode 100644
index 000000000..53fa00071
--- /dev/null
+++ b/wallet/src/contract-abis/ERC165.json
@@ -0,0 +1,21 @@
+[
+ {
+ "inputs": [
+ {
+ "internalType": "bytes4",
+ "name": "interfaceId",
+ "type": "bytes4"
+ }
+ ],
+ "name": "supportsInterface",
+ "outputs": [
+ {
+ "internalType": "bool",
+ "name": "",
+ "type": "bool"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function"
+ }
+]
diff --git a/wallet/src/contract-abis/ERC20.json b/wallet/src/contract-abis/ERC20.json
new file mode 100644
index 000000000..d4503c38b
--- /dev/null
+++ b/wallet/src/contract-abis/ERC20.json
@@ -0,0 +1,296 @@
+[
+ {
+ "inputs":[
+ {
+ "internalType":"string",
+ "name":"name_",
+ "type":"string"
+ },
+ {
+ "internalType":"string",
+ "name":"symbol_",
+ "type":"string"
+ }
+ ],
+ "stateMutability":"nonpayable",
+ "type":"constructor"
+ },
+ {
+ "anonymous":false,
+ "inputs":[
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"owner",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"spender",
+ "type":"address"
+ },
+ {
+ "indexed":false,
+ "internalType":"uint256",
+ "name":"value",
+ "type":"uint256"
+ }
+ ],
+ "name":"Approval",
+ "type":"event"
+ },
+ {
+ "anonymous":false,
+ "inputs":[
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"from",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "indexed":false,
+ "internalType":"uint256",
+ "name":"value",
+ "type":"uint256"
+ }
+ ],
+ "name":"Transfer",
+ "type":"event"
+ },
+ {
+ "inputs":[
+
+ ],
+ "name":"name",
+ "outputs":[
+ {
+ "internalType":"string",
+ "name":"",
+ "type":"string"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+
+ ],
+ "name":"symbol",
+ "outputs":[
+ {
+ "internalType":"string",
+ "name":"",
+ "type":"string"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+
+ ],
+ "name":"decimals",
+ "outputs":[
+ {
+ "internalType":"uint8",
+ "name":"",
+ "type":"uint8"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+
+ ],
+ "name":"totalSupply",
+ "outputs":[
+ {
+ "internalType":"uint256",
+ "name":"",
+ "type":"uint256"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"account",
+ "type":"address"
+ }
+ ],
+ "name":"balanceOf",
+ "outputs":[
+ {
+ "internalType":"uint256",
+ "name":"",
+ "type":"uint256"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"recipient",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"amount",
+ "type":"uint256"
+ }
+ ],
+ "name":"transfer",
+ "outputs":[
+ {
+ "internalType":"bool",
+ "name":"",
+ "type":"bool"
+ }
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"owner",
+ "type":"address"
+ },
+ {
+ "internalType":"address",
+ "name":"spender",
+ "type":"address"
+ }
+ ],
+ "name":"allowance",
+ "outputs":[
+ {
+ "internalType":"uint256",
+ "name":"",
+ "type":"uint256"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"spender",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"amount",
+ "type":"uint256"
+ }
+ ],
+ "name":"approve",
+ "outputs":[
+ {
+ "internalType":"bool",
+ "name":"",
+ "type":"bool"
+ }
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"sender",
+ "type":"address"
+ },
+ {
+ "internalType":"address",
+ "name":"recipient",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"amount",
+ "type":"uint256"
+ }
+ ],
+ "name":"transferFrom",
+ "outputs":[
+ {
+ "internalType":"bool",
+ "name":"",
+ "type":"bool"
+ }
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"spender",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"addedValue",
+ "type":"uint256"
+ }
+ ],
+ "name":"increaseAllowance",
+ "outputs":[
+ {
+ "internalType":"bool",
+ "name":"",
+ "type":"bool"
+ }
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"spender",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"subtractedValue",
+ "type":"uint256"
+ }
+ ],
+ "name":"decreaseAllowance",
+ "outputs":[
+ {
+ "internalType":"bool",
+ "name":"",
+ "type":"bool"
+ }
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ }
+]
\ No newline at end of file
diff --git a/wallet/src/contract-abis/ERC721.json b/wallet/src/contract-abis/ERC721.json
new file mode 100644
index 000000000..19039c01c
--- /dev/null
+++ b/wallet/src/contract-abis/ERC721.json
@@ -0,0 +1,362 @@
+[
+ {
+ "inputs":[
+ {
+ "internalType":"string",
+ "name":"name_",
+ "type":"string"
+ },
+ {
+ "internalType":"string",
+ "name":"symbol_",
+ "type":"string"
+ }
+ ],
+ "stateMutability":"nonpayable",
+ "type":"constructor"
+ },
+ {
+ "anonymous":false,
+ "inputs":[
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"owner",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"approved",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"uint256",
+ "name":"tokenId",
+ "type":"uint256"
+ }
+ ],
+ "name":"Approval",
+ "type":"event"
+ },
+ {
+ "anonymous":false,
+ "inputs":[
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"owner",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"operator",
+ "type":"address"
+ },
+ {
+ "indexed":false,
+ "internalType":"bool",
+ "name":"approved",
+ "type":"bool"
+ }
+ ],
+ "name":"ApprovalForAll",
+ "type":"event"
+ },
+ {
+ "anonymous":false,
+ "inputs":[
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"from",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "indexed":true,
+ "internalType":"uint256",
+ "name":"tokenId",
+ "type":"uint256"
+ }
+ ],
+ "name":"Transfer",
+ "type":"event"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"bytes4",
+ "name":"interfaceId",
+ "type":"bytes4"
+ }
+ ],
+ "name":"supportsInterface",
+ "outputs":[
+ {
+ "internalType":"bool",
+ "name":"",
+ "type":"bool"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"owner",
+ "type":"address"
+ }
+ ],
+ "name":"balanceOf",
+ "outputs":[
+ {
+ "internalType":"uint256",
+ "name":"",
+ "type":"uint256"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"uint256",
+ "name":"tokenId",
+ "type":"uint256"
+ }
+ ],
+ "name":"ownerOf",
+ "outputs":[
+ {
+ "internalType":"address",
+ "name":"",
+ "type":"address"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+
+ ],
+ "name":"name",
+ "outputs":[
+ {
+ "internalType":"string",
+ "name":"",
+ "type":"string"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+
+ ],
+ "name":"symbol",
+ "outputs":[
+ {
+ "internalType":"string",
+ "name":"",
+ "type":"string"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"uint256",
+ "name":"tokenId",
+ "type":"uint256"
+ }
+ ],
+ "name":"tokenURI",
+ "outputs":[
+ {
+ "internalType":"string",
+ "name":"",
+ "type":"string"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"tokenId",
+ "type":"uint256"
+ }
+ ],
+ "name":"approve",
+ "outputs":[
+
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"uint256",
+ "name":"tokenId",
+ "type":"uint256"
+ }
+ ],
+ "name":"getApproved",
+ "outputs":[
+ {
+ "internalType":"address",
+ "name":"",
+ "type":"address"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"operator",
+ "type":"address"
+ },
+ {
+ "internalType":"bool",
+ "name":"approved",
+ "type":"bool"
+ }
+ ],
+ "name":"setApprovalForAll",
+ "outputs":[
+
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"owner",
+ "type":"address"
+ },
+ {
+ "internalType":"address",
+ "name":"operator",
+ "type":"address"
+ }
+ ],
+ "name":"isApprovedForAll",
+ "outputs":[
+ {
+ "internalType":"bool",
+ "name":"",
+ "type":"bool"
+ }
+ ],
+ "stateMutability":"view",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"from",
+ "type":"address"
+ },
+ {
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"tokenId",
+ "type":"uint256"
+ }
+ ],
+ "name":"transferFrom",
+ "outputs":[
+
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"from",
+ "type":"address"
+ },
+ {
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"tokenId",
+ "type":"uint256"
+ }
+ ],
+ "name":"safeTransferFrom",
+ "outputs":[
+
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ },
+ {
+ "inputs":[
+ {
+ "internalType":"address",
+ "name":"from",
+ "type":"address"
+ },
+ {
+ "internalType":"address",
+ "name":"to",
+ "type":"address"
+ },
+ {
+ "internalType":"uint256",
+ "name":"tokenId",
+ "type":"uint256"
+ },
+ {
+ "internalType":"bytes",
+ "name":"_data",
+ "type":"bytes"
+ }
+ ],
+ "name":"safeTransferFrom",
+ "outputs":[
+
+ ],
+ "stateMutability":"nonpayable",
+ "type":"function"
+ }
+]
\ No newline at end of file
diff --git a/wallet/src/contract-abis/Shield.json b/wallet/src/contract-abis/Shield.json
new file mode 100644
index 000000000..25c3d22d4
--- /dev/null
+++ b/wallet/src/contract-abis/Shield.json
@@ -0,0 +1,1054 @@
+[
+ {
+ "anonymous": false,
+ "inputs": [],
+ "name": "BlockProposed",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": false,
+ "internalType": "bytes32",
+ "name": "commitHash",
+ "type": "bytes32"
+ },
+ {
+ "indexed": false,
+ "internalType": "address",
+ "name": "sender",
+ "type": "address"
+ }
+ ],
+ "name": "CommittedToChallenge",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": false,
+ "internalType": "bytes32",
+ "name": "withdrawTransactionHash",
+ "type": "bytes32"
+ },
+ {
+ "indexed": false,
+ "internalType": "address",
+ "name": "paidBy",
+ "type": "address"
+ },
+ {
+ "indexed": false,
+ "internalType": "uint256",
+ "name": "amount",
+ "type": "uint256"
+ }
+ ],
+ "name": "InstantWithdrawalRequested",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": false,
+ "internalType": "address",
+ "name": "proposer",
+ "type": "address"
+ }
+ ],
+ "name": "NewCurrentProposer",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": false,
+ "internalType": "uint256",
+ "name": "leafIndex",
+ "type": "uint256"
+ },
+ {
+ "indexed": false,
+ "internalType": "bytes32",
+ "name": "leafValue",
+ "type": "bytes32"
+ },
+ {
+ "indexed": false,
+ "internalType": "bytes32",
+ "name": "root",
+ "type": "bytes32"
+ }
+ ],
+ "name": "NewLeaf",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": false,
+ "internalType": "uint256",
+ "name": "minLeafIndex",
+ "type": "uint256"
+ },
+ {
+ "indexed": false,
+ "internalType": "bytes32[]",
+ "name": "leafValues",
+ "type": "bytes32[]"
+ },
+ {
+ "indexed": false,
+ "internalType": "bytes32",
+ "name": "root",
+ "type": "bytes32"
+ }
+ ],
+ "name": "NewLeaves",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": false,
+ "internalType": "address",
+ "name": "previousOwner",
+ "type": "address"
+ },
+ {
+ "indexed": false,
+ "internalType": "address",
+ "name": "newOwner",
+ "type": "address"
+ }
+ ],
+ "name": "OwnershipTransferred",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": true,
+ "internalType": "bytes32",
+ "name": "blockHash",
+ "type": "bytes32"
+ },
+ {
+ "indexed": false,
+ "internalType": "uint256",
+ "name": "blockNumberL2",
+ "type": "uint256"
+ },
+ {
+ "indexed": false,
+ "internalType": "uint256",
+ "name": "leafCount",
+ "type": "uint256"
+ }
+ ],
+ "name": "Rollback",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [],
+ "name": "TransactionSubmitted",
+ "type": "event"
+ },
+ {
+ "anonymous": false,
+ "inputs": [
+ {
+ "indexed": false,
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "txType",
+ "type": "uint8"
+ }
+ ],
+ "name": "VkChanged",
+ "type": "event"
+ },
+ {
+ "inputs": [],
+ "name": "_owner",
+ "outputs": [
+ {
+ "internalType": "address",
+ "name": "",
+ "type": "address"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "bytes32",
+ "name": "",
+ "type": "bytes32"
+ }
+ ],
+ "name": "advancedFeeWithdrawals",
+ "outputs": [
+ {
+ "internalType": "uint256",
+ "name": "",
+ "type": "uint256"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "bytes32",
+ "name": "",
+ "type": "bytes32"
+ }
+ ],
+ "name": "advancedWithdrawals",
+ "outputs": [
+ {
+ "internalType": "address",
+ "name": "",
+ "type": "address"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "bytes32",
+ "name": "",
+ "type": "bytes32"
+ }
+ ],
+ "name": "feeBook",
+ "outputs": [
+ {
+ "internalType": "uint256",
+ "name": "",
+ "type": "uint256"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "txType",
+ "type": "uint8"
+ }
+ ],
+ "name": "getVerificationKey",
+ "outputs": [
+ {
+ "internalType": "uint256[]",
+ "name": "",
+ "type": "uint256[]"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [],
+ "name": "owner",
+ "outputs": [
+ {
+ "internalType": "address",
+ "name": "",
+ "type": "address"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "uint256[]",
+ "name": "_vk",
+ "type": "uint256[]"
+ },
+ {
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "_txType",
+ "type": "uint8"
+ }
+ ],
+ "name": "registerVerificationKey",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "address payable",
+ "name": "stateAddress",
+ "type": "address"
+ }
+ ],
+ "name": "setStateContract",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [],
+ "name": "state",
+ "outputs": [
+ {
+ "internalType": "contract State",
+ "name": "",
+ "type": "address"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "address",
+ "name": "newOwner",
+ "type": "address"
+ }
+ ],
+ "name": "transferOwnership",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "",
+ "type": "uint8"
+ },
+ {
+ "internalType": "uint256",
+ "name": "",
+ "type": "uint256"
+ }
+ ],
+ "name": "vks",
+ "outputs": [
+ {
+ "internalType": "uint256",
+ "name": "",
+ "type": "uint256"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "bytes32",
+ "name": "",
+ "type": "bytes32"
+ }
+ ],
+ "name": "withdrawn",
+ "outputs": [
+ {
+ "internalType": "bool",
+ "name": "",
+ "type": "bool"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [
+ {
+ "components": [
+ {
+ "internalType": "uint64",
+ "name": "value",
+ "type": "uint64"
+ },
+ {
+ "internalType": "uint64[2]",
+ "name": "historicRootBlockNumberL2",
+ "type": "uint64[2]"
+ },
+ {
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "transactionType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "enum Structures.TokenType",
+ "name": "tokenType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "tokenId",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "ercAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "recipientAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "commitments",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "nullifiers",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[8]",
+ "name": "compressedSecrets",
+ "type": "bytes32[8]"
+ },
+ {
+ "internalType": "uint256[4]",
+ "name": "proof",
+ "type": "uint256[4]"
+ }
+ ],
+ "internalType": "struct Structures.Transaction",
+ "name": "t",
+ "type": "tuple"
+ }
+ ],
+ "name": "submitTransaction",
+ "outputs": [],
+ "stateMutability": "payable",
+ "type": "function",
+ "payable": true
+ },
+ {
+ "inputs": [
+ {
+ "components": [
+ {
+ "internalType": "uint48",
+ "name": "leafCount",
+ "type": "uint48"
+ },
+ {
+ "internalType": "address",
+ "name": "proposer",
+ "type": "address"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "root",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "uint256",
+ "name": "blockNumberL2",
+ "type": "uint256"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "previousBlockHash",
+ "type": "bytes32"
+ }
+ ],
+ "internalType": "struct Structures.Block",
+ "name": "b",
+ "type": "tuple"
+ },
+ {
+ "internalType": "uint256",
+ "name": "blockNumberL2",
+ "type": "uint256"
+ },
+ {
+ "components": [
+ {
+ "internalType": "uint64",
+ "name": "value",
+ "type": "uint64"
+ },
+ {
+ "internalType": "uint64[2]",
+ "name": "historicRootBlockNumberL2",
+ "type": "uint64[2]"
+ },
+ {
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "transactionType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "enum Structures.TokenType",
+ "name": "tokenType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "tokenId",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "ercAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "recipientAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "commitments",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "nullifiers",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[8]",
+ "name": "compressedSecrets",
+ "type": "bytes32[8]"
+ },
+ {
+ "internalType": "uint256[4]",
+ "name": "proof",
+ "type": "uint256[4]"
+ }
+ ],
+ "internalType": "struct Structures.Transaction[]",
+ "name": "ts",
+ "type": "tuple[]"
+ }
+ ],
+ "name": "requestBlockPayment",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "address",
+ "name": "",
+ "type": "address"
+ },
+ {
+ "internalType": "address",
+ "name": "_from",
+ "type": "address"
+ },
+ {
+ "internalType": "uint256",
+ "name": "_tokenId",
+ "type": "uint256"
+ },
+ {
+ "internalType": "bytes",
+ "name": "",
+ "type": "bytes"
+ }
+ ],
+ "name": "onERC721Received",
+ "outputs": [
+ {
+ "internalType": "bytes4",
+ "name": "",
+ "type": "bytes4"
+ }
+ ],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "internalType": "address",
+ "name": "_operator",
+ "type": "address"
+ },
+ {
+ "internalType": "address",
+ "name": "_from",
+ "type": "address"
+ },
+ {
+ "internalType": "uint256",
+ "name": "_id",
+ "type": "uint256"
+ },
+ {
+ "internalType": "uint256",
+ "name": "_value",
+ "type": "uint256"
+ },
+ {
+ "internalType": "bytes",
+ "name": "_data",
+ "type": "bytes"
+ }
+ ],
+ "name": "onERC1155Received",
+ "outputs": [
+ {
+ "internalType": "bytes4",
+ "name": "",
+ "type": "bytes4"
+ }
+ ],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "components": [
+ {
+ "internalType": "uint48",
+ "name": "leafCount",
+ "type": "uint48"
+ },
+ {
+ "internalType": "address",
+ "name": "proposer",
+ "type": "address"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "root",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "uint256",
+ "name": "blockNumberL2",
+ "type": "uint256"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "previousBlockHash",
+ "type": "bytes32"
+ }
+ ],
+ "internalType": "struct Structures.Block",
+ "name": "b",
+ "type": "tuple"
+ },
+ {
+ "internalType": "uint256",
+ "name": "blockNumberL2",
+ "type": "uint256"
+ },
+ {
+ "components": [
+ {
+ "internalType": "uint64",
+ "name": "value",
+ "type": "uint64"
+ },
+ {
+ "internalType": "uint64[2]",
+ "name": "historicRootBlockNumberL2",
+ "type": "uint64[2]"
+ },
+ {
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "transactionType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "enum Structures.TokenType",
+ "name": "tokenType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "tokenId",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "ercAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "recipientAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "commitments",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "nullifiers",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[8]",
+ "name": "compressedSecrets",
+ "type": "bytes32[8]"
+ },
+ {
+ "internalType": "uint256[4]",
+ "name": "proof",
+ "type": "uint256[4]"
+ }
+ ],
+ "internalType": "struct Structures.Transaction[]",
+ "name": "ts",
+ "type": "tuple[]"
+ },
+ {
+ "internalType": "uint256",
+ "name": "index",
+ "type": "uint256"
+ }
+ ],
+ "name": "isValidWithdrawal",
+ "outputs": [
+ {
+ "internalType": "bool",
+ "name": "",
+ "type": "bool"
+ }
+ ],
+ "stateMutability": "view",
+ "type": "function",
+ "constant": true
+ },
+ {
+ "inputs": [
+ {
+ "components": [
+ {
+ "internalType": "uint48",
+ "name": "leafCount",
+ "type": "uint48"
+ },
+ {
+ "internalType": "address",
+ "name": "proposer",
+ "type": "address"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "root",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "uint256",
+ "name": "blockNumberL2",
+ "type": "uint256"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "previousBlockHash",
+ "type": "bytes32"
+ }
+ ],
+ "internalType": "struct Structures.Block",
+ "name": "b",
+ "type": "tuple"
+ },
+ {
+ "internalType": "uint256",
+ "name": "blockNumberL2",
+ "type": "uint256"
+ },
+ {
+ "components": [
+ {
+ "internalType": "uint64",
+ "name": "value",
+ "type": "uint64"
+ },
+ {
+ "internalType": "uint64[2]",
+ "name": "historicRootBlockNumberL2",
+ "type": "uint64[2]"
+ },
+ {
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "transactionType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "enum Structures.TokenType",
+ "name": "tokenType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "tokenId",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "ercAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "recipientAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "commitments",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "nullifiers",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[8]",
+ "name": "compressedSecrets",
+ "type": "bytes32[8]"
+ },
+ {
+ "internalType": "uint256[4]",
+ "name": "proof",
+ "type": "uint256[4]"
+ }
+ ],
+ "internalType": "struct Structures.Transaction[]",
+ "name": "ts",
+ "type": "tuple[]"
+ },
+ {
+ "internalType": "uint256",
+ "name": "index",
+ "type": "uint256"
+ }
+ ],
+ "name": "finaliseWithdrawal",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "components": [
+ {
+ "internalType": "uint64",
+ "name": "value",
+ "type": "uint64"
+ },
+ {
+ "internalType": "uint64[2]",
+ "name": "historicRootBlockNumberL2",
+ "type": "uint64[2]"
+ },
+ {
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "transactionType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "enum Structures.TokenType",
+ "name": "tokenType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "tokenId",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "ercAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "recipientAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "commitments",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "nullifiers",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[8]",
+ "name": "compressedSecrets",
+ "type": "bytes32[8]"
+ },
+ {
+ "internalType": "uint256[4]",
+ "name": "proof",
+ "type": "uint256[4]"
+ }
+ ],
+ "internalType": "struct Structures.Transaction",
+ "name": "withdrawTransaction",
+ "type": "tuple"
+ }
+ ],
+ "name": "advanceWithdrawal",
+ "outputs": [],
+ "stateMutability": "nonpayable",
+ "type": "function"
+ },
+ {
+ "inputs": [
+ {
+ "components": [
+ {
+ "internalType": "uint48",
+ "name": "leafCount",
+ "type": "uint48"
+ },
+ {
+ "internalType": "address",
+ "name": "proposer",
+ "type": "address"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "root",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "uint256",
+ "name": "blockNumberL2",
+ "type": "uint256"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "previousBlockHash",
+ "type": "bytes32"
+ }
+ ],
+ "internalType": "struct Structures.Block",
+ "name": "b",
+ "type": "tuple"
+ },
+ {
+ "internalType": "uint256",
+ "name": "blockNumberL2",
+ "type": "uint256"
+ },
+ {
+ "components": [
+ {
+ "internalType": "uint64",
+ "name": "value",
+ "type": "uint64"
+ },
+ {
+ "internalType": "uint64[2]",
+ "name": "historicRootBlockNumberL2",
+ "type": "uint64[2]"
+ },
+ {
+ "internalType": "enum Structures.TransactionTypes",
+ "name": "transactionType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "enum Structures.TokenType",
+ "name": "tokenType",
+ "type": "uint8"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "tokenId",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "ercAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32",
+ "name": "recipientAddress",
+ "type": "bytes32"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "commitments",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[2]",
+ "name": "nullifiers",
+ "type": "bytes32[2]"
+ },
+ {
+ "internalType": "bytes32[8]",
+ "name": "compressedSecrets",
+ "type": "bytes32[8]"
+ },
+ {
+ "internalType": "uint256[4]",
+ "name": "proof",
+ "type": "uint256[4]"
+ }
+ ],
+ "internalType": "struct Structures.Transaction[]",
+ "name": "ts",
+ "type": "tuple[]"
+ },
+ {
+ "internalType": "uint256",
+ "name": "index",
+ "type": "uint256"
+ }
+ ],
+ "name": "setAdvanceWithdrawalFee",
+ "outputs": [],
+ "stateMutability": "payable",
+ "type": "function",
+ "payable": true
+ }
+]
diff --git a/wallet/src/contract-abis/index.js b/wallet/src/contract-abis/index.js
new file mode 100644
index 000000000..96635c270
--- /dev/null
+++ b/wallet/src/contract-abis/index.js
@@ -0,0 +1,14 @@
+import Shield from './Shield.json';
+import ERC1155 from './ERC1155.json';
+import ERC165 from './ERC165.json';
+import ERC20 from './ERC20.json';
+import ERC721 from './ERC721.json';
+
+// ignore unused exports default
+export default {
+ Shield,
+ ERC1155,
+ ERC165,
+ ERC20,
+ ERC721,
+};
diff --git a/wallet/src/custom.d.ts b/wallet/src/custom.d.ts
new file mode 100644
index 000000000..2cb95817d
--- /dev/null
+++ b/wallet/src/custom.d.ts
@@ -0,0 +1,4 @@
+declare module "*.svg";
+declare module "*.png";
+declare module '*.scss';
+declare module '*.sass';
\ No newline at end of file
diff --git a/wallet/src/hooks/User/index.jsx b/wallet/src/hooks/User/index.jsx
new file mode 100644
index 000000000..75902933d
--- /dev/null
+++ b/wallet/src/hooks/User/index.jsx
@@ -0,0 +1,141 @@
+import React from 'react';
+import jsSha3 from 'js-sha3';
+import { useLocation } from 'react-router-dom';
+
+import Web3 from '../../common-files/utils/web3';
+import { METAMASK_MESSAGE, DEFAULT_NF_ADDRESS_INDEX } from '../../constants';
+import * as Storage from '../../utils/lib/local-storage';
+import { generateKeys } from '../../nightfall-browser/services/keys';
+import blockProposedEventHandler from '../../nightfall-browser/event-handlers/block-proposed';
+import { getMaxBlock } from '../../nightfall-browser/services/database';
+
+const { eventWsUrl } = global.config;
+
+export const initialState = {
+ active: false,
+ zkpKeys: {
+ pkd: '',
+ nsk: '',
+ ask: '',
+ },
+};
+
+export const UserContext = React.createContext({
+ state: initialState,
+});
+
+// eslint-disable-next-line react/prop-types
+export const UserProvider = ({ children }) => {
+ // const [state, dispatch] = React.useReducer(reducer, initialState);
+ const [state, setState] = React.useState(initialState);
+ const [isSyncComplete, setIsSyncComplete] = React.useState(false);
+ const location = useLocation();
+ // const [isRoot, setIsRoot] = React.useState(location.pathname === '/');
+
+ const configureMnemonic = async mnemonic => {
+ const signature = await Web3.signMessage(METAMASK_MESSAGE);
+ const passphrase = jsSha3.keccak256(signature);
+ Storage.mnemonicSet(await Web3.getAccount(), mnemonic, passphrase);
+ setState(previousState => {
+ return {
+ ...previousState,
+ mnemonic,
+ };
+ });
+ };
+
+ const syncState = async () => {
+ const mnemonicExists = Storage.mnemonicGet(await Web3.getAccount());
+ if (mnemonicExists) {
+ const signature = await Web3.signMessage(METAMASK_MESSAGE);
+ const passphrase = jsSha3.keccak256(signature);
+ const mnemonic = Storage.mnemonicGet(await Web3.getAccount(), passphrase);
+ setState(previousState => {
+ return {
+ ...previousState,
+ mnemonic,
+ };
+ });
+ }
+ };
+
+ const setupWebSocket = () => {
+ if (!state.zkpKeys) return;
+ const socket = new WebSocket(eventWsUrl);
+
+ // Connection opened
+ socket.addEventListener('open', async function () {
+ console.log(`Websocket is open`);
+ const lastBlock = (await getMaxBlock()) ?? -1;
+ console.log('LastBlock', lastBlock);
+ socket.send(JSON.stringify({ type: 'sync', lastBlock }));
+ });
+
+ // Listen for messages
+ socket.addEventListener('message', async function (event) {
+ console.log('Message from server ', JSON.parse(event.data));
+ const parsed = JSON.parse(event.data);
+ if (parsed.type === 'sync') {
+ parsed.historicalData
+ .sort((a, b) => a.blockNumberL2 - b.blockNumberL2)
+ .reduce(async (acc, curr) => {
+ console.log('State', state.zkpKeys.ivk);
+ await acc; // Acc is a promise so we await it before processing the next one;
+ return blockProposedEventHandler(curr, [state.zkpKeys.ivk], [state.zkpKeys.nsk]); // TODO Should be array
+ }, Promise.resolve());
+ } else if (parsed.type === 'blockProposed') await blockProposedEventHandler(parsed.data, state.zkpKeys.ivk, state.zkpKeys.nsk);
+ // TODO Rollback Handler
+ });
+ setState(previousState => {
+ return {
+ ...previousState,
+ socket,
+ };
+ });
+ };
+
+ const configureZkpKeys = async mnemonic => {
+ if (!mnemonic) return;
+ const zkpKeys = await generateKeys(
+ mnemonic,
+ `m/44'/60'/0'/${DEFAULT_NF_ADDRESS_INDEX.toString()}`,
+ );
+
+ // Save Pkd
+ Storage.pkdSet(await Web3.getAccount(), zkpKeys.compressedPkd);
+ setState(previousState => {
+ return {
+ ...previousState,
+ zkpKeys,
+ };
+ });
+ };
+
+ React.useEffect(async () => {
+ if (location.pathname !== '/' && !state.mnemonic) {
+ await syncState();
+ }
+ if (!isSyncComplete) setIsSyncComplete({ isSyncComplete: true });
+ }, [location]);
+
+ React.useEffect(() => {
+ setupWebSocket();
+ }, [state.zkpKeys]);
+
+ React.useEffect(() => {
+ configureZkpKeys(state.mnemonic);
+ }, [state.mnemonic]);
+
+ /*
+ * TODO: children should render when sync is complete
+ * like implement a loader till sync is not complete
+ * for example with blank page:
+ * '{isSyncComplete || true ? children :
+
+
+
+
+
+
+ {/* */}
+ {/*
*/}
+
+
+ All Transactions
+
+
+
+ Today
+
*/}
+ {/*
+ {txs.map(tx => (
+
+
+ ))}
+
+
+ {/*
+
+ {/* Details */}
+
+
+ {/* tx-type-time */}
+
+ {txTypeOptions[tx.txType]}
+ {/* tx-type-time-type */}
+
+ {/* tx-type-time-time */}
+ {displayTime(tx.createdTime, tx.now)}
+
+
+ {/* tx-status-hash */}
+ {/*
+ 1/3 • Action Required • From Mumbai to Goerli
*/}
+
+ {tx.isOnChain >= 0 ? 'Confirmed' : 'Pending'} • {txTypeDest[tx.txType]}
+
+
+ {/* details-section */}
+
+
+ {/* token-image */}
+ 
+
+
+ {/* amount-details */}
+
+
+ {tx.value} MATIC
+
+
+ $x.xx
+
+
+ {/* Transaction Details */}
+
+
+ {/* Transaction Hash label */}
+ Transaction Hash
+
+
+ {/* Tooltip */}
+
+
+ {tx.truncTransactionHash}
+
+ 
+
+ Signing to MetaMask
}'
+ * instead of '{children}'
+ */
+ return (
+
-
- Web3 connection is pending
;
+ * '{isWeb3Connected ?
+
+ );
+};
+
+export default Bridge;
diff --git a/wallet/src/views/initialPage/index.jsx b/wallet/src/views/initialPage/index.jsx
new file mode 100644
index 000000000..b4fbe8c6b
--- /dev/null
+++ b/wallet/src/views/initialPage/index.jsx
@@ -0,0 +1,107 @@
+import React from 'react';
+import { Link } from 'react-router-dom';
+
+import polyBridge from '../../static/img/homepage/poly-bridge.png';
+import polyStaking from '../../static/img/homepage/poly-staking.png';
+import polyWallet from '../../static/img/homepage/poly-wallet.png';
+import polyWidgetDashboard from '../../static/img/homepage/poly-widget-dashboard.png';
+
+import './initial.scss';
+
+// fix: problems with page redirect and images presentation
+
+// I changed all the names of the mainpage images for camelCase. Imported each one with the same name. And in the list of options
+// to be presented in the cards of the mainpage I changed the imageName attribute to be equal of the name of the png image. So at the moment
+// of present the image I doing some conditionals to present the correct image based on the imageName.
+
+// About problem with redirection. I added the exec tag in the '/' route. This way the pege only be redirect to the main page if the path
+// was exactly '/'.
+const cardsData = [
+ {
+ imageName: 'poly-wallet',
+ title: 'Polygon Wallet',
+ desc: 'Send and receive crypto assets on Polygon network',
+ route: 'wallet',
+ },
+ {
+ imageName: 'poly-bridge',
+ title: 'Polygon Bridge',
+ desc: 'Deposit and withdraw between networks',
+ route: 'bridge',
+ },
+ {
+ imageName: 'poly-wallet',
+ title: 'Polygon Nightfall Wallet',
+ desc: 'Privately send and receive crypto assets on Ethereum',
+ route: 'walletNF3',
+ },
+ {
+ imageName: 'poly-staking',
+ title: 'Polygon Staking',
+ desc: 'Stake MATIC to earn rewards',
+ route: 'staking',
+ tag: 'Live on ETHEREUM chain',
+ },
+ {
+ imageName: 'poly-widget-dashboard',
+ title: 'Widget Dashboard',
+ desc: 'Manage all your Polygon wallet widgets at one place',
+ route: 'widget-dashboard',
+ tag: 'Supported only on desktop',
+ },
+];
+
+// src={require('../static/img/homepage/poly-bridge.png')}
+export default function MainPage() {
+ return (
+
+
+
+
+
+
+
+ {/*
+
+
+
+
+
+
+ Nightfall Bridge
+
+ Safe, fast and private token transfers on Ethereum.
+
+
+ {/* v-tooltip="{
+ content: fastWithdrawInfoMsg,
+ placement: 'top-center',
+ }"
+ :to="{ name: 'fast-withdraw' }"
+ For link below */}
+
+ Fast Withdraw
+
+ {/* :to="{ name: 'on-ramp' }"
+ For link below */}
+
+ On Ramp Transfers
+
+
+ How it works?
+
+
+ FAQ
+
+
+ User guide
+
+
+
+
+
+
+
+
+
+ );
+}
diff --git a/wallet/src/views/initialPage/initial.scss b/wallet/src/views/initialPage/initial.scss
new file mode 100644
index 000000000..cd2f8201d
--- /dev/null
+++ b/wallet/src/views/initialPage/initial.scss
@@ -0,0 +1,105 @@
+@import '../../assets/css/theme/_theme';
+
+
+a {
+ text-decoration: none;
+ color: inherit;
+}
+a:hover{
+ text-decoration: none;
+}
+
+.homepage {
+ min-height: calc(100vh - #{$navbar-local-height});
+ padding: 44px 0;
+
+ .cards-container {
+ .m-card {
+ height: 350px;
+ width: 306px;
+ background: light-color('700');
+ box-shadow: 0px 24px 50px rgba(0, 0, 0, 0.15);
+ border-radius: 12px;
+ margin: 0 auto 12px auto;
+ padding: 24px 23px;
+
+ @media #{$lg-devices} {
+ margin: 0 12px;
+ }
+
+ .desc {
+ font-size: 14px;
+ font-weight: 400;
+ line-height: 20px;
+ letter-spacing: 0em;
+ }
+
+ &.poly-wallet {
+ img {
+ margin: 24px 0 42px;
+ height: 119px;
+ width: 128px;
+ }
+ }
+ &.poly-bridge {
+ img {
+ margin: 20px 0 38px;
+ height: 128px;
+ width: 119px;
+ }
+ }
+ &.poly-staking {
+ img {
+ margin: 20px 0 38px;
+ height: 128px;
+ width: 89px;
+ }
+ }
+ &.poly-widget-dashboard {
+ display: none;
+
+ @media #{$lg-devices} {
+ display: block;
+ }
+
+ img {
+ margin: 16px 0 32px;
+ height: 140px;
+ width: 150px;
+ }
+
+ .tag {
+ margin-top: 20px !important;
+ }
+ }
+
+ .tag {
+ font-size: 10px;
+ font-weight: 700;
+ letter-spacing: 0.05em;
+ line-height: 16px;
+ text-transform: uppercase;
+ color: primary-color('600');
+ background: primary-color('100');
+ border-radius: 12px;
+ padding: 2px 8px;
+ }
+ }
+ }
+}
+
+.header-h2 {
+ font-weight: bold;
+ font-size: 36px;
+ line-height: 43px;
+ letter-spacing: -0.01em;
+}
+.header-h4 {
+ font-weight: 600;
+ font-size: 18px;
+ line-height: 24px;
+ letter-spacing: -0.01em;
+}
+.text-gray-500 {
+ color: dark-color('500');
+}
\ No newline at end of file
diff --git a/wallet/src/views/login/components/create-wallet.view.jsx b/wallet/src/views/login/components/create-wallet.view.jsx
deleted file mode 100644
index 686c2979a..000000000
--- a/wallet/src/views/login/components/create-wallet.view.jsx
+++ /dev/null
@@ -1,110 +0,0 @@
-import React from 'react';
-import {
- Button,
- Modal,
- Form,
- Icon,
- TextArea,
- Grid,
- Message,
- Divider,
- Checkbox,
-} from 'semantic-ui-react';
-import PropTypes from 'prop-types';
-import { connect } from 'react-redux';
-import { generateMnemonic } from 'bip39';
-
-function CreateWalletModal({ modalEnable, handleClickOnImport, toggleModalEnable }) {
- const [mnemonic, setMnemonic] = React.useState('');
- const [mnemonicBackup, setMnemonicBackup] = React.useState(false);
-
- const disableAll = () => {
- toggleModalEnable();
- setMnemonic('');
- setMnemonicBackup(false);
- };
-
- const handleSubmit = () => {
- disableAll();
- handleClickOnImport(mnemonic, mnemonicBackup);
- };
-
- const newMnemonic = () => {
- setMnemonic(generateMnemonic());
- };
-
- const toggleMnemonicBackupEnable = () => {
- setMnemonicBackup(!mnemonicBackup);
- };
-
- return (
- Getting started with Polygon PoS chain
+
+ The safe, fast, and most secure way to use Polygon PoS.
+
+
+ {cardsData.map((card, index) => (
+
+ {/* TODO fix the .tag and width and height */}
+ 
+
+
+ {card.title}
+
+ {card.desc}
+
+ {card.tag && (
+ //
+
+ {card.tag}
+
+ )}
+
+ ))}
+