@@ -677,9 +692,9 @@ const SendModal = (props: SendModalProps): JSX.Element => {
Transaction created sucessfully.
Your transfer is ready to send.
@@ -704,6 +719,28 @@ const SendModal = (props: SendModalProps): JSX.Element => {
)}
+
+ {showModalTransferFailed && (
+
+
+
+ 
+
+
+
+
+
+
+
Failed To Create Transaction.
+ {/*
Please Try Again
*/}
+
+ handleCloseConfirmModal()}>Close
+
+ {/*
View on etherscan */}
+
+ )}
);
diff --git a/wallet/src/nightfall-browser/services/deposit.js b/wallet/src/nightfall-browser/services/deposit.js
index a50e1eee0..4a64219d7 100644
--- a/wallet/src/nightfall-browser/services/deposit.js
+++ b/wallet/src/nightfall-browser/services/deposit.js
@@ -65,35 +65,35 @@ async function deposit(items, shieldContractAddress) {
];
logger.debug(`witness input is ${witnessInput.join(' ')}`);
- const zokratesProvider = await initialize();
- const artifacts = { program: new Uint8Array(program), abi };
- const keypair = { pk: new Uint8Array(pk) };
+ try {
+ const zokratesProvider = await initialize();
+ 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,
- );
+ // 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 {
+ // 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
const rawTransaction = await shieldContractInstance.methods
.submitTransaction(Transaction.buildSolidityStruct(optimisticDepositTransaction))
.encodeABI();
diff --git a/wallet/src/nightfall-browser/services/transfer.js b/wallet/src/nightfall-browser/services/transfer.js
index 5c64a7db9..1ce441cf5 100644
--- a/wallet/src/nightfall-browser/services/transfer.js
+++ b/wallet/src/nightfall-browser/services/transfer.js
@@ -53,194 +53,197 @@ async function transfer(transferParams, shieldContractAddress) {
);
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) {
+ try {
+ // 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
- 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);
- }
+ 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);
+ // 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',
- );
- }
+ 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 => {
- const bin = text.binary.padStart(256, '0');
- const parity = bin[0];
- const ordinate = bin.slice(1);
- const fields = {
- parity: !!Number(parity), // This converts parity into true / false from 1 / 0;
- ordinate: new GN(ordinate, 'binary').field(BN128_GROUP_ORDER),
- };
- return fields;
- }),
- ];
+ // 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 => {
+ const bin = text.binary.padStart(256, '0');
+ const parity = bin[0];
+ const ordinate = bin.slice(1);
+ const fields = {
+ parity: !!Number(parity), // This converts parity into true / false from 1 / 0;
+ ordinate: new GN(ordinate, 'binary').field(BN128_GROUP_ORDER),
+ };
+ return fields;
+ }),
+ ];
- const flattenInput = witnessInput.map(w => {
- if (w.length === 1) {
- const [w_] = w;
- return w_;
- }
- return w;
- });
+ 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 abi;
- let program;
- let pk;
- let transactionType;
- if (oldCommitments.length === 1) {
- transactionType = 1;
- blockNumberL2s.push(0); // We need top pad block numbers if we do a single transfer
- if (!(await checkIndexDBForCircuit(singleTransfer)))
- throw Error('Some circuit data are missing from IndexedDB');
- const [abiData, programData, pkData] = await Promise.all([
- getStoreCircuit(`${singleTransfer}-abi`),
- getStoreCircuit(`${singleTransfer}-program`),
- getStoreCircuit(`${singleTransfer}-pk`),
- ]);
- abi = abiData.data;
- program = programData.data;
- pk = pkData.data;
- } else if (oldCommitments.length === 2) {
- transactionType = 2;
- if (!(await checkIndexDBForCircuit(doubleTransfer)))
- throw Error('Some circuit data are missing from IndexedDB');
- const [abiData, programData, pkData] = await Promise.all([
- getStoreCircuit(`${doubleTransfer}-abi`),
- getStoreCircuit(`${doubleTransfer}-program`),
- getStoreCircuit(`${doubleTransfer}-pk`),
- ]);
- abi = abiData.data;
- program = programData.data;
- pk = pkData.data;
- } else throw new Error('Unsupported number of commitments');
+ 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 abi;
+ let program;
+ let pk;
+ let transactionType;
+ if (oldCommitments.length === 1) {
+ transactionType = 1;
+ blockNumberL2s.push(0); // We need top pad block numbers if we do a single transfer
+ if (!(await checkIndexDBForCircuit(singleTransfer)))
+ throw Error('Some circuit data are missing from IndexedDB');
+ const [abiData, programData, pkData] = await Promise.all([
+ getStoreCircuit(`${singleTransfer}-abi`),
+ getStoreCircuit(`${singleTransfer}-program`),
+ getStoreCircuit(`${singleTransfer}-pk`),
+ ]);
+ abi = abiData.data;
+ program = programData.data;
+ pk = pkData.data;
+ } else if (oldCommitments.length === 2) {
+ transactionType = 2;
+ if (!(await checkIndexDBForCircuit(doubleTransfer)))
+ throw Error('Some circuit data are missing from IndexedDB');
+ const [abiData, programData, pkData] = await Promise.all([
+ getStoreCircuit(`${doubleTransfer}-abi`),
+ getStoreCircuit(`${doubleTransfer}-program`),
+ getStoreCircuit(`${doubleTransfer}-pk`),
+ ]);
+ abi = abiData.data;
+ program = programData.data;
+ pk = pkData.data;
+ } else throw new Error('Unsupported number of commitments');
- const zokratesProvider = await initialize();
- 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 {
+ const zokratesProvider = await initialize();
+ 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,
+ });
// if (offchain) {
// await axios
// .post(
diff --git a/wallet/src/nightfall-browser/services/withdraw.js b/wallet/src/nightfall-browser/services/withdraw.js
index 6f0f05928..dc2f9a5e2 100644
--- a/wallet/src/nightfall-browser/services/withdraw.js
+++ b/wallet/src/nightfall-browser/services/withdraw.js
@@ -55,67 +55,67 @@ async function withdraw(withdrawParams, shieldContractAddress) {
)) || [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(),
- ),
- );
+ try {
+ // 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;
+ // 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(),
- ];
+ // 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 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: withdrawParams.tokenType,
- tokenId,
- value,
- ercAddress,
- recipientAddress,
- nullifiers: [nullifier],
- proof,
- });
- try {
+ logger.debug(`witness input is ${JSON.stringify(witnessInput)}`);
+ // call a zokrates worker to generate the proof
+ const zokratesProvider = await initialize();
+ 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: withdrawParams.tokenType,
+ tokenId,
+ value,
+ ercAddress,
+ recipientAddress,
+ nullifiers: [nullifier],
+ proof,
+ });
const rawTransaction = await shieldContractInstance.methods
.submitTransaction(Transaction.buildSolidityStruct(optimisticWithdrawTransaction))
.encodeABI();