contents of zip

scripts/view_proof_builder.js

@@ -0,0 +1,266 @@
+// Use strict
+"use strict";
+
+
+// Classes
+
+// View proof builder class
+class ViewProofBuilder extends ProofBuilder {
+
+	// Public
+	
+		// Initialize
+		initialize(extendedPrivateKeyOrRootPublicKey) {
+		
+			// Set self
+			var self = this;
+		
+			// Return promise
+			return new Promise(function(resolve, reject) {
+			
+				// Check if an extended private key is provided
+				if(extendedPrivateKeyOrRootPublicKey["length"] !== Crypto.SECP256K1_PUBLIC_KEY_LENGTH) {
+				
+					// Get extended private key
+					var extendedPrivateKey = extendedPrivateKeyOrRootPublicKey;
+			
+					// Return getting root public key from extended private key
+					return Crypto.rootPublicKey(extendedPrivateKey).then(function(publicKey) {
+					
+						// Check if getting rewind hash from public key was successful
+						self.rewindHash = Blake2b.compute(Crypto.NONCE_LENGTH, publicKey, new Uint8Array([]));
+						
+						if(self.rewindHash !== Blake2b.OPERATION_FAILED) {
+						
+							// Securely clear public key
+							publicKey.fill(0);
+						
+							// Resolve
+							resolve();
+						}
+						
+						// Otherwise
+						else {
+						
+							// Securely clear public key
+							publicKey.fill(0);
+						
+							// Reject error
+							reject("Getting Rewind hash failed.");
+						}
+					
+					// Catch errors
+					}).catch(function(error) {
+					
+						// Reject error
+						reject(error);
+					});
+				}
+				
+				// Otherwise
+				else {
+				
+					// Get root public key
+					var rootPublicKey = extendedPrivateKeyOrRootPublicKey;
+					
+					// Check if getting rewind hash from root public key was successful
+					self.rewindHash = Blake2b.compute(Crypto.NONCE_LENGTH, rootPublicKey, new Uint8Array([]));
+					
+					if(self.rewindHash !== Blake2b.OPERATION_FAILED) {
+					
+						// Resolve
+						resolve();
+					}
+					
+					// Otherwise
+					else {
+					
+						// Reject error
+						reject("Getting Rewind hash failed.");
+					}
+				}
+			});
+		}
+		
+		// Uninitialize
+		uninitialize() {
+		
+			// Securely clear rewind hash
+			this.rewindHash.fill(0);
+		}
+	
+		// Rewind nonce
+		rewindNonce(commit) {
+		
+			// Set self
+			var self = this;
+		
+			// Return promise
+			return new Promise(function(resolve, reject) {
+		
+				// Check if getting nonce from rewind hash and commit was successful
+				var nonce = Blake2b.compute(Crypto.NONCE_LENGTH, self.rewindHash, commit);
+				
+				if(nonce !== Blake2b.OPERATION_FAILED) {
+				
+					// Check if nonce is a valid secret key
+					if(Secp256k1Zkp.isValidSecretKey(nonce) === true) {
+					
+						// Resolve nonce
+						resolve(nonce);
+					}
+					
+					// Otherwise
+					else {
+					
+						// Securely clear nonce
+						nonce.fill(0);
+					
+						// Reject error
+						reject("Nonce is not a valid secret key.");
+					}
+				}
+				
+				// Otherwise
+				else {
+				
+					// Reject error
+					reject("Getting nonce failed.");
+				}
+			});
+		}
+		
+		// Proof message
+		proofMessage(identifier, switchType) {
+		
+			// Create message
+			var message = new Uint8Array(NewProofBuilder.MESSAGE_LENGTH).fill(0);
+			
+			// Set message's switch type
+			message[NewProofBuilder.MESSAGE_SWITCH_TYPE_INDEX] = switchType;
+			
+			// Set everything after message's switch type to the identifier's value
+			message = Common.mergeArrays([
+			
+				// Message switch type
+				message.subarray(0, NewProofBuilder.MESSAGE_SWITCH_TYPE_INDEX + 1),
+				
+				// Identifier's value
+				identifier.getValue().subarray(0, NewProofBuilder.MESSAGE_LENGTH - (NewProofBuilder.MESSAGE_SWITCH_TYPE_INDEX + 1))
+			]);
+			
+			// Return message
+			return message;
+		}
+		
+		// Get output
+		getOutput(extendedPrivateKeyOrRootPublicKey, amount, commit, message) {
+		
+			// Return promise
+			return new Promise(function(resolve, reject) {
+		
+				// Check if message is valid
+				if(message["length"] === NewProofBuilder.MESSAGE_LENGTH && Common.arraysAreEqual(message.subarray(0, NewProofBuilder.MESSAGE_HEADER_START["length"]), NewProofBuilder.MESSAGE_HEADER_START) === true) {
+								
+					// Get switch type from message
+					var switchType = message[NewProofBuilder.MESSAGE_SWITCH_TYPE_INDEX];
+					
+					// Check if switch type is valid
+					if(switchType === Crypto.SWITCH_TYPE_NONE || switchType === Crypto.SWITCH_TYPE_REGULAR) {
+					
+						// Get depth from message
+						var depth = message[NewProofBuilder.MESSAGE_DEPTH_INDEX];
+						
+						// Try
+						try {
+						
+							// Create identifier from depth and message
+							var identifier = new Identifier(depth.toString(Common.HEX_NUMBER_BASE).padStart(Common.HEX_NUMBER_LENGTH, Common.HEX_NUMBER_PADDING) + Common.toHexString(message.subarray(NewProofBuilder.MESSAGE_HEADER_LENGTH)));
+						}
+						
+						// Catch errors
+						catch(error) {
+						
+							// Reject error
+							reject("Identifier isn't valid.");
+							
+							// Return
+							return;
+						}
+						
+						// Check if an extended private key is provided
+						if(extendedPrivateKeyOrRootPublicKey["length"] !== Crypto.SECP256K1_PUBLIC_KEY_LENGTH) {
+						
+							// Get extended private key
+							var extendedPrivateKey = extendedPrivateKeyOrRootPublicKey;
+						
+							// Return getting commit from extended private key, amount, identifier, and switch type
+							return Crypto.commit(extendedPrivateKey, amount, identifier, switchType).then(function(computedCommit) {
+							
+								// Check if commit matches the computed commit
+								if(Common.arraysAreEqual(commit, computedCommit) === true) {
+								
+									// Resolve output
+									resolve([
+									
+										// Identifier
+										identifier,
+										
+										// Switch type
+										switchType
+									]);
+								}
+								
+								// Otherwise
+								else {
+								
+									// Reject error
+									reject("Output isn't valid.");
+								}
+							
+							// Catch errors
+							}).catch(function(error) {
+							
+								// Reject error
+								reject(error);
+							});
+						}
+						
+						// Otherwise
+						else {
+						
+							// Resolve output
+							resolve([
+							
+								// Identifier
+								identifier,
+								
+								// Switch type
+								switchType
+							]);
+						}
+					}
+					
+					// Otherwise
+					else {
+					
+						// Reject error
+						reject("Switch type isn't valid.");
+					}
+				}
+				
+				// Otherwise
+				else {
+				
+					// Reject error
+					reject("Message isn't valid.");
+				}
+			});
+		}
+}
+
+
+// Main function
+
+// Set global object's view proof builder
+globalThis["ViewProofBuilder"] = ViewProofBuilder;