diff --git a/app/.gitignore b/app/.gitignore index 935904a84..e4dd28471 100644 --- a/app/.gitignore +++ b/app/.gitignore @@ -68,3 +68,5 @@ yarn-error.log .env .expo/ + +libuniffi_mopro.so \ No newline at end of file diff --git a/app/App.tsx b/app/App.tsx index 43f77f89d..07ebff485 100644 --- a/app/App.tsx +++ b/app/App.tsx @@ -19,8 +19,8 @@ import { toStandardName } from '../common/src/utils/formatNames'; import { generateCircuitInputs } from '../common/src/utils/generateInputs'; import { AWS_ENDPOINT, TREE_DEPTH } from '../common/src/constants/constants'; import { - formatProofIOS, - formatInputsIOS + formatProof, + formatInputs } from '../common/src/utils/utils'; import { samplePassportData } from '../common/src/utils/passportDataStatic'; import "@ethersproject/shims" @@ -110,11 +110,17 @@ function App(): JSX.Element { }, []); useEffect(() => { - if (Platform.OS !== 'android') { - NativeModules.Prover.runInitAction() // for mopro, ios only rn - } + init() }, []); + async function init() { + await new Promise(resolve => setTimeout(resolve, 2000)); + console.log('launching init') + const res = await NativeModules.Prover.runInitAction() + console.log('init done') + console.log('init res', res) + } + async function handleResponseIOS(response: any) { const parsed = JSON.parse(response); @@ -253,6 +259,7 @@ function App(): JSX.Element { handleResponseAndroid(response); } catch (e: any) { console.log('error during scan :', e); + setStep(Steps.MRZ_SCAN_COMPLETED); Toast.show({ type: 'error', text1: e.message, @@ -288,8 +295,6 @@ function App(): JSX.Element { setGeneratingProof(true) await new Promise(resolve => setTimeout(resolve, 10)); - // TODO check circuit to make sure the proof will work - const reveal_bitmap = revealBitmapFromMapping(disclosure); // if (!["sha256WithRSAEncryption"].includes(passportData.signatureAlgorithm)) { @@ -317,79 +322,59 @@ function App(): JSX.Element { }); const start = Date.now(); - if (Platform.OS === 'android') { - await proveAndroid(inputs, path); - } else { - await proveIOS(inputs); - } + await prove(inputs, path); + const end = Date.now(); console.log('Total proof time from frontend:', end - start); }; - async function proveAndroid(inputs: any, path: string) { - const startTime = Date.now(); - NativeModules.RNPassportReader.provePassport(inputs, path, (err: any, res: any) => { - const endTime = Date.now(); - setProofTime(endTime - startTime); - - if (err) { - console.error(err); - setError( - "err: " + err.toString(), - ); - return - } - console.log("res", res); - const parsedResponse = JSON.parse(res); - console.log('parsedResponse', parsedResponse); - console.log('parsedResponse.duration', parsedResponse.duration); - - const deserializedProof = JSON.parse(parsedResponse.serialized_proof); - console.log('deserializedProof', deserializedProof); - - const deserializedInputs = JSON.parse(parsedResponse.serialized_inputs); - console.log('deserializedInputs', deserializedInputs); - - setProof({ - proof: JSON.stringify(deserializedProof), - inputs: JSON.stringify(deserializedInputs), - }); - setGeneratingProof(false); - setStep(Steps.PROOF_GENERATED); - }); - } - - async function proveIOS(inputs: any) { + async function prove(inputs: any, path?: string) { try { - const startTime = Date.now(); - console.log('running mopro init action') + console.log('launching prove function') + console.log('inputs in App.tsx', inputs) + await NativeModules.Prover.runInitAction() + const startTime = Date.now(); + console.log('running mopro prove action') - const response = await NativeModules.Prover.runProveAction({ - ...inputs, - datahashes_padded_length: [inputs.datahashes_padded_length.toString()], // wrap everything in arrays for bindings - signatureAlgorithm: [inputs.signatureAlgorithm], - root: [inputs.root], - address: [BigInt(address).toString()], - }) + const response = await NativeModules.Prover.runProveAction(inputs) console.log('proof response:', response) - const parsedResponse = JSON.parse(response) + + function parseProofAndroid(response: any) { + const match = response.match(/GenerateProofResult\(proof=\[(.*?)\], inputs=\[(.*?)\]\)/); + if (!match) throw new Error('Invalid input format'); + + return { + proof: match[1].split(',').map((n: any) => (parseInt(n.trim()) + 256) % 256), + inputs: match[2].split(',').map((n: any) => (parseInt(n.trim()) + 256) % 256) + } + } + + const parsedResponse = Platform.OS == 'android' + ? parseProofAndroid(response) + : JSON.parse(response) + + console.log('parsedResponse', parsedResponse) const endTime = Date.now(); setProofTime(endTime - startTime); - // console.log('running mopro verify action') - // const res = await NativeModules.Prover.runVerifyAction() - // console.log('verify response:', res) + console.log('running mopro verify action') + const res = await NativeModules.Prover.runVerifyAction() + console.log('verify response:', res) + + const finalProof = { + proof: JSON.stringify(formatProof(parsedResponse.proof)), + inputs: JSON.stringify(formatInputs(parsedResponse.inputs)), + } + + console.log('finalProof:', finalProof) - setProof({ - proof: JSON.stringify(formatProofIOS(parsedResponse.proof)), - inputs: JSON.stringify(formatInputsIOS(parsedResponse.inputs)), - }); + setProof(finalProof); setGeneratingProof(false) - setStep(Steps.PROOF_GENERATED); + setStep(Steps.PROOF_GENERATED); } catch (err: any) { console.log('err', err); setError( @@ -398,7 +383,6 @@ function App(): JSX.Element { } } - const handleMint = async () => { setMinting(true) if (!proof?.proof || !proof?.inputs) { @@ -413,8 +397,6 @@ function App(): JSX.Element { // Format the proof and publicInputs as calldata for the verifier contract const p = JSON.parse(proof.proof); const i = JSON.parse(proof.inputs); - // const p = {"a": ["16502577771187684977980616374304236605057905196561863637384296592370445017998", "3901861368174142739149849352179287633574688417834634300291202761562972709023"], "b": [["14543689684654938043989715590415160645004827219804187355799512446208262437248", "2758656853017552407340621959452084149765188239766723663849017782705599048610"], ["11277365272183899064677884160333958573750879878546952615484891009952508146334", "6233152645613613236466445508816847016425532566954931368157994995587995754446"]], "c": ["6117026818273543012196632774531089444191538074414171872462281003025766583671", "10261526153619394223629018490329697233150978685332753612996629076672112420472"]} - // const i = ["0", "0", "0", "146183216590389235917737925524385821154", "43653084046336027166990", "21085389953176386480267", "56519161086598100699293", "15779090386165698845937", "23690430366843652392111", "22932463418406768540896", "51019038683800409078189", "50360649287615093470666", "47789371969706091489401", "15311247864741754764238", "20579290199534174842880", "1318168358802144844680228651107716082931624381008"] console.log('p', p); console.log('i', i); const cd = groth16ExportSolidityCallData(p, i); diff --git a/app/android/app/build.gradle b/app/android/app/build.gradle index 580592993..0e2fd541d 100644 --- a/app/android/app/build.gradle +++ b/app/android/app/build.gradle @@ -1,5 +1,7 @@ apply plugin: "com.android.application" apply plugin: "com.facebook.react" +apply plugin: 'kotlin-android' + /** * This is the configuration block to customize your React Native Android app. @@ -122,9 +124,6 @@ dependencies { } implementation project(':passportreader') implementation 'org.jmrtd:jmrtd:0.7.18' - // implementation files('libs/jmrtd-0.5.5.jar') - //implementation 'org.jmrtd:jmrtd:0.7.35' - debugImplementation("com.facebook.flipper:flipper:${FLIPPER_VERSION}") debugImplementation("com.facebook.flipper:flipper-network-plugin:${FLIPPER_VERSION}") { @@ -137,6 +136,10 @@ dependencies { } else { implementation jscFlavor } + implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version" + implementation("net.java.dev.jna:jna:5.13.0@aar") + implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-android' + } apply from: file("../../node_modules/@react-native-community/cli-platform-android/native_modules.gradle"); applyNativeModulesAppBuildGradle(project) diff --git a/app/android/app/src/main/java/com/awesomeproject/MainApplication.java b/app/android/app/src/main/java/com/awesomeproject/MainApplication.java index 9b48547ec..d21e33174 100644 --- a/app/android/app/src/main/java/com/awesomeproject/MainApplication.java +++ b/app/android/app/src/main/java/com/awesomeproject/MainApplication.java @@ -8,9 +8,11 @@ import com.facebook.react.ReactPackage; import com.facebook.react.defaults.DefaultNewArchitectureEntryPoint; import com.facebook.react.defaults.DefaultReactNativeHost; import com.facebook.soloader.SoLoader; -import com.proofofpassport.CameraActivityPackage; //import new package for mrz reading +import com.proofofpassport.CameraActivityPackage; // import new package for mrz reading import io.tradle.nfc.RNPassportReaderPackage; import java.util.List; +import com.proofofpassport.prover.ProverPackage; + public class MainApplication extends Application implements ReactApplication { @@ -29,6 +31,7 @@ public class MainApplication extends Application implements ReactApplication { // Add the custom package here packages.add(new CameraActivityPackage()); + packages.add(new ProverPackage()); return packages; } diff --git a/app/android/app/src/main/java/com/awesomeproject/ProverModule.kt b/app/android/app/src/main/java/com/awesomeproject/ProverModule.kt new file mode 100644 index 000000000..50c7f2fae --- /dev/null +++ b/app/android/app/src/main/java/com/awesomeproject/ProverModule.kt @@ -0,0 +1,130 @@ +package com.proofofpassport.prover + +import com.facebook.react.bridge.ReactApplicationContext +import com.facebook.react.bridge.ReactContextBaseJavaModule +import com.facebook.react.bridge.ReactMethod +import com.facebook.react.bridge.Promise + +import android.util.Log +import com.facebook.react.bridge.ReadableMap +import uniffi.mopro.GenerateProofResult + +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.launch +import kotlinx.coroutines.withContext + +class ProverModule(reactContext: ReactApplicationContext) : ReactContextBaseJavaModule(reactContext) { + private val TAG = "ProverModule" + lateinit var res: GenerateProofResult + + + override fun getName(): String { + return "Prover" + } + + @ReactMethod + fun runInitAction(promise: Promise) { + // Launch a coroutine in the IO dispatcher for background tasks + CoroutineScope(Dispatchers.IO).launch { + try { + val startTime = System.currentTimeMillis() + uniffi.mopro.initializeMopro() + val endTime = System.currentTimeMillis() + val initTime = "init time: " + (endTime - startTime).toString() + " ms" + + // Since the promise needs to be resolved in the main thread + withContext(Dispatchers.Main) { + promise.resolve(initTime) + } + } catch (e: Exception) { + withContext(Dispatchers.Main) { + promise.reject(e) + } + } + } + } + + // @ReactMethod + // fun downloadFile(url: String, fileName: String, promise: Promise) { + // val client = OkHttpClient() + // val request = Request.Builder().url(url).build() + + // try { + // client.newCall(request).execute().use { response -> + // if (!response.isSuccessful) throw IOException("Failed to download file: $response") + + // // Use the app's internal files directory + // val fileOutputStream = reactContext.openFileOutput(fileName, Context.MODE_PRIVATE) + + // val inputStream = response.body?.byteStream() + // inputStream.use { input -> + // fileOutputStream.use { output -> + // input?.copyTo(output) + // } + // } + + // // Resolve the promise with the file path + // val file = File(reactContext.filesDir, fileName) + // promise.resolve(file.absolutePath) + // } + // } catch (e: Exception) { + // // Reject the promise if an exception occurs + // promise.reject(e) + // } + // } + + + @ReactMethod + // fun runProveAction(inputs: ReadableMap, zkeypath: String, promise: Promise) { + fun runProveAction(inputs: ReadableMap, promise: Promise) { + Log.e(TAG, "inputs in provePassport kotlin: " + inputs.toString()) + + // working example + // val inputs = mutableMapOf>( + // "mrz" to listOf("97","91","95","31","88","80","60","70","82","65","84","65","86","69","82","78","73","69","82","60","60","70","76","79","82","69","78","84","60","72","85","71","85","69","83","60","74","69","65","78","60","60","60","60","60","60","60","60","60","49","57","72","65","51","52","56","50","56","52","70","82","65","48","48","48","55","49","57","49","77","50","57","49","50","48","57","53","60","60","60","60","60","60","60","60","60","60","60","60","60","60","48","50"), + // "reveal_bitmap" to listOf("0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0"), + // "dataHashes" to listOf("48","130","1","37","2","1","0","48","11","6","9","96","134","72","1","101","3","4","2","1","48","130","1","17","48","37","2","1","1","4","32","99","19","179","205","55","104","45","214","133","101","233","177","130","1","37","89","125","229","139","34","132","146","28","116","248","186","63","195","96","151","26","215","48","37","2","1","2","4","32","63","234","106","78","31","16","114","137","237","17","92","71","134","47","62","78","189","233","201","213","53","4","47","189","201","133","6","121","34","131","64","142","48","37","2","1","3","4","32","136","155","87","144","121","15","152","127","85","25","154","80","20","58","51","75","193","116","234","0","60","30","29","30","183","141","72","247","255","203","100","124","48","37","2","1","11","4","32","0","194","104","108","237","246","97","230","116","198","69","110","26","87","17","89","110","199","108","250","36","21","39","87","110","102","250","213","174","131","171","174","48","37","2","1","12","4","32","190","82","180","235","222","33","79","50","152","136","142","35","116","224","6","242","156","141","128","247","10","61","98","86","248","45","207","210","90","232","175","38","48","37","2","1","13","4","32","91","222","210","193","63","222","104","82","36","41","138","253","70","15","148","208","156","45","105","171","241","195","185","43","217","162","146","201","222","89","238","38","48","37","2","1","14","4","32","76","123","216","13","52","227","72","245","59","193","238","166","103","49","24","164","171","188","194","197","156","187","249","28","198","95","69","15","182","56","54","38","128","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","0","9","72"), + // "datahashes_padded_length" to listOf("320"), + // "eContentBytes" to listOf("49","102","48","21","6","9","42","134","72","134","247","13","1","9","3","49","8","6","6","103","129","8","1","1","1","48","28","6","9","42","134","72","134","247","13","1","9","5","49","15","23","13","49","57","49","50","49","54","49","55","50","50","51","56","90","48","47","6","9","42","134","72","134","247","13","1","9","4","49","34","4","32","176","96","59","213","131","82","89","248","105","125","37","177","158","162","137","43","13","39","115","6","59","229","81","110","49","75","255","184","155","73","116","86"), + // "signature" to listOf("1004979219314799894","6361443755252600907","6439012883494616023","9400879716815088139","17551897985575934811","11779273958797828281","2536315921873401485","3748173260178203981","12475215309213288577","6281117468118442715","1336292932993922350","14238156234566069988","11985045093510507012","3585865343992378960","16170829868787473084","17039645001628184779","486540501180074772","5061439412388381188","12478821212163933993","7430448406248319432","746345521572597865","5002454658692185142","3715069341922830389","11010599232161942094","1577500614971981868","13656226284809645063","3918261659477120323","5578832687955645075","3416933977282345392","15829829506526117610","17465616637242519010","6519177967447716150"), + // "signatureAlgorithm" to listOf("1"), + // "pubkey" to listOf("9539992759301679521","1652651398804391575","7756096264856639170","15028348881266521487","13451582891670014060","11697656644529425980","14590137142310897374","1172377360308996086","6389592621616098288","6767780215543232436","11347756978427069433","2593119277386338350","18385617576997885505","14960211320702750252","8706817324429498800","15168543370367053559","8708916123725550363","18006178692029805686","6398208271038376723","15000821494077560096","17674982305626887153","2867958270953137726","9287774520059158342","9813100051910281130","13494313215150203208","7792741716144106392","6553490305289731807","32268224696386820","15737886769048580611","669518601007982974","11424760966478363403","16073833083611347461"), + // "pathIndices" to listOf("0","1","1","1","1","1","1","0","1","1","0","0","1","1","0","0"), + // "siblings" to listOf("20516282398390866580647417962347415258712802604212003365416596890852644939364","20547289806543281108128197867250295423223489766069952889766689677695750842294","17092860852967512812593771487649838995106203215624858397482169733546970246117","19141872343555753276227561835732941623954902346285308564941039231845690663515","2888260764701592030713638283446165050628606750519377550369633789586724212406","17037943129534065359096662792322618985598809624384219749636863003643326502177","21260541151470016589788332273091943678373855676584683193443363340566713593750","9681119423869145671286918102040570804786474221694907866875171055859965502010","3999714159260652982057321310481110903729446356195536109316994934664982988519","14359042263488593594514913785064471775842285148703143594475594381078274944550","10696856845043652409316424831381338144209147199074363427177722046972515079299","2796323689030312622891330190155708704921773618732461037692992858528069077360","1379184643939692456020535864077563679018059205165852146212742699309755722087","17834317267514482863629341626611816587254867008433493508231639322166589549456","1473918712602583605383280948484316645101117513102582419100942131704211814519","15819538789928229930262697811477882737253464456578333862691129291651619515538"), + // "root" to listOf("4080578225172475068086778061870548445929343471785864518431540330127324371840"), + // "address" to listOf("642829559307850963015472508762062935916233390536") + // ) + + val convertedInputs = mutableMapOf>() + + for ((key, value) in inputs.toHashMap()) { + val parsedArray = inputs.getArray(key)?.toArrayList()?.map { item -> + item.toString() + } ?: emptyList() + convertedInputs[key] = parsedArray + } + + Log.e(TAG, "convertedInputs: $convertedInputs") + + val startTime = System.currentTimeMillis() + res = uniffi.mopro.generateProof2(convertedInputs) + val endTime = System.currentTimeMillis() + val provingTime = "proving time: " + (endTime - startTime).toString() + " ms" + Log.e(TAG, provingTime) + + Log.e(TAG, "res: " + res.toString()) + + promise.resolve(res.toString()) + } + + @ReactMethod + fun runVerifyAction(promise: Promise) { + val startTime = System.currentTimeMillis() + val valid = "valid: " + uniffi.mopro.verifyProof2(res.proof, res.inputs).toString() + val endTime = System.currentTimeMillis() + val verifyingTime = "verifying time: " + (endTime - startTime).toString() + " ms" + Log.e(TAG, verifyingTime) + promise.resolve(valid) + } +} diff --git a/app/android/app/src/main/java/com/awesomeproject/ProverPackage.kt b/app/android/app/src/main/java/com/awesomeproject/ProverPackage.kt new file mode 100644 index 000000000..3ff8c6e5f --- /dev/null +++ b/app/android/app/src/main/java/com/awesomeproject/ProverPackage.kt @@ -0,0 +1,16 @@ +package com.proofofpassport.prover + +import com.facebook.react.ReactPackage +import com.facebook.react.bridge.NativeModule +import com.facebook.react.bridge.ReactApplicationContext +import com.facebook.react.uimanager.ViewManager + +class ProverPackage : ReactPackage { + override fun createNativeModules(reactContext: ReactApplicationContext): List { + return listOf(ProverModule(reactContext)) + } + + override fun createViewManagers(reactContext: ReactApplicationContext): List> { + return emptyList() + } +} \ No newline at end of file diff --git a/app/android/app/src/main/java/uniffi/mopro/mopro.kt b/app/android/app/src/main/java/uniffi/mopro/mopro.kt new file mode 100644 index 000000000..655f6dfcd --- /dev/null +++ b/app/android/app/src/main/java/uniffi/mopro/mopro.kt @@ -0,0 +1,1172 @@ +// This file was autogenerated by some hot garbage in the `uniffi` crate. +// Trust me, you don't want to mess with it! + +@file:Suppress("NAME_SHADOWING") + +package uniffi.mopro; + +// Common helper code. +// +// Ideally this would live in a separate .kt file where it can be unittested etc +// in isolation, and perhaps even published as a re-useable package. +// +// However, it's important that the details of how this helper code works (e.g. the +// way that different builtin types are passed across the FFI) exactly match what's +// expected by the Rust code on the other side of the interface. In practice right +// now that means coming from the exact some version of `uniffi` that was used to +// compile the Rust component. The easiest way to ensure this is to bundle the Kotlin +// helpers directly inline like we're doing here. + +import com.sun.jna.Library +import com.sun.jna.IntegerType +import com.sun.jna.Native +import com.sun.jna.Pointer +import com.sun.jna.Structure +import com.sun.jna.Callback +import com.sun.jna.ptr.* +import java.nio.ByteBuffer +import java.nio.ByteOrder +import java.nio.CharBuffer +import java.nio.charset.CodingErrorAction +import java.util.concurrent.ConcurrentHashMap +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicLong + +// This is a helper for safely working with byte buffers returned from the Rust code. +// A rust-owned buffer is represented by its capacity, its current length, and a +// pointer to the underlying data. + +@Structure.FieldOrder("capacity", "len", "data") +open class RustBuffer : Structure() { + @JvmField var capacity: Int = 0 + @JvmField var len: Int = 0 + @JvmField var data: Pointer? = null + + class ByValue: RustBuffer(), Structure.ByValue + class ByReference: RustBuffer(), Structure.ByReference + + companion object { + internal fun alloc(size: Int = 0) = rustCall() { status -> + _UniFFILib.INSTANCE.ffi_mopro_ffi_rustbuffer_alloc(size, status) + }.also { + if(it.data == null) { + throw RuntimeException("RustBuffer.alloc() returned null data pointer (size=${size})") + } + } + + internal fun create(capacity: Int, len: Int, data: Pointer?): RustBuffer.ByValue { + var buf = RustBuffer.ByValue() + buf.capacity = capacity + buf.len = len + buf.data = data + return buf + } + + internal fun free(buf: RustBuffer.ByValue) = rustCall() { status -> + _UniFFILib.INSTANCE.ffi_mopro_ffi_rustbuffer_free(buf, status) + } + } + + @Suppress("TooGenericExceptionThrown") + fun asByteBuffer() = + this.data?.getByteBuffer(0, this.len.toLong())?.also { + it.order(ByteOrder.BIG_ENDIAN) + } +} + +/** + * The equivalent of the `*mut RustBuffer` type. + * Required for callbacks taking in an out pointer. + * + * Size is the sum of all values in the struct. + */ +class RustBufferByReference : ByReference(16) { + /** + * Set the pointed-to `RustBuffer` to the given value. + */ + fun setValue(value: RustBuffer.ByValue) { + // NOTE: The offsets are as they are in the C-like struct. + val pointer = getPointer() + pointer.setInt(0, value.capacity) + pointer.setInt(4, value.len) + pointer.setPointer(8, value.data) + } + + /** + * Get a `RustBuffer.ByValue` from this reference. + */ + fun getValue(): RustBuffer.ByValue { + val pointer = getPointer() + val value = RustBuffer.ByValue() + value.writeField("capacity", pointer.getInt(0)) + value.writeField("len", pointer.getInt(4)) + value.writeField("data", pointer.getPointer(8)) + + return value + } +} + +// This is a helper for safely passing byte references into the rust code. +// It's not actually used at the moment, because there aren't many things that you +// can take a direct pointer to in the JVM, and if we're going to copy something +// then we might as well copy it into a `RustBuffer`. But it's here for API +// completeness. + +@Structure.FieldOrder("len", "data") +open class ForeignBytes : Structure() { + @JvmField var len: Int = 0 + @JvmField var data: Pointer? = null + + class ByValue : ForeignBytes(), Structure.ByValue +} +// The FfiConverter interface handles converter types to and from the FFI +// +// All implementing objects should be public to support external types. When a +// type is external we need to import it's FfiConverter. +public interface FfiConverter { + // Convert an FFI type to a Kotlin type + fun lift(value: FfiType): KotlinType + + // Convert an Kotlin type to an FFI type + fun lower(value: KotlinType): FfiType + + // Read a Kotlin type from a `ByteBuffer` + fun read(buf: ByteBuffer): KotlinType + + // Calculate bytes to allocate when creating a `RustBuffer` + // + // This must return at least as many bytes as the write() function will + // write. It can return more bytes than needed, for example when writing + // Strings we can't know the exact bytes needed until we the UTF-8 + // encoding, so we pessimistically allocate the largest size possible (3 + // bytes per codepoint). Allocating extra bytes is not really a big deal + // because the `RustBuffer` is short-lived. + fun allocationSize(value: KotlinType): Int + + // Write a Kotlin type to a `ByteBuffer` + fun write(value: KotlinType, buf: ByteBuffer) + + // Lower a value into a `RustBuffer` + // + // This method lowers a value into a `RustBuffer` rather than the normal + // FfiType. It's used by the callback interface code. Callback interface + // returns are always serialized into a `RustBuffer` regardless of their + // normal FFI type. + fun lowerIntoRustBuffer(value: KotlinType): RustBuffer.ByValue { + val rbuf = RustBuffer.alloc(allocationSize(value)) + try { + val bbuf = rbuf.data!!.getByteBuffer(0, rbuf.capacity.toLong()).also { + it.order(ByteOrder.BIG_ENDIAN) + } + write(value, bbuf) + rbuf.writeField("len", bbuf.position()) + return rbuf + } catch (e: Throwable) { + RustBuffer.free(rbuf) + throw e + } + } + + // Lift a value from a `RustBuffer`. + // + // This here mostly because of the symmetry with `lowerIntoRustBuffer()`. + // It's currently only used by the `FfiConverterRustBuffer` class below. + fun liftFromRustBuffer(rbuf: RustBuffer.ByValue): KotlinType { + val byteBuf = rbuf.asByteBuffer()!! + try { + val item = read(byteBuf) + if (byteBuf.hasRemaining()) { + throw RuntimeException("junk remaining in buffer after lifting, something is very wrong!!") + } + return item + } finally { + RustBuffer.free(rbuf) + } + } +} + +// FfiConverter that uses `RustBuffer` as the FfiType +public interface FfiConverterRustBuffer: FfiConverter { + override fun lift(value: RustBuffer.ByValue) = liftFromRustBuffer(value) + override fun lower(value: KotlinType) = lowerIntoRustBuffer(value) +} +// A handful of classes and functions to support the generated data structures. +// This would be a good candidate for isolating in its own ffi-support lib. +// Error runtime. +@Structure.FieldOrder("code", "error_buf") +internal open class RustCallStatus : Structure() { + @JvmField var code: Byte = 0 + @JvmField var error_buf: RustBuffer.ByValue = RustBuffer.ByValue() + + class ByValue: RustCallStatus(), Structure.ByValue + + fun isSuccess(): Boolean { + return code == 0.toByte() + } + + fun isError(): Boolean { + return code == 1.toByte() + } + + fun isPanic(): Boolean { + return code == 2.toByte() + } +} + +class InternalException(message: String) : Exception(message) + +// Each top-level error class has a companion object that can lift the error from the call status's rust buffer +interface CallStatusErrorHandler { + fun lift(error_buf: RustBuffer.ByValue): E; +} + +// Helpers for calling Rust +// In practice we usually need to be synchronized to call this safely, so it doesn't +// synchronize itself + +// Call a rust function that returns a Result<>. Pass in the Error class companion that corresponds to the Err +private inline fun rustCallWithError(errorHandler: CallStatusErrorHandler, callback: (RustCallStatus) -> U): U { + var status = RustCallStatus(); + val return_value = callback(status) + checkCallStatus(errorHandler, status) + return return_value +} + +// Check RustCallStatus and throw an error if the call wasn't successful +private fun checkCallStatus(errorHandler: CallStatusErrorHandler, status: RustCallStatus) { + if (status.isSuccess()) { + return + } else if (status.isError()) { + throw errorHandler.lift(status.error_buf) + } else if (status.isPanic()) { + // when the rust code sees a panic, it tries to construct a rustbuffer + // with the message. but if that code panics, then it just sends back + // an empty buffer. + if (status.error_buf.len > 0) { + throw InternalException(FfiConverterString.lift(status.error_buf)) + } else { + throw InternalException("Rust panic") + } + } else { + throw InternalException("Unknown rust call status: $status.code") + } +} + +// CallStatusErrorHandler implementation for times when we don't expect a CALL_ERROR +object NullCallStatusErrorHandler: CallStatusErrorHandler { + override fun lift(error_buf: RustBuffer.ByValue): InternalException { + RustBuffer.free(error_buf) + return InternalException("Unexpected CALL_ERROR") + } +} + +// Call a rust function that returns a plain value +private inline fun rustCall(callback: (RustCallStatus) -> U): U { + return rustCallWithError(NullCallStatusErrorHandler, callback); +} + +// IntegerType that matches Rust's `usize` / C's `size_t` +public class USize(value: Long = 0) : IntegerType(Native.SIZE_T_SIZE, value, true) { + // This is needed to fill in the gaps of IntegerType's implementation of Number for Kotlin. + override fun toByte() = toInt().toByte() + // Needed until https://youtrack.jetbrains.com/issue/KT-47902 is fixed. + @Deprecated("`toInt().toChar()` is deprecated") + override fun toChar() = toInt().toChar() + override fun toShort() = toInt().toShort() + + fun writeToBuffer(buf: ByteBuffer) { + // Make sure we always write usize integers using native byte-order, since they may be + // casted to pointer values + buf.order(ByteOrder.nativeOrder()) + try { + when (Native.SIZE_T_SIZE) { + 4 -> buf.putInt(toInt()) + 8 -> buf.putLong(toLong()) + else -> throw RuntimeException("Invalid SIZE_T_SIZE: ${Native.SIZE_T_SIZE}") + } + } finally { + buf.order(ByteOrder.BIG_ENDIAN) + } + } + + companion object { + val size: Int + get() = Native.SIZE_T_SIZE + + fun readFromBuffer(buf: ByteBuffer) : USize { + // Make sure we always read usize integers using native byte-order, since they may be + // casted from pointer values + buf.order(ByteOrder.nativeOrder()) + try { + return when (Native.SIZE_T_SIZE) { + 4 -> USize(buf.getInt().toLong()) + 8 -> USize(buf.getLong()) + else -> throw RuntimeException("Invalid SIZE_T_SIZE: ${Native.SIZE_T_SIZE}") + } + } finally { + buf.order(ByteOrder.BIG_ENDIAN) + } + } + } +} + + +// Map handles to objects +// +// This is used when the Rust code expects an opaque pointer to represent some foreign object. +// Normally we would pass a pointer to the object, but JNA doesn't support getting a pointer from an +// object reference , nor does it support leaking a reference to Rust. +// +// Instead, this class maps USize values to objects so that we can pass a pointer-sized type to +// Rust when it needs an opaque pointer. +// +// TODO: refactor callbacks to use this class +internal class UniFfiHandleMap { + private val map = ConcurrentHashMap() + // Use AtomicInteger for our counter, since we may be on a 32-bit system. 4 billion possible + // values seems like enough. If somehow we generate 4 billion handles, then this will wrap + // around back to zero and we can assume the first handle generated will have been dropped by + // then. + private val counter = java.util.concurrent.atomic.AtomicInteger(0) + + val size: Int + get() = map.size + + fun insert(obj: T): USize { + val handle = USize(counter.getAndAdd(1).toLong()) + map.put(handle, obj) + return handle + } + + fun get(handle: USize): T? { + return map.get(handle) + } + + fun remove(handle: USize): T? { + return map.remove(handle) + } +} + +// FFI type for Rust future continuations +internal interface UniFffiRustFutureContinuationCallbackType : com.sun.jna.Callback { + fun callback(continuationHandle: USize, pollResult: Short); +} + +// Contains loading, initialization code, +// and the FFI Function declarations in a com.sun.jna.Library. +@Synchronized +private fun findLibraryName(componentName: String): String { + val libOverride = System.getProperty("uniffi.component.$componentName.libraryOverride") + if (libOverride != null) { + return libOverride + } + return "uniffi_mopro" +} + +private inline fun loadIndirect( + componentName: String +): Lib { + return Native.load(findLibraryName(componentName), Lib::class.java) +} + +// A JNA Library to expose the extern-C FFI definitions. +// This is an implementation detail which will be called internally by the public API. + +internal interface _UniFFILib : Library { + companion object { + internal val INSTANCE: _UniFFILib by lazy { + loadIndirect<_UniFFILib>(componentName = "mopro") + .also { lib: _UniFFILib -> + uniffiCheckContractApiVersion(lib) + uniffiCheckApiChecksums(lib) + } + } + } + + fun uniffi_mopro_ffi_fn_free_moprocircom(`ptr`: Pointer,_uniffi_out_err: RustCallStatus, + ): Unit + fun uniffi_mopro_ffi_fn_constructor_moprocircom_new(_uniffi_out_err: RustCallStatus, + ): Pointer + fun uniffi_mopro_ffi_fn_method_moprocircom_generate_proof(`ptr`: Pointer,`circuitInputs`: RustBuffer.ByValue,_uniffi_out_err: RustCallStatus, + ): RustBuffer.ByValue + fun uniffi_mopro_ffi_fn_method_moprocircom_setup(`ptr`: Pointer,`wasmPath`: RustBuffer.ByValue,`r1csPath`: RustBuffer.ByValue,_uniffi_out_err: RustCallStatus, + ): RustBuffer.ByValue + fun uniffi_mopro_ffi_fn_method_moprocircom_verify_proof(`ptr`: Pointer,`proof`: RustBuffer.ByValue,`publicInput`: RustBuffer.ByValue,_uniffi_out_err: RustCallStatus, + ): Byte + fun uniffi_mopro_ffi_fn_func_add(`a`: Int,`b`: Int,_uniffi_out_err: RustCallStatus, + ): Int + fun uniffi_mopro_ffi_fn_func_generate_proof2(`circuitInputs`: RustBuffer.ByValue,_uniffi_out_err: RustCallStatus, + ): RustBuffer.ByValue + fun uniffi_mopro_ffi_fn_func_hello(_uniffi_out_err: RustCallStatus, + ): RustBuffer.ByValue + fun uniffi_mopro_ffi_fn_func_initialize_mopro(_uniffi_out_err: RustCallStatus, + ): Unit + fun uniffi_mopro_ffi_fn_func_initialize_mopro_dylib(`dylibPath`: RustBuffer.ByValue,_uniffi_out_err: RustCallStatus, + ): Unit + fun uniffi_mopro_ffi_fn_func_verify_proof2(`proof`: RustBuffer.ByValue,`publicInput`: RustBuffer.ByValue,_uniffi_out_err: RustCallStatus, + ): Byte + fun ffi_mopro_ffi_rustbuffer_alloc(`size`: Int,_uniffi_out_err: RustCallStatus, + ): RustBuffer.ByValue + fun ffi_mopro_ffi_rustbuffer_from_bytes(`bytes`: ForeignBytes.ByValue,_uniffi_out_err: RustCallStatus, + ): RustBuffer.ByValue + fun ffi_mopro_ffi_rustbuffer_free(`buf`: RustBuffer.ByValue,_uniffi_out_err: RustCallStatus, + ): Unit + fun ffi_mopro_ffi_rustbuffer_reserve(`buf`: RustBuffer.ByValue,`additional`: Int,_uniffi_out_err: RustCallStatus, + ): RustBuffer.ByValue + fun ffi_mopro_ffi_rust_future_continuation_callback_set(`callback`: UniFffiRustFutureContinuationCallbackType, + ): Unit + fun ffi_mopro_ffi_rust_future_poll_u8(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_u8(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_u8(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_u8(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Byte + fun ffi_mopro_ffi_rust_future_poll_i8(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_i8(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_i8(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_i8(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Byte + fun ffi_mopro_ffi_rust_future_poll_u16(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_u16(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_u16(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_u16(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Short + fun ffi_mopro_ffi_rust_future_poll_i16(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_i16(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_i16(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_i16(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Short + fun ffi_mopro_ffi_rust_future_poll_u32(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_u32(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_u32(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_u32(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Int + fun ffi_mopro_ffi_rust_future_poll_i32(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_i32(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_i32(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_i32(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Int + fun ffi_mopro_ffi_rust_future_poll_u64(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_u64(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_u64(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_u64(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Long + fun ffi_mopro_ffi_rust_future_poll_i64(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_i64(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_i64(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_i64(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Long + fun ffi_mopro_ffi_rust_future_poll_f32(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_f32(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_f32(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_f32(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Float + fun ffi_mopro_ffi_rust_future_poll_f64(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_f64(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_f64(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_f64(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Double + fun ffi_mopro_ffi_rust_future_poll_pointer(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_pointer(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_pointer(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_pointer(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Pointer + fun ffi_mopro_ffi_rust_future_poll_rust_buffer(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_rust_buffer(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_rust_buffer(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_rust_buffer(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): RustBuffer.ByValue + fun ffi_mopro_ffi_rust_future_poll_void(`handle`: Pointer,`uniffiCallback`: USize, + ): Unit + fun ffi_mopro_ffi_rust_future_cancel_void(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_free_void(`handle`: Pointer, + ): Unit + fun ffi_mopro_ffi_rust_future_complete_void(`handle`: Pointer,_uniffi_out_err: RustCallStatus, + ): Unit + fun uniffi_mopro_ffi_checksum_func_add( + ): Short + fun uniffi_mopro_ffi_checksum_func_generate_proof2( + ): Short + fun uniffi_mopro_ffi_checksum_func_hello( + ): Short + fun uniffi_mopro_ffi_checksum_func_initialize_mopro( + ): Short + fun uniffi_mopro_ffi_checksum_func_initialize_mopro_dylib( + ): Short + fun uniffi_mopro_ffi_checksum_func_verify_proof2( + ): Short + fun uniffi_mopro_ffi_checksum_method_moprocircom_generate_proof( + ): Short + fun uniffi_mopro_ffi_checksum_method_moprocircom_setup( + ): Short + fun uniffi_mopro_ffi_checksum_method_moprocircom_verify_proof( + ): Short + fun uniffi_mopro_ffi_checksum_constructor_moprocircom_new( + ): Short + fun ffi_mopro_ffi_uniffi_contract_version( + ): Int + +} + +private fun uniffiCheckContractApiVersion(lib: _UniFFILib) { + // Get the bindings contract version from our ComponentInterface + val bindings_contract_version = 24 + // Get the scaffolding contract version by calling the into the dylib + val scaffolding_contract_version = lib.ffi_mopro_ffi_uniffi_contract_version() + if (bindings_contract_version != scaffolding_contract_version) { + throw RuntimeException("UniFFI contract version mismatch: try cleaning and rebuilding your project") + } +} + +@Suppress("UNUSED_PARAMETER") +private fun uniffiCheckApiChecksums(lib: _UniFFILib) { + if (lib.uniffi_mopro_ffi_checksum_func_add() != 8411.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_mopro_ffi_checksum_func_generate_proof2() != 40187.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_mopro_ffi_checksum_func_hello() != 46136.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_mopro_ffi_checksum_func_initialize_mopro() != 17540.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_mopro_ffi_checksum_func_initialize_mopro_dylib() != 64476.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_mopro_ffi_checksum_func_verify_proof2() != 37192.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_mopro_ffi_checksum_method_moprocircom_generate_proof() != 64602.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_mopro_ffi_checksum_method_moprocircom_setup() != 57700.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_mopro_ffi_checksum_method_moprocircom_verify_proof() != 61522.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } + if (lib.uniffi_mopro_ffi_checksum_constructor_moprocircom_new() != 42205.toShort()) { + throw RuntimeException("UniFFI API checksum mismatch: try cleaning and rebuilding your project") + } +} + +// Async support + +// Public interface members begin here. + + +public object FfiConverterUInt: FfiConverter { + override fun lift(value: Int): UInt { + return value.toUInt() + } + + override fun read(buf: ByteBuffer): UInt { + return lift(buf.getInt()) + } + + override fun lower(value: UInt): Int { + return value.toInt() + } + + override fun allocationSize(value: UInt) = 4 + + override fun write(value: UInt, buf: ByteBuffer) { + buf.putInt(value.toInt()) + } +} + +public object FfiConverterBoolean: FfiConverter { + override fun lift(value: Byte): Boolean { + return value.toInt() != 0 + } + + override fun read(buf: ByteBuffer): Boolean { + return lift(buf.get()) + } + + override fun lower(value: Boolean): Byte { + return if (value) 1.toByte() else 0.toByte() + } + + override fun allocationSize(value: Boolean) = 1 + + override fun write(value: Boolean, buf: ByteBuffer) { + buf.put(lower(value)) + } +} + +public object FfiConverterString: FfiConverter { + // Note: we don't inherit from FfiConverterRustBuffer, because we use a + // special encoding when lowering/lifting. We can use `RustBuffer.len` to + // store our length and avoid writing it out to the buffer. + override fun lift(value: RustBuffer.ByValue): String { + try { + val byteArr = ByteArray(value.len) + value.asByteBuffer()!!.get(byteArr) + return byteArr.toString(Charsets.UTF_8) + } finally { + RustBuffer.free(value) + } + } + + override fun read(buf: ByteBuffer): String { + val len = buf.getInt() + val byteArr = ByteArray(len) + buf.get(byteArr) + return byteArr.toString(Charsets.UTF_8) + } + + fun toUtf8(value: String): ByteBuffer { + // Make sure we don't have invalid UTF-16, check for lone surrogates. + return Charsets.UTF_8.newEncoder().run { + onMalformedInput(CodingErrorAction.REPORT) + encode(CharBuffer.wrap(value)) + } + } + + override fun lower(value: String): RustBuffer.ByValue { + val byteBuf = toUtf8(value) + // Ideally we'd pass these bytes to `ffi_bytebuffer_from_bytes`, but doing so would require us + // to copy them into a JNA `Memory`. So we might as well directly copy them into a `RustBuffer`. + val rbuf = RustBuffer.alloc(byteBuf.limit()) + rbuf.asByteBuffer()!!.put(byteBuf) + return rbuf + } + + // We aren't sure exactly how many bytes our string will be once it's UTF-8 + // encoded. Allocate 3 bytes per UTF-16 code unit which will always be + // enough. + override fun allocationSize(value: String): Int { + val sizeForLength = 4 + val sizeForString = value.length * 3 + return sizeForLength + sizeForString + } + + override fun write(value: String, buf: ByteBuffer) { + val byteBuf = toUtf8(value) + buf.putInt(byteBuf.limit()) + buf.put(byteBuf) + } +} + +public object FfiConverterByteArray: FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): ByteArray { + val len = buf.getInt() + val byteArr = ByteArray(len) + buf.get(byteArr) + return byteArr + } + override fun allocationSize(value: ByteArray): Int { + return 4 + value.size + } + override fun write(value: ByteArray, buf: ByteBuffer) { + buf.putInt(value.size) + buf.put(value) + } +} + + +// Interface implemented by anything that can contain an object reference. +// +// Such types expose a `destroy()` method that must be called to cleanly +// dispose of the contained objects. Failure to call this method may result +// in memory leaks. +// +// The easiest way to ensure this method is called is to use the `.use` +// helper method to execute a block and destroy the object at the end. +interface Disposable { + fun destroy() + companion object { + fun destroy(vararg args: Any?) { + args.filterIsInstance() + .forEach(Disposable::destroy) + } + } +} + +inline fun T.use(block: (T) -> R) = + try { + block(this) + } finally { + try { + // N.B. our implementation is on the nullable type `Disposable?`. + this?.destroy() + } catch (e: Throwable) { + // swallow + } + } + +// The base class for all UniFFI Object types. +// +// This class provides core operations for working with the Rust `Arc` pointer to +// the live Rust struct on the other side of the FFI. +// +// There's some subtlety here, because we have to be careful not to operate on a Rust +// struct after it has been dropped, and because we must expose a public API for freeing +// the Kotlin wrapper object in lieu of reliable finalizers. The core requirements are: +// +// * Each `FFIObject` instance holds an opaque pointer to the underlying Rust struct. +// Method calls need to read this pointer from the object's state and pass it in to +// the Rust FFI. +// +// * When an `FFIObject` is no longer needed, its pointer should be passed to a +// special destructor function provided by the Rust FFI, which will drop the +// underlying Rust struct. +// +// * Given an `FFIObject` instance, calling code is expected to call the special +// `destroy` method in order to free it after use, either by calling it explicitly +// or by using a higher-level helper like the `use` method. Failing to do so will +// leak the underlying Rust struct. +// +// * We can't assume that calling code will do the right thing, and must be prepared +// to handle Kotlin method calls executing concurrently with or even after a call to +// `destroy`, and to handle multiple (possibly concurrent!) calls to `destroy`. +// +// * We must never allow Rust code to operate on the underlying Rust struct after +// the destructor has been called, and must never call the destructor more than once. +// Doing so may trigger memory unsafety. +// +// If we try to implement this with mutual exclusion on access to the pointer, there is the +// possibility of a race between a method call and a concurrent call to `destroy`: +// +// * Thread A starts a method call, reads the value of the pointer, but is interrupted +// before it can pass the pointer over the FFI to Rust. +// * Thread B calls `destroy` and frees the underlying Rust struct. +// * Thread A resumes, passing the already-read pointer value to Rust and triggering +// a use-after-free. +// +// One possible solution would be to use a `ReadWriteLock`, with each method call taking +// a read lock (and thus allowed to run concurrently) and the special `destroy` method +// taking a write lock (and thus blocking on live method calls). However, we aim not to +// generate methods with any hidden blocking semantics, and a `destroy` method that might +// block if called incorrectly seems to meet that bar. +// +// So, we achieve our goals by giving each `FFIObject` an associated `AtomicLong` counter to track +// the number of in-flight method calls, and an `AtomicBoolean` flag to indicate whether `destroy` +// has been called. These are updated according to the following rules: +// +// * The initial value of the counter is 1, indicating a live object with no in-flight calls. +// The initial value for the flag is false. +// +// * At the start of each method call, we atomically check the counter. +// If it is 0 then the underlying Rust struct has already been destroyed and the call is aborted. +// If it is nonzero them we atomically increment it by 1 and proceed with the method call. +// +// * At the end of each method call, we atomically decrement and check the counter. +// If it has reached zero then we destroy the underlying Rust struct. +// +// * When `destroy` is called, we atomically flip the flag from false to true. +// If the flag was already true we silently fail. +// Otherwise we atomically decrement and check the counter. +// If it has reached zero then we destroy the underlying Rust struct. +// +// Astute readers may observe that this all sounds very similar to the way that Rust's `Arc` works, +// and indeed it is, with the addition of a flag to guard against multiple calls to `destroy`. +// +// The overall effect is that the underlying Rust struct is destroyed only when `destroy` has been +// called *and* all in-flight method calls have completed, avoiding violating any of the expectations +// of the underlying Rust code. +// +// In the future we may be able to replace some of this with automatic finalization logic, such as using +// the new "Cleaner" functionaility in Java 9. The above scheme has been designed to work even if `destroy` is +// invoked by garbage-collection machinery rather than by calling code (which by the way, it's apparently also +// possible for the JVM to finalize an object while there is an in-flight call to one of its methods [1], +// so there would still be some complexity here). +// +// Sigh...all of this for want of a robust finalization mechanism. +// +// [1] https://stackoverflow.com/questions/24376768/can-java-finalize-an-object-when-it-is-still-in-scope/24380219 +// +abstract class FFIObject( + protected val pointer: Pointer +): Disposable, AutoCloseable { + + private val wasDestroyed = AtomicBoolean(false) + private val callCounter = AtomicLong(1) + + open protected fun freeRustArcPtr() { + // To be overridden in subclasses. + } + + override fun destroy() { + // Only allow a single call to this method. + // TODO: maybe we should log a warning if called more than once? + if (this.wasDestroyed.compareAndSet(false, true)) { + // This decrement always matches the initial count of 1 given at creation time. + if (this.callCounter.decrementAndGet() == 0L) { + this.freeRustArcPtr() + } + } + } + + @Synchronized + override fun close() { + this.destroy() + } + + internal inline fun callWithPointer(block: (ptr: Pointer) -> R): R { + // Check and increment the call counter, to keep the object alive. + // This needs a compare-and-set retry loop in case of concurrent updates. + do { + val c = this.callCounter.get() + if (c == 0L) { + throw IllegalStateException("${this.javaClass.simpleName} object has already been destroyed") + } + if (c == Long.MAX_VALUE) { + throw IllegalStateException("${this.javaClass.simpleName} call counter would overflow") + } + } while (! this.callCounter.compareAndSet(c, c + 1L)) + // Now we can safely do the method call without the pointer being freed concurrently. + try { + return block(this.pointer) + } finally { + // This decrement always matches the increment we performed above. + if (this.callCounter.decrementAndGet() == 0L) { + this.freeRustArcPtr() + } + } + } +} + +public interface MoproCircomInterface { + @Throws(MoproException::class) + fun `generateProof`(`circuitInputs`: Map>): GenerateProofResult@Throws(MoproException::class) + fun `setup`(`wasmPath`: String, `r1csPath`: String): SetupResult@Throws(MoproException::class) + fun `verifyProof`(`proof`: ByteArray, `publicInput`: ByteArray): Boolean + companion object +} + +class MoproCircom( + pointer: Pointer +) : FFIObject(pointer), MoproCircomInterface { + constructor() : + this( + rustCall() { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_constructor_moprocircom_new(_status) +}) + + /** + * Disconnect the object from the underlying Rust object. + * + * It can be called more than once, but once called, interacting with the object + * causes an `IllegalStateException`. + * + * Clients **must** call this method once done with the object, or cause a memory leak. + */ + override protected fun freeRustArcPtr() { + rustCall() { status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_free_moprocircom(this.pointer, status) + } + } + + + @Throws(MoproException::class)override fun `generateProof`(`circuitInputs`: Map>): GenerateProofResult = + callWithPointer { + rustCallWithError(MoproException) { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_method_moprocircom_generate_proof(it, + FfiConverterMapStringSequenceString.lower(`circuitInputs`), + _status) +} + }.let { + FfiConverterTypeGenerateProofResult.lift(it) + } + + + @Throws(MoproException::class)override fun `setup`(`wasmPath`: String, `r1csPath`: String): SetupResult = + callWithPointer { + rustCallWithError(MoproException) { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_method_moprocircom_setup(it, + FfiConverterString.lower(`wasmPath`),FfiConverterString.lower(`r1csPath`), + _status) +} + }.let { + FfiConverterTypeSetupResult.lift(it) + } + + + @Throws(MoproException::class)override fun `verifyProof`(`proof`: ByteArray, `publicInput`: ByteArray): Boolean = + callWithPointer { + rustCallWithError(MoproException) { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_method_moprocircom_verify_proof(it, + FfiConverterByteArray.lower(`proof`),FfiConverterByteArray.lower(`publicInput`), + _status) +} + }.let { + FfiConverterBoolean.lift(it) + } + + + + + companion object + +} + +public object FfiConverterTypeMoproCircom: FfiConverter { + override fun lower(value: MoproCircom): Pointer = value.callWithPointer { it } + + override fun lift(value: Pointer): MoproCircom { + return MoproCircom(value) + } + + override fun read(buf: ByteBuffer): MoproCircom { + // The Rust code always writes pointers as 8 bytes, and will + // fail to compile if they don't fit. + return lift(Pointer(buf.getLong())) + } + + override fun allocationSize(value: MoproCircom) = 8 + + override fun write(value: MoproCircom, buf: ByteBuffer) { + // The Rust code always expects pointers written as 8 bytes, + // and will fail to compile if they don't fit. + buf.putLong(Pointer.nativeValue(lower(value))) + } +} + + + + +data class GenerateProofResult ( + var `proof`: ByteArray, + var `inputs`: ByteArray +) { + + companion object +} + +public object FfiConverterTypeGenerateProofResult: FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): GenerateProofResult { + return GenerateProofResult( + FfiConverterByteArray.read(buf), + FfiConverterByteArray.read(buf), + ) + } + + override fun allocationSize(value: GenerateProofResult) = ( + FfiConverterByteArray.allocationSize(value.`proof`) + + FfiConverterByteArray.allocationSize(value.`inputs`) + ) + + override fun write(value: GenerateProofResult, buf: ByteBuffer) { + FfiConverterByteArray.write(value.`proof`, buf) + FfiConverterByteArray.write(value.`inputs`, buf) + } +} + + + + +data class SetupResult ( + var `provingKey`: ByteArray +) { + + companion object +} + +public object FfiConverterTypeSetupResult: FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): SetupResult { + return SetupResult( + FfiConverterByteArray.read(buf), + ) + } + + override fun allocationSize(value: SetupResult) = ( + FfiConverterByteArray.allocationSize(value.`provingKey`) + ) + + override fun write(value: SetupResult, buf: ByteBuffer) { + FfiConverterByteArray.write(value.`provingKey`, buf) + } +} + + + + + +sealed class MoproException(message: String): Exception(message) { + // Each variant is a nested class + // Flat enums carries a string error message, so no special implementation is necessary. + class CircomException(message: String) : MoproException(message) + + + companion object ErrorHandler : CallStatusErrorHandler { + override fun lift(error_buf: RustBuffer.ByValue): MoproException = FfiConverterTypeMoproError.lift(error_buf) + } +} + +public object FfiConverterTypeMoproError : FfiConverterRustBuffer { + override fun read(buf: ByteBuffer): MoproException { + + return when(buf.getInt()) { + 1 -> MoproException.CircomException(FfiConverterString.read(buf)) + else -> throw RuntimeException("invalid error enum value, something is very wrong!!") + } + + } + + override fun allocationSize(value: MoproException): Int { + return 4 + } + + override fun write(value: MoproException, buf: ByteBuffer) { + when(value) { + is MoproException.CircomException -> { + buf.putInt(1) + Unit + } + }.let { /* this makes the `when` an expression, which ensures it is exhaustive */ } + } + +} + + + + +public object FfiConverterSequenceString: FfiConverterRustBuffer> { + override fun read(buf: ByteBuffer): List { + val len = buf.getInt() + return List(len) { + FfiConverterString.read(buf) + } + } + + override fun allocationSize(value: List): Int { + val sizeForLength = 4 + val sizeForItems = value.map { FfiConverterString.allocationSize(it) }.sum() + return sizeForLength + sizeForItems + } + + override fun write(value: List, buf: ByteBuffer) { + buf.putInt(value.size) + value.forEach { + FfiConverterString.write(it, buf) + } + } +} + + + +public object FfiConverterMapStringSequenceString: FfiConverterRustBuffer>> { + override fun read(buf: ByteBuffer): Map> { + val len = buf.getInt() + return buildMap>(len) { + repeat(len) { + val k = FfiConverterString.read(buf) + val v = FfiConverterSequenceString.read(buf) + this[k] = v + } + } + } + + override fun allocationSize(value: Map>): Int { + val spaceForMapSize = 4 + val spaceForChildren = value.map { (k, v) -> + FfiConverterString.allocationSize(k) + + FfiConverterSequenceString.allocationSize(v) + }.sum() + return spaceForMapSize + spaceForChildren + } + + override fun write(value: Map>, buf: ByteBuffer) { + buf.putInt(value.size) + // The parens on `(k, v)` here ensure we're calling the right method, + // which is important for compatibility with older android devices. + // Ref https://blog.danlew.net/2017/03/16/kotlin-puzzler-whose-line-is-it-anyways/ + value.forEach { (k, v) -> + FfiConverterString.write(k, buf) + FfiConverterSequenceString.write(v, buf) + } + } +} + +fun `add`(`a`: UInt, `b`: UInt): UInt { + return FfiConverterUInt.lift( + rustCall() { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_func_add(FfiConverterUInt.lower(`a`),FfiConverterUInt.lower(`b`),_status) +}) +} + +@Throws(MoproException::class) + +fun `generateProof2`(`circuitInputs`: Map>): GenerateProofResult { + return FfiConverterTypeGenerateProofResult.lift( + rustCallWithError(MoproException) { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_func_generate_proof2(FfiConverterMapStringSequenceString.lower(`circuitInputs`),_status) +}) +} + + +fun `hello`(): String { + return FfiConverterString.lift( + rustCall() { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_func_hello(_status) +}) +} + +@Throws(MoproException::class) + +fun `initializeMopro`() = + + rustCallWithError(MoproException) { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_func_initialize_mopro(_status) +} + + +@Throws(MoproException::class) + +fun `initializeMoproDylib`(`dylibPath`: String) = + + rustCallWithError(MoproException) { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_func_initialize_mopro_dylib(FfiConverterString.lower(`dylibPath`),_status) +} + + +@Throws(MoproException::class) + +fun `verifyProof2`(`proof`: ByteArray, `publicInput`: ByteArray): Boolean { + return FfiConverterBoolean.lift( + rustCallWithError(MoproException) { _status -> + _UniFFILib.INSTANCE.uniffi_mopro_ffi_fn_func_verify_proof2(FfiConverterByteArray.lower(`proof`),FfiConverterByteArray.lower(`publicInput`),_status) +}) +} + + diff --git a/app/android/react-native-passport-reader/android/src/main/java/io/tradle/nfc/RNPassportReaderModule.kt b/app/android/react-native-passport-reader/android/src/main/java/io/tradle/nfc/RNPassportReaderModule.kt index 37024cf9f..42c345849 100644 --- a/app/android/react-native-passport-reader/android/src/main/java/io/tradle/nfc/RNPassportReaderModule.kt +++ b/app/android/react-native-passport-reader/android/src/main/java/io/tradle/nfc/RNPassportReaderModule.kt @@ -618,105 +618,6 @@ class RNPassportReaderModule(private val reactContext: ReactApplicationContext) } } - //-------------functions related to calling rust lib----------------// - - // Declare native method - external fun callRustCode(): String - - @ReactMethod - fun callRustLib(callback: Callback) { - // Call the Rust function - val resultFromRust = callRustCode() - - // Return the result to JavaScript through the callback - callback.invoke(null, resultFromRust) - } - - external fun provePassport( - mrz: List, - reveal_bitmap: List, - dataHashes: List, - datahashes_padded_length: String, - eContentBytes: List, - signature: List, - signature_algorithm: String, - pubkey: List, - path_indices: List, - siblings: List, - root: String, - address: String, - zkeypath: String - ): String - - @ReactMethod - fun provePassport(inputs: ReadableMap, zkeypath: String, callback: Callback) { - Log.d(TAG, "inputs in provePassport kotlin: " + inputs.toString()) - - val mrz = inputs.getArray("mrz")?.toArrayList()?.map { it as String } ?: listOf() - val reveal_bitmap = inputs.getArray("reveal_bitmap")?.toArrayList()?.map { it as String } ?: listOf() - val data_hashes = inputs.getArray("dataHashes")?.toArrayList()?.map { it as String } ?: listOf() - val datahashes_padded_length = inputs.getString("datahashes_padded_length") ?: "" - val e_content_bytes = inputs.getArray("eContentBytes")?.toArrayList()?.map { it as String } ?: listOf() - val signature = inputs.getArray("signature")?.toArrayList()?.map { it as String } ?: listOf() - val signature_algorithm = inputs.getString("signatureAlgorithm") ?: "" - val pubkey = inputs.getArray("pubkey")?.toArrayList()?.map { it as String } ?: listOf() - val path_indices = inputs.getArray("pathIndices")?.toArrayList()?.map { it as String } ?: listOf() - val siblings = inputs.getArray("siblings")?.toArrayList()?.map { it as String } ?: listOf() - val root = inputs.getString("root") ?: "" - val address = inputs.getString("address") ?: "" - - val resultFromProof = provePassport( - mrz, - reveal_bitmap, - data_hashes, - datahashes_padded_length, - e_content_bytes, - signature, - signature_algorithm, - pubkey, - path_indices, - siblings, - root, - address, - zkeypath - ) - - Log.d(TAG, "resultFromProof: " + resultFromProof.toString()) - - // Return the result to JavaScript through the callback - callback.invoke(null, resultFromProof) - } - - @ReactMethod - fun downloadFile(url: String, fileName: String, promise: Promise) { - val client = OkHttpClient() - val request = Request.Builder().url(url).build() - - try { - client.newCall(request).execute().use { response -> - if (!response.isSuccessful) throw IOException("Failed to download file: $response") - - // Use the app's internal files directory - val fileOutputStream = reactContext.openFileOutput(fileName, Context.MODE_PRIVATE) - - val inputStream = response.body?.byteStream() - inputStream.use { input -> - fileOutputStream.use { output -> - input?.copyTo(output) - } - } - - // Resolve the promise with the file path - val file = File(reactContext.filesDir, fileName) - promise.resolve(file.absolutePath) - } - } catch (e: Exception) { - // Reject the promise if an exception occurs - promise.reject(e) - } - } - - companion object { private val TAG = RNPassportReaderModule::class.java.simpleName private const val PARAM_DOC_NUM = "documentNumber"; @@ -725,8 +626,5 @@ class RNPassportReaderModule(private val reactContext: ReactApplicationContext) const val JPEG_DATA_URI_PREFIX = "data:image/jpeg;base64," private const val KEY_IS_SUPPORTED = "isSupported" var instance: RNPassportReaderModule? = null - init { - System.loadLibrary("ark_circom_passport") - } } } \ No newline at end of file diff --git a/app/ark-circom-passport/.gitignore b/app/ark-circom-passport/.gitignore deleted file mode 100644 index 65bee789a..000000000 --- a/app/ark-circom-passport/.gitignore +++ /dev/null @@ -1,3 +0,0 @@ -/target -rsa -passport \ No newline at end of file diff --git a/app/ark-circom-passport/Cargo.lock b/app/ark-circom-passport/Cargo.lock deleted file mode 100644 index df8dd9892..000000000 --- a/app/ark-circom-passport/Cargo.lock +++ /dev/null @@ -1,5071 +0,0 @@ -# This file is automatically @generated by Cargo. -# It is not intended for manual editing. -version = 3 - -[[package]] -name = "Inflector" -version = "0.11.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe438c63458706e03479442743baae6c88256498e6431708f6dfc520a26515d3" -dependencies = [ - "lazy_static 1.4.0", - "regex", -] - -[[package]] -name = "addr2line" -version = "0.21.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a30b2e23b9e17a9f90641c7ab1549cd9b44f296d3ccbf309d2863cfe398a0cb" -dependencies = [ - "gimli 0.28.1", -] - -[[package]] -name = "adler" -version = "1.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe" - -[[package]] -name = "aes" -version = "0.8.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac1f845298e95f983ff1944b728ae08b8cebab80d684f0a832ed0fc74dfa27e2" -dependencies = [ - "cfg-if", - "cipher", - "cpufeatures", -] - -[[package]] -name = "ahash" -version = "0.7.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a824f2aa7e75a0c98c5a504fceb80649e9c35265d44525b5f94de4771a395cd" -dependencies = [ - "getrandom", - "once_cell", - "version_check", -] - -[[package]] -name = "ahash" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01" -dependencies = [ - "cfg-if", - "once_cell", - "version_check", - "zerocopy", -] - -[[package]] -name = "aho-corasick" -version = "1.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2969dcb958b36655471fc61f7e416fa76033bdd4bfed0678d8fee1e2d07a1f0" -dependencies = [ - "memchr", -] - -[[package]] -name = "android_log-sys" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b8052e2d8aabbb8d556d6abbcce2a22b9590996c5f849b9c7ce4544a2e3b984e" - -[[package]] -name = "android_logger" -version = "0.8.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cbd542dd180566fad88fd2729a53a62a734843c626638006a9d63ec0688484e" -dependencies = [ - "android_log-sys", - "env_logger", - "lazy_static 1.4.0", - "log", -] - -[[package]] -name = "ark-bn254" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a22f4561524cd949590d78d7d4c5df8f592430d221f7f3c9497bbafd8972120f" -dependencies = [ - "ark-ec", - "ark-ff", - "ark-std", -] - -[[package]] -name = "ark-circom" -version = "0.1.0" -source = "git+https://github.com/0xturboblitz/circom-compat.git#621a3369523aec2406ca4f2f86d1794b14b823f1" -dependencies = [ - "ark-bn254", - "ark-crypto-primitives", - "ark-ec", - "ark-ff", - "ark-groth16", - "ark-poly", - "ark-relations", - "ark-serialize", - "ark-std", - "byteorder", - "cfg-if", - "color-eyre", - "criterion", - "ethers-core", - "fnv", - "hex", - "num", - "num-bigint", - "num-traits", - "thiserror", - "wasmer", -] - -[[package]] -name = "ark-circom" -version = "0.1.0" -source = "git+https://github.com/arkworks-rs/circom-compat.git#170b10fc9ed182b5f72ecf379033dda023d0bf07" -dependencies = [ - "ark-bn254", - "ark-crypto-primitives", - "ark-ec", - "ark-ff", - "ark-groth16", - "ark-poly", - "ark-relations", - "ark-serialize", - "ark-std", - "byteorder", - "cfg-if", - "color-eyre", - "criterion", - "ethers-core", - "fnv", - "hex", - "num", - "num-bigint", - "num-traits", - "thiserror", - "wasmer", -] - -[[package]] -name = "ark-crypto-primitives" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3a13b34da09176a8baba701233fdffbaa7c1b1192ce031a3da4e55ce1f1a56" -dependencies = [ - "ark-ec", - "ark-ff", - "ark-relations", - "ark-serialize", - "ark-snark", - "ark-std", - "blake2", - "derivative", - "digest", - "rayon", - "sha2", -] - -[[package]] -name = "ark-ec" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c60370a92f8e1a5f053cad73a862e1b99bc642333cd676fa11c0c39f80f4ac2" -dependencies = [ - "ark-ff", - "ark-poly", - "ark-serialize", - "ark-std", - "derivative", - "hashbrown 0.13.2", - "itertools", - "num-traits", - "rayon", - "zeroize", -] - -[[package]] -name = "ark-ff" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c2d42532524bee1da5a4f6f733eb4907301baa480829557adcff5dfaeee1d9a" -dependencies = [ - "ark-ff-asm", - "ark-ff-macros", - "ark-serialize", - "ark-std", - "derivative", - "digest", - "itertools", - "num-bigint", - "num-traits", - "paste", - "rayon", - "rustc_version", - "zeroize", -] - -[[package]] -name = "ark-ff-asm" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3ed4aa4fe255d0bc6d79373f7e31d2ea147bcf486cba1be5ba7ea85abdb92348" -dependencies = [ - "quote", - "syn 1.0.109", -] - -[[package]] -name = "ark-ff-macros" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7abe79b0e4288889c4574159ab790824d0033b9fdcb2a112a3182fac2e514565" -dependencies = [ - "num-bigint", - "num-traits", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "ark-groth16" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20ceafa83848c3e390f1cbf124bc3193b3e639b3f02009e0e290809a501b95fc" -dependencies = [ - "ark-crypto-primitives", - "ark-ec", - "ark-ff", - "ark-poly", - "ark-relations", - "ark-serialize", - "ark-std", - "rayon", -] - -[[package]] -name = "ark-poly" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f6ec811462cabe265cfe1b102fcfe3df79d7d2929c2425673648ee9abfd0272" -dependencies = [ - "ark-ff", - "ark-serialize", - "ark-std", - "derivative", - "hashbrown 0.13.2", - "rayon", -] - -[[package]] -name = "ark-relations" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "00796b6efc05a3f48225e59cb6a2cda78881e7c390872d5786aaf112f31fb4f0" -dependencies = [ - "ark-ff", - "ark-std", - "tracing", - "tracing-subscriber 0.2.25", -] - -[[package]] -name = "ark-serialize" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7e735959bc173ea4baf13327b19c22d452b8e9e8e8f7b7fc34e6bf0e316c33e" -dependencies = [ - "ark-serialize-derive", - "ark-std", - "digest", - "num-bigint", -] - -[[package]] -name = "ark-serialize-derive" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae3281bc6d0fd7e549af32b52511e1302185bd688fd3359fa36423346ff682ea" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "ark-snark" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84d3cc6833a335bb8a600241889ead68ee89a3cf8448081fb7694c0fe503da63" -dependencies = [ - "ark-ff", - "ark-relations", - "ark-serialize", - "ark-std", -] - -[[package]] -name = "ark-std" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94893f1e0c6eeab764ade8dc4c0db24caf4fe7cbbaafc0eba0a9030f447b5185" -dependencies = [ - "num-traits", - "rand", - "rayon", -] - -[[package]] -name = "ark-zkey" -version = "0.1.0" -source = "git+https://github.com/oskarth/mopro.git?branch=main#ada13d6e1135d6788c9f3d4243229f06cdbebca7" -dependencies = [ - "ark-bn254", - "ark-circom 0.1.0 (git+https://github.com/arkworks-rs/circom-compat.git)", - "ark-ec", - "ark-ff", - "ark-groth16", - "ark-relations", - "ark-serialize", - "color-eyre", - "flame", - "flamer", - "memmap2 0.9.3", -] - -[[package]] -name = "ark_circom_passport" -version = "0.1.0" -dependencies = [ - "android_logger", - "ark-bn254", - "ark-circom 0.1.0 (git+https://github.com/0xturboblitz/circom-compat.git)", - "ark-crypto-primitives", - "ark-ec", - "ark-ff", - "ark-groth16", - "ark-relations", - "ark-serialize", - "ark-std", - "ark-zkey", - "byteorder", - "color-eyre", - "ethers", - "hex", - "jni", - "log", - "num-bigint", - "num-traits", - "once_cell", - "serde", - "serde_derive", - "serde_json", - "tokio", - "wasmer", -] - -[[package]] -name = "arrayvec" -version = "0.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" - -[[package]] -name = "ascii-canvas" -version = "3.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8824ecca2e851cec16968d54a01dd372ef8f95b244fb84b84e70128be347c3c6" -dependencies = [ - "term", -] - -[[package]] -name = "async-trait" -version = "0.1.76" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "531b97fb4cd3dfdce92c35dedbfdc1f0b9d8091c8ca943d6dae340ef5012d514" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "async_io_stream" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6d7b9decdf35d8908a7e3ef02f64c5e9b1695e230154c0e8de3969142d9b94c" -dependencies = [ - "futures", - "pharos", - "rustc_version", -] - -[[package]] -name = "atty" -version = "0.2.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d9b39be18770d11421cdb1b9947a45dd3f37e93092cbf377614828a319d5fee8" -dependencies = [ - "hermit-abi 0.1.19", - "libc", - "winapi", -] - -[[package]] -name = "auto_impl" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fee3da8ef1276b0bee5dd1c7258010d8fffd31801447323115a25560e1327b89" -dependencies = [ - "proc-macro-error", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "autocfg" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa" - -[[package]] -name = "backtrace" -version = "0.3.69" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2089b7e3f35b9dd2d0ed921ead4f6d318c27680d4a5bd167b3ee120edb105837" -dependencies = [ - "addr2line", - "cc", - "cfg-if", - "libc", - "miniz_oxide", - "object 0.32.2", - "rustc-demangle", -] - -[[package]] -name = "base16ct" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c7f02d4ea65f2c1853089ffd8d2787bdbc63de2f0d29dedbcf8ccdfa0ccd4cf" - -[[package]] -name = "base64" -version = "0.13.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e1b586273c5702936fe7b7d6896644d8be71e6314cfe09d3167c95f712589e8" - -[[package]] -name = "base64" -version = "0.21.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35636a1494ede3b646cc98f74f8e62c773a38a659ebc777a2cf26b9b74171df9" - -[[package]] -name = "base64ct" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c3c1a368f70d6cf7302d78f8f7093da241fb8e8807c05cc9e51a125895a6d5b" - -[[package]] -name = "bech32" -version = "0.9.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d86b93f97252c47b41663388e6d155714a9d0c398b99f1005cbc5f978b29f445" - -[[package]] -name = "bit-set" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0700ddab506f33b20a03b13996eccd309a48e5ff77d0d95926aa0210fb4e95f1" -dependencies = [ - "bit-vec", -] - -[[package]] -name = "bit-vec" -version = "0.6.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "349f9b6a179ed607305526ca489b34ad0a41aed5f7980fa90eb03160b69598fb" - -[[package]] -name = "bitflags" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" - -[[package]] -name = "bitflags" -version = "2.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "327762f6e5a765692301e5bb513e0d9fef63be86bbc14528052b1cd3e6f03e07" - -[[package]] -name = "bitvec" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c" -dependencies = [ - "funty", - "radium", - "tap", - "wyz", -] - -[[package]] -name = "blake2" -version = "0.10.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46502ad458c9a52b69d4d4d32775c788b7a1b85e8bc9d482d92250fc0e3f8efe" -dependencies = [ - "digest", -] - -[[package]] -name = "block-buffer" -version = "0.10.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3078c7629b62d3f0439517fa394996acacc5cbc91c5a20d8c658e77abd503a71" -dependencies = [ - "generic-array", -] - -[[package]] -name = "bs58" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f5353f36341f7451062466f0b755b96ac3a9547e4d7f6b70d603fc721a7d7896" -dependencies = [ - "sha2", - "tinyvec", -] - -[[package]] -name = "bumpalo" -version = "3.14.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f30e7476521f6f8af1a1c4c0b8cc94f0bee37d91763d0ca2665f299b6cd8aec" - -[[package]] -name = "byte-slice-cast" -version = "1.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c" - -[[package]] -name = "bytecheck" -version = "0.6.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b6372023ac861f6e6dc89c8344a8f398fb42aaba2b5dbc649ca0c0e9dbcb627" -dependencies = [ - "bytecheck_derive", - "ptr_meta", - "simdutf8", -] - -[[package]] -name = "bytecheck_derive" -version = "0.6.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a7ec4c6f261935ad534c0c22dbef2201b45918860eb1c574b972bd213a76af61" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "byteorder" -version = "1.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14c189c53d098945499cdfa7ecc63567cf3886b3332b312a5b4585d8d3a6a610" - -[[package]] -name = "bytes" -version = "1.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2bd12c1caf447e69cd4528f47f94d203fd2582878ecb9e9465484c4148a8223" -dependencies = [ - "serde", -] - -[[package]] -name = "bzip2" -version = "0.4.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bdb116a6ef3f6c3698828873ad02c3014b3c85cadb88496095628e3ef1e347f8" -dependencies = [ - "bzip2-sys", - "libc", -] - -[[package]] -name = "bzip2-sys" -version = "0.1.11+1.0.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "736a955f3fa7875102d57c82b8cac37ec45224a07fd32d58f9f7a186b6cd4cdc" -dependencies = [ - "cc", - "libc", - "pkg-config", -] - -[[package]] -name = "camino" -version = "1.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c59e92b5a388f549b863a7bea62612c09f24c8393560709a54558a9abdfb3b9c" -dependencies = [ - "serde", -] - -[[package]] -name = "cargo-platform" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ceed8ef69d8518a5dda55c07425450b58a4e1946f4951eab6d7191ee86c2443d" -dependencies = [ - "serde", -] - -[[package]] -name = "cargo_metadata" -version = "0.15.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eee4243f1f26fc7a42710e7439c149e2b10b05472f88090acce52632f231a73a" -dependencies = [ - "camino", - "cargo-platform", - "semver", - "serde", - "serde_json", - "thiserror", -] - -[[package]] -name = "cast" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37b2a672a2cb129a2e41c10b1224bb368f9f37a2b16b612598138befd7b37eb5" - -[[package]] -name = "cc" -version = "1.0.83" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0" -dependencies = [ - "jobserver", - "libc", -] - -[[package]] -name = "cesu8" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6d43a04d8753f35258c91f8ec639f792891f748a1edbd759cf1dcea3382ad83c" - -[[package]] -name = "cfg-if" -version = "1.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" - -[[package]] -name = "chrono" -version = "0.4.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f2c685bad3eb3d45a01354cedb7d5faa66194d1d58ba6e267a8de788f79db38" -dependencies = [ - "num-traits", -] - -[[package]] -name = "cipher" -version = "0.4.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "773f3b9af64447d2ce9850330c473515014aa235e6a783b02db81ff39e4a3dad" -dependencies = [ - "crypto-common", - "inout", -] - -[[package]] -name = "clap" -version = "2.34.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0610544180c38b88101fecf2dd634b174a62eef6946f84dfc6a7127512b381c" -dependencies = [ - "bitflags 1.3.2", - "textwrap", - "unicode-width", -] - -[[package]] -name = "coins-bip32" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3b6be4a5df2098cd811f3194f64ddb96c267606bffd9689ac7b0160097b01ad3" -dependencies = [ - "bs58", - "coins-core", - "digest", - "hmac", - "k256", - "serde", - "sha2", - "thiserror", -] - -[[package]] -name = "coins-bip39" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3db8fba409ce3dc04f7d804074039eb68b960b0829161f8e06c95fea3f122528" -dependencies = [ - "bitvec", - "coins-bip32", - "hmac", - "once_cell", - "pbkdf2 0.12.2", - "rand", - "sha2", - "thiserror", -] - -[[package]] -name = "coins-core" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5286a0843c21f8367f7be734f89df9b822e0321d8bcce8d6e735aadff7d74979" -dependencies = [ - "base64 0.21.5", - "bech32", - "bs58", - "digest", - "generic-array", - "hex", - "ripemd", - "serde", - "serde_derive", - "sha2", - "sha3", - "thiserror", -] - -[[package]] -name = "color-eyre" -version = "0.6.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5a667583cca8c4f8436db8de46ea8233c42a7d9ae424a82d338f2e4675229204" -dependencies = [ - "backtrace", - "color-spantrace", - "eyre", - "indenter", - "once_cell", - "owo-colors", - "tracing-error", -] - -[[package]] -name = "color-spantrace" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd6be1b2a7e382e2b98b43b2adcca6bb0e465af0bdd38123873ae61eb17a72c2" -dependencies = [ - "once_cell", - "owo-colors", - "tracing-core", - "tracing-error", -] - -[[package]] -name = "combine" -version = "4.6.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "35ed6e9d84f0b51a7f52daf1c7d71dd136fd7a3f41a8462b8cdb8c78d920fad4" -dependencies = [ - "bytes", - "memchr", -] - -[[package]] -name = "const-oid" -version = "0.9.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2459377285ad874054d797f3ccebf984978aa39129f6eafde5cdc8315b612f8" - -[[package]] -name = "constant_time_eq" -version = "0.1.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "245097e9a4535ee1e3e3931fcfcd55a796a44c643e8596ff6566d68f09b87bbc" - -[[package]] -name = "core-foundation" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91e195e091a93c46f7102ec7818a2aa394e1e1771c3ab4825963fa03e45afb8f" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "core-foundation-sys" -version = "0.8.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "06ea2b9bc92be3c2baa9334a323ebca2d6f074ff852cd1d7b11064035cd3868f" - -[[package]] -name = "corosensei" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "80128832c58ea9cbd041d2a759ec449224487b2c1e400453d99d244eead87a8e" -dependencies = [ - "autocfg", - "cfg-if", - "libc", - "scopeguard", - "windows-sys 0.33.0", -] - -[[package]] -name = "cpufeatures" -version = "0.2.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce420fe07aecd3e67c5f910618fe65e94158f6dcc0adf44e00d69ce2bdfe0fd0" -dependencies = [ - "libc", -] - -[[package]] -name = "cranelift-bforest" -version = "0.82.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38faa2a16616c8e78a18d37b4726b98bfd2de192f2fdc8a39ddf568a408a0f75" -dependencies = [ - "cranelift-entity", -] - -[[package]] -name = "cranelift-codegen" -version = "0.82.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26f192472a3ba23860afd07d2b0217dc628f21fcc72617aa1336d98e1671f33b" -dependencies = [ - "cranelift-bforest", - "cranelift-codegen-meta", - "cranelift-codegen-shared", - "cranelift-entity", - "gimli 0.26.2", - "log", - "regalloc", - "smallvec", - "target-lexicon", -] - -[[package]] -name = "cranelift-codegen-meta" -version = "0.82.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0f32ddb89e9b89d3d9b36a5b7d7ea3261c98235a76ac95ba46826b8ec40b1a24" -dependencies = [ - "cranelift-codegen-shared", -] - -[[package]] -name = "cranelift-codegen-shared" -version = "0.82.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "01fd0d9f288cc1b42d9333b7a776b17e278fc888c28e6a0f09b5573d45a150bc" - -[[package]] -name = "cranelift-entity" -version = "0.82.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e3bfe172b83167604601faf9dc60453e0d0a93415b57a9c4d1a7ae6849185cf" - -[[package]] -name = "cranelift-frontend" -version = "0.82.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a006e3e32d80ce0e4ba7f1f9ddf66066d052a8c884a110b91d05404d6ce26dce" -dependencies = [ - "cranelift-codegen", - "log", - "smallvec", - "target-lexicon", -] - -[[package]] -name = "crc32fast" -version = "1.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b540bd8bc810d3885c6ea91e2018302f68baba2129ab3e88f32389ee9370880d" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "criterion" -version = "0.3.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b01d6de93b2b6c65e17c634a26653a29d107b3c98c607c765bf38d041531cd8f" -dependencies = [ - "atty", - "cast", - "clap", - "criterion-plot", - "csv", - "itertools", - "lazy_static 1.4.0", - "num-traits", - "oorandom", - "plotters", - "rayon", - "regex", - "serde", - "serde_cbor", - "serde_derive", - "serde_json", - "tinytemplate", - "walkdir", -] - -[[package]] -name = "criterion-plot" -version = "0.4.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2673cc8207403546f45f5fd319a974b1e6983ad1a3ee7e6041650013be041876" -dependencies = [ - "cast", - "itertools", -] - -[[package]] -name = "crossbeam-deque" -version = "0.8.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fca89a0e215bab21874660c67903c5f143333cab1da83d041c7ded6053774751" -dependencies = [ - "cfg-if", - "crossbeam-epoch", - "crossbeam-utils", -] - -[[package]] -name = "crossbeam-epoch" -version = "0.9.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e3681d554572a651dda4186cd47240627c3d0114d45a95f6ad27f2f22e7548d" -dependencies = [ - "autocfg", - "cfg-if", - "crossbeam-utils", -] - -[[package]] -name = "crossbeam-utils" -version = "0.8.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3a430a770ebd84726f584a90ee7f020d28db52c6d02138900f22341f866d39c" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "crunchy" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" - -[[package]] -name = "crypto-bigint" -version = "0.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0dc92fb57ca44df6db8059111ab3af99a63d5d0f8375d9972e319a379c6bab76" -dependencies = [ - "generic-array", - "rand_core", - "subtle", - "zeroize", -] - -[[package]] -name = "crypto-common" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1bfb12502f3fc46cca1bb51ac28df9d618d813cdc3d2f25b9fe775a34af26bb3" -dependencies = [ - "generic-array", - "typenum", -] - -[[package]] -name = "csv" -version = "1.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe" -dependencies = [ - "csv-core", - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "csv-core" -version = "0.1.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70" -dependencies = [ - "memchr", -] - -[[package]] -name = "ctr" -version = "0.9.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0369ee1ad671834580515889b80f2ea915f23b8be8d0daa4bbaf2ac5c7590835" -dependencies = [ - "cipher", -] - -[[package]] -name = "darling" -version = "0.20.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0209d94da627ab5605dcccf08bb18afa5009cfbef48d8a8b7d7bdbc79be25c5e" -dependencies = [ - "darling_core", - "darling_macro", -] - -[[package]] -name = "darling_core" -version = "0.20.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "177e3443818124b357d8e76f53be906d60937f0d3a90773a664fa63fa253e621" -dependencies = [ - "fnv", - "ident_case", - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "darling_macro" -version = "0.20.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "836a9bbc7ad63342d6d6e7b815ccab164bc77a2d95d84bc3117a8c0d5c98e2d5" -dependencies = [ - "darling_core", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "data-encoding" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e962a19be5cfc3f3bf6dd8f61eb50107f356ad6270fbb3ed41476571db78be5" - -[[package]] -name = "der" -version = "0.7.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fffa369a668c8af7dbf8b5e56c9f744fbd399949ed171606040001947de40b1c" -dependencies = [ - "const-oid", - "zeroize", -] - -[[package]] -name = "deranged" -version = "0.3.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4" -dependencies = [ - "powerfmt", -] - -[[package]] -name = "derivative" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fcc3dd5e9e9c0b295d6e1e4d811fb6f157d5ffd784b8d202fc62eac8035a770b" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "derive_more" -version = "0.99.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "diff" -version = "0.1.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56254986775e3233ffa9c4d7d3faaf6d36a2c09d30b20687e9f88bc8bafc16c8" - -[[package]] -name = "digest" -version = "0.10.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ed9a281f7bc9b7576e61468ba615a66a5c8cfdff42420a70aa82701a3b1e292" -dependencies = [ - "block-buffer", - "const-oid", - "crypto-common", - "subtle", -] - -[[package]] -name = "dirs-next" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b98cf8ebf19c3d1b223e151f99a4f9f0690dca41414773390fc824184ac833e1" -dependencies = [ - "cfg-if", - "dirs-sys-next", -] - -[[package]] -name = "dirs-sys-next" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4ebda144c4fe02d1f7ea1a7d9641b6fc6b580adcfa024ae48797ecdeb6825b4d" -dependencies = [ - "libc", - "redox_users", - "winapi", -] - -[[package]] -name = "dunce" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56ce8c6da7551ec6c462cbaf3bfbc75131ebbfa1c944aeaa9dab51ca1c5f0c3b" - -[[package]] -name = "ecdsa" -version = "0.16.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee27f32b5c5292967d2d4a9d7f1e0b0aed2c15daded5a60300e4abb9d8020bca" -dependencies = [ - "der", - "digest", - "elliptic-curve", - "rfc6979", - "signature", - "spki", -] - -[[package]] -name = "either" -version = "1.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a26ae43d7bcc3b814de94796a5e736d4029efb0ee900c12e2d54c993ad1a1e07" - -[[package]] -name = "elliptic-curve" -version = "0.13.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e6043086bf7973472e0c7dff2142ea0b680d30e18d9cc40f267efbf222bd47" -dependencies = [ - "base16ct", - "crypto-bigint", - "digest", - "ff", - "generic-array", - "group", - "pkcs8", - "rand_core", - "sec1", - "subtle", - "zeroize", -] - -[[package]] -name = "ena" -version = "0.14.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c533630cf40e9caa44bd91aadc88a75d75a4c3a12b4cfde353cbed41daa1e1f1" -dependencies = [ - "log", -] - -[[package]] -name = "encoding_rs" -version = "0.8.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "enr" -version = "0.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cf56acd72bb22d2824e66ae8e9e5ada4d0de17a69c7fd35569dde2ada8ec9116" -dependencies = [ - "base64 0.13.1", - "bytes", - "hex", - "k256", - "log", - "rand", - "rlp", - "serde", - "sha3", - "zeroize", -] - -[[package]] -name = "enum-iterator" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4eeac5c5edb79e4e39fe8439ef35207780a11f69c52cbe424ce3dfad4cb78de6" -dependencies = [ - "enum-iterator-derive", -] - -[[package]] -name = "enum-iterator-derive" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c134c37760b27a871ba422106eedbb8247da973a09e82558bf26d619c882b159" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "enumset" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "226c0da7462c13fb57e5cc9e0dc8f0635e7d27f276a3a7fd30054647f669007d" -dependencies = [ - "enumset_derive", -] - -[[package]] -name = "enumset_derive" -version = "0.8.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e08b6c6ab82d70f08844964ba10c7babb716de2ecaeab9be5717918a5177d3af" -dependencies = [ - "darling", - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "env_logger" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "44533bbbb3bb3c1fa17d9f2e4e38bbbaf8396ba82193c4cb1b6445d711445d36" -dependencies = [ - "log", - "regex", -] - -[[package]] -name = "equivalent" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" - -[[package]] -name = "errno" -version = "0.3.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a258e46cdc063eb8519c00b9fc845fc47bcfca4130e2f08e88665ceda8474245" -dependencies = [ - "libc", - "windows-sys 0.52.0", -] - -[[package]] -name = "eth-keystore" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fda3bf123be441da5260717e0661c25a2fd9cb2b2c1d20bf2e05580047158ab" -dependencies = [ - "aes", - "ctr", - "digest", - "hex", - "hmac", - "pbkdf2 0.11.0", - "rand", - "scrypt", - "serde", - "serde_json", - "sha2", - "sha3", - "thiserror", - "uuid 0.8.2", -] - -[[package]] -name = "ethabi" -version = "18.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7413c5f74cc903ea37386a8965a936cbeb334bd270862fdece542c1b2dcbc898" -dependencies = [ - "ethereum-types", - "hex", - "once_cell", - "regex", - "serde", - "serde_json", - "sha3", - "thiserror", - "uint", -] - -[[package]] -name = "ethbloom" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c22d4b5885b6aa2fe5e8b9329fb8d232bf739e434e6b87347c63bdd00c120f60" -dependencies = [ - "crunchy", - "fixed-hash", - "impl-codec", - "impl-rlp", - "impl-serde", - "scale-info", - "tiny-keccak", -] - -[[package]] -name = "ethereum-types" -version = "0.14.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02d215cbf040552efcbe99a38372fe80ab9d00268e20012b79fcd0f073edd8ee" -dependencies = [ - "ethbloom", - "fixed-hash", - "impl-codec", - "impl-rlp", - "impl-serde", - "primitive-types", - "scale-info", - "uint", -] - -[[package]] -name = "ethers" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2a58ce802c65cf3d0756dee5a61094a92cde53c1583b246e9ee5b37226c7fc15" -dependencies = [ - "ethers-addressbook", - "ethers-contract", - "ethers-core", - "ethers-etherscan", - "ethers-middleware", - "ethers-providers", - "ethers-signers", - "ethers-solc", -] - -[[package]] -name = "ethers-addressbook" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b856b7b8ff5c961093cb8efe151fbcce724b451941ce20781de11a531ccd578" -dependencies = [ - "ethers-core", - "once_cell", - "serde", - "serde_json", -] - -[[package]] -name = "ethers-contract" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e066a0d9cfc70c454672bf16bb433b0243427420076dc5b2f49c448fb5a10628" -dependencies = [ - "ethers-contract-abigen", - "ethers-contract-derive", - "ethers-core", - "ethers-providers", - "futures-util", - "hex", - "once_cell", - "pin-project", - "serde", - "serde_json", - "thiserror", -] - -[[package]] -name = "ethers-contract-abigen" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c113e3e86b6bc16d98484b2c3bb2d01d6fed9f489fe2e592e5cc87c3024d616b" -dependencies = [ - "Inflector", - "dunce", - "ethers-core", - "ethers-etherscan", - "eyre", - "hex", - "prettyplease", - "proc-macro2", - "quote", - "regex", - "reqwest", - "serde", - "serde_json", - "syn 2.0.43", - "toml", - "walkdir", -] - -[[package]] -name = "ethers-contract-derive" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c3fb5adee25701c79ec58fcf2c63594cd8829bc9ad6037ff862d5a111101ed2" -dependencies = [ - "Inflector", - "ethers-contract-abigen", - "ethers-core", - "hex", - "proc-macro2", - "quote", - "serde_json", - "syn 2.0.43", -] - -[[package]] -name = "ethers-core" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6da5fa198af0d3be20c19192df2bd9590b92ce09a8421e793bec8851270f1b05" -dependencies = [ - "arrayvec", - "bytes", - "cargo_metadata", - "chrono", - "elliptic-curve", - "ethabi", - "generic-array", - "hex", - "k256", - "num_enum", - "once_cell", - "open-fastrlp", - "rand", - "rlp", - "serde", - "serde_json", - "strum", - "syn 2.0.43", - "tempfile", - "thiserror", - "tiny-keccak", - "unicode-xid", -] - -[[package]] -name = "ethers-etherscan" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "84ebb401ba97c6f5af278c2c9936c4546cad75dec464b439ae6df249906f4caa" -dependencies = [ - "ethers-core", - "reqwest", - "semver", - "serde", - "serde_json", - "thiserror", - "tracing", -] - -[[package]] -name = "ethers-middleware" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "740f4a773c19dd6d6a68c8c2e0996c096488d38997d524e21dc612c55da3bd24" -dependencies = [ - "async-trait", - "auto_impl", - "ethers-contract", - "ethers-core", - "ethers-etherscan", - "ethers-providers", - "ethers-signers", - "futures-channel", - "futures-locks", - "futures-util", - "instant", - "reqwest", - "serde", - "serde_json", - "thiserror", - "tokio", - "tracing", - "tracing-futures", - "url", -] - -[[package]] -name = "ethers-providers" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "56b498fd2a6c019d023e43e83488cd1fb0721f299055975aa6bac8dbf1e95f2c" -dependencies = [ - "async-trait", - "auto_impl", - "base64 0.21.5", - "bytes", - "enr", - "ethers-core", - "futures-core", - "futures-timer", - "futures-util", - "hashers", - "hex", - "http", - "instant", - "once_cell", - "pin-project", - "reqwest", - "serde", - "serde_json", - "thiserror", - "tokio", - "tokio-tungstenite", - "tracing", - "tracing-futures", - "url", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", - "ws_stream_wasm", -] - -[[package]] -name = "ethers-signers" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "02c4b7e15f212fa7cc2e1251868320221d4ff77a3d48068e69f47ce1c491df2d" -dependencies = [ - "async-trait", - "coins-bip32", - "coins-bip39", - "elliptic-curve", - "eth-keystore", - "ethers-core", - "hex", - "rand", - "sha2", - "thiserror", - "tracing", -] - -[[package]] -name = "ethers-solc" -version = "2.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a81c89f121595cf8959e746045bb8b25a6a38d72588561e1a3b7992fc213f674" -dependencies = [ - "cfg-if", - "dunce", - "ethers-core", - "glob", - "hex", - "home", - "md-5", - "num_cpus", - "once_cell", - "path-slash", - "rayon", - "regex", - "semver", - "serde", - "serde_json", - "solang-parser", - "svm-rs", - "thiserror", - "tiny-keccak", - "tokio", - "tracing", - "walkdir", - "yansi", -] - -[[package]] -name = "eyre" -version = "0.6.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6267a1fa6f59179ea4afc8e50fd8612a3cc60bc858f786ff877a4a8cb042799" -dependencies = [ - "indenter", - "once_cell", -] - -[[package]] -name = "fallible-iterator" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4443176a9f2c162692bd3d352d745ef9413eec5782a80d8fd6f8a1ac692a07f7" - -[[package]] -name = "fastrand" -version = "2.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25cbce373ec4653f1a01a31e8a5e5ec0c622dc27ff9c4e6606eefef5cbbed4a5" - -[[package]] -name = "ff" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ded41244b729663b1e574f1b4fb731469f69f79c17667b5d776b16cda0479449" -dependencies = [ - "rand_core", - "subtle", -] - -[[package]] -name = "fixed-hash" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "835c052cb0c08c1acf6ffd71c022172e18723949c8282f2b9f27efbc51e64534" -dependencies = [ - "byteorder", - "rand", - "rustc-hex", - "static_assertions", -] - -[[package]] -name = "fixedbitset" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ce7134b9999ecaf8bcd65542e436736ef32ddca1b3e06094cb6ec5755203b80" - -[[package]] -name = "flame" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1fc2706461e1ee94f55cab2ed2e3d34ae9536cfa830358ef80acff1a3dacab30" -dependencies = [ - "lazy_static 0.2.11", - "serde", - "serde_derive", - "serde_json", - "thread-id", -] - -[[package]] -name = "flamer" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7693d9dd1ec1c54f52195dfe255b627f7cec7da33b679cd56de949e662b3db10" -dependencies = [ - "flame", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "flate2" -version = "1.0.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "46303f565772937ffe1d394a4fac6f411c6013172fadde9dcdb1e147a086940e" -dependencies = [ - "crc32fast", - "miniz_oxide", -] - -[[package]] -name = "fnv" -version = "1.0.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1" - -[[package]] -name = "form_urlencoded" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456" -dependencies = [ - "percent-encoding", -] - -[[package]] -name = "fs2" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9564fc758e15025b46aa6643b1b77d047d1a56a1aea6e01002ac0c7026876213" -dependencies = [ - "libc", - "winapi", -] - -[[package]] -name = "funty" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c" - -[[package]] -name = "futures" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "645c6916888f6cb6350d2550b80fb63e734897a8498abe35cfb732b6487804b0" -dependencies = [ - "futures-channel", - "futures-core", - "futures-executor", - "futures-io", - "futures-sink", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-channel" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eac8f7d7865dcb88bd4373ab671c8cf4508703796caa2b1985a9ca867b3fcb78" -dependencies = [ - "futures-core", - "futures-sink", -] - -[[package]] -name = "futures-core" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dfc6580bb841c5a68e9ef15c77ccc837b40a7504914d52e47b8b0e9bbda25a1d" - -[[package]] -name = "futures-executor" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a576fc72ae164fca6b9db127eaa9a9dda0d61316034f33a0a0d4eda41f02b01d" -dependencies = [ - "futures-core", - "futures-task", - "futures-util", -] - -[[package]] -name = "futures-io" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a44623e20b9681a318efdd71c299b6b222ed6f231972bfe2f224ebad6311f0c1" - -[[package]] -name = "futures-locks" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "45ec6fe3675af967e67c5536c0b9d44e34e6c52f86bedc4ea49c5317b8e94d06" -dependencies = [ - "futures-channel", - "futures-task", -] - -[[package]] -name = "futures-macro" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87750cf4b7a4c0625b1529e4c543c2182106e4dedc60a2a6455e00d212c489ac" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "futures-sink" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9fb8e00e87438d937621c1c6269e53f536c14d3fbd6a042bb24879e57d474fb5" - -[[package]] -name = "futures-task" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38d84fa142264698cdce1a9f9172cf383a0c82de1bddcf3092901442c4097004" - -[[package]] -name = "futures-timer" -version = "3.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e64b03909df88034c26dc1547e8970b91f98bdb65165d6a4e9110d94263dbb2c" -dependencies = [ - "gloo-timers", - "send_wrapper 0.4.0", -] - -[[package]] -name = "futures-util" -version = "0.3.30" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d6401deb83407ab3da39eba7e33987a73c3df0c82b4bb5813ee871c19c41d48" -dependencies = [ - "futures-channel", - "futures-core", - "futures-io", - "futures-macro", - "futures-sink", - "futures-task", - "memchr", - "pin-project-lite", - "pin-utils", - "slab", -] - -[[package]] -name = "fxhash" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c31b6d751ae2c7f11320402d34e41349dd1016f8d5d45e48c4312bc8625af50c" -dependencies = [ - "byteorder", -] - -[[package]] -name = "generic-array" -version = "0.14.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85649ca51fd72272d7821adaf274ad91c288277713d9c18820d8499a7ff69e9a" -dependencies = [ - "typenum", - "version_check", - "zeroize", -] - -[[package]] -name = "getrandom" -version = "0.2.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fe9006bed769170c11f845cf00c7c1e9092aeb3f268e007c3e760ac68008070f" -dependencies = [ - "cfg-if", - "libc", - "wasi", -] - -[[package]] -name = "gimli" -version = "0.26.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d" -dependencies = [ - "fallible-iterator", - "indexmap 1.9.3", - "stable_deref_trait", -] - -[[package]] -name = "gimli" -version = "0.28.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4271d37baee1b8c7e4b708028c57d816cf9d2434acb33a549475f78c181f6253" - -[[package]] -name = "glob" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b" - -[[package]] -name = "gloo-timers" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b995a66bb87bebce9a0f4a95aed01daca4872c050bfcb21653361c03bc35e5c" -dependencies = [ - "futures-channel", - "futures-core", - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "group" -version = "0.13.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0f9ef7462f7c099f518d754361858f86d8a07af53ba9af0fe635bbccb151a63" -dependencies = [ - "ff", - "rand_core", - "subtle", -] - -[[package]] -name = "h2" -version = "0.3.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4d6250322ef6e60f93f9a2162799302cd6f68f79f6e5d85c8c16f14d1d958178" -dependencies = [ - "bytes", - "fnv", - "futures-core", - "futures-sink", - "futures-util", - "http", - "indexmap 2.1.0", - "slab", - "tokio", - "tokio-util", - "tracing", -] - -[[package]] -name = "half" -version = "1.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eabb4a44450da02c90444cf74558da904edde8fb4e9035a9a6a4e15445af0bd7" - -[[package]] -name = "hashbrown" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ab5ef0d4909ef3724cc8cce6ccc8572c5c817592e9285f5464f8e86f8bd3726e" -dependencies = [ - "ahash 0.7.7", -] - -[[package]] -name = "hashbrown" -version = "0.12.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888" -dependencies = [ - "ahash 0.7.7", -] - -[[package]] -name = "hashbrown" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43a3c133739dddd0d2990f9a4bdf8eb4b21ef50e4851ca85ab661199821d510e" -dependencies = [ - "ahash 0.8.7", -] - -[[package]] -name = "hashbrown" -version = "0.14.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" - -[[package]] -name = "hashers" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b2bca93b15ea5a746f220e56587f71e73c6165eab783df9e26590069953e3c30" -dependencies = [ - "fxhash", -] - -[[package]] -name = "heck" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8" - -[[package]] -name = "hermit-abi" -version = "0.1.19" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33" -dependencies = [ - "libc", -] - -[[package]] -name = "hermit-abi" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d77f7ec81a6d05a3abb01ab6eb7590f6083d08449fe5a1c8b1e620283546ccb7" - -[[package]] -name = "hex" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70" - -[[package]] -name = "hmac" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6c49c37c09c17a53d937dfbb742eb3a961d65a994e6bcdcf37e7399d0cc8ab5e" -dependencies = [ - "digest", -] - -[[package]] -name = "home" -version = "0.5.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5" -dependencies = [ - "windows-sys 0.52.0", -] - -[[package]] -name = "http" -version = "0.2.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8947b1a6fad4393052c7ba1f4cd97bed3e953a95c79c92ad9b051a04611d9fbb" -dependencies = [ - "bytes", - "fnv", - "itoa", -] - -[[package]] -name = "http-body" -version = "0.4.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ceab25649e9960c0311ea418d17bee82c0dcec1bd053b5f9a66e265a693bed2" -dependencies = [ - "bytes", - "http", - "pin-project-lite", -] - -[[package]] -name = "httparse" -version = "1.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d897f394bad6a705d5f4104762e116a75639e470d80901eed05a860a95cb1904" - -[[package]] -name = "httpdate" -version = "1.0.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9" - -[[package]] -name = "hyper" -version = "0.14.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf96e135eb83a2a8ddf766e426a841d8ddd7449d5f00d34ea02b41d2f19eef80" -dependencies = [ - "bytes", - "futures-channel", - "futures-core", - "futures-util", - "h2", - "http", - "http-body", - "httparse", - "httpdate", - "itoa", - "pin-project-lite", - "socket2", - "tokio", - "tower-service", - "tracing", - "want", -] - -[[package]] -name = "hyper-rustls" -version = "0.24.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec3efd23720e2049821a693cbc7e65ea87c72f1c58ff2f9522ff332b1491e590" -dependencies = [ - "futures-util", - "http", - "hyper", - "rustls", - "tokio", - "tokio-rustls", -] - -[[package]] -name = "ident_case" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b9e0384b61958566e926dc50660321d12159025e767c18e043daf26b70104c39" - -[[package]] -name = "idna" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6" -dependencies = [ - "unicode-bidi", - "unicode-normalization", -] - -[[package]] -name = "impl-codec" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba6a270039626615617f3f36d15fc827041df3b78c439da2cadfa47455a77f2f" -dependencies = [ - "parity-scale-codec", -] - -[[package]] -name = "impl-rlp" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f28220f89297a075ddc7245cd538076ee98b01f2a9c23a53a4f1105d5a322808" -dependencies = [ - "rlp", -] - -[[package]] -name = "impl-serde" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebc88fc67028ae3db0c853baa36269d398d5f45b6982f95549ff5def78c935cd" -dependencies = [ - "serde", -] - -[[package]] -name = "impl-trait-for-tuples" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "indenter" -version = "0.3.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce23b50ad8242c51a442f3ff322d56b02f08852c77e4c0b4d3fd684abc89c683" - -[[package]] -name = "indexmap" -version = "1.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd070e393353796e801d209ad339e89596eb4c8d430d18ede6a1cced8fafbd99" -dependencies = [ - "autocfg", - "hashbrown 0.12.3", - "serde", -] - -[[package]] -name = "indexmap" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d530e1a18b1cb4c484e6e34556a0d948706958449fca0cab753d649f2bce3d1f" -dependencies = [ - "equivalent", - "hashbrown 0.14.3", -] - -[[package]] -name = "inout" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a0c10553d664a4d0bcff9f4215d0aac67a639cc68ef660840afe309b807bc9f5" -dependencies = [ - "generic-array", -] - -[[package]] -name = "instant" -version = "0.1.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a5bbe824c507c5da5956355e86a746d82e0e1464f65d862cc5e71da70e94b2c" -dependencies = [ - "cfg-if", -] - -[[package]] -name = "ipnet" -version = "2.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f518f335dce6725a761382244631d86cf0ccb2863413590b31338feb467f9c3" - -[[package]] -name = "is-terminal" -version = "0.4.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0bad00257d07be169d870ab665980b06cdb366d792ad690bf2e76876dc503455" -dependencies = [ - "hermit-abi 0.3.3", - "rustix", - "windows-sys 0.52.0", -] - -[[package]] -name = "itertools" -version = "0.10.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b0fd2260e829bddf4cb6ea802289de2f86d6a7a690192fbe91b3f46e0f2c8473" -dependencies = [ - "either", -] - -[[package]] -name = "itoa" -version = "1.0.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c" - -[[package]] -name = "jni" -version = "0.18.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "24967112a1e4301ca5342ea339763613a37592b8a6ce6cf2e4494537c7a42faf" -dependencies = [ - "cesu8", - "combine", - "jni-sys", - "log", - "thiserror", - "walkdir", -] - -[[package]] -name = "jni-sys" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8eaf4bc02d17cbdd7ff4c7438cafcdf7fb9a4613313ad11b4f8fefe7d3fa0130" - -[[package]] -name = "jobserver" -version = "0.1.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8c37f63953c4c63420ed5fd3d6d398c719489b9f872b9fa683262f8edd363c7d" -dependencies = [ - "libc", -] - -[[package]] -name = "js-sys" -version = "0.3.66" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cee9c64da59eae3b50095c18d3e74f8b73c0b86d2792824ff01bbce68ba229ca" -dependencies = [ - "wasm-bindgen", -] - -[[package]] -name = "k256" -version = "0.13.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3f01b677d82ef7a676aa37e099defd83a28e15687112cafdd112d60236b6115b" -dependencies = [ - "cfg-if", - "ecdsa", - "elliptic-curve", - "once_cell", - "sha2", - "signature", -] - -[[package]] -name = "keccak" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f6d5ed8676d904364de097082f4e7d240b571b67989ced0240f08b7f966f940" -dependencies = [ - "cpufeatures", -] - -[[package]] -name = "lalrpop" -version = "0.19.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0a1cbf952127589f2851ab2046af368fd20645491bb4b376f04b7f94d7a9837b" -dependencies = [ - "ascii-canvas", - "bit-set", - "diff", - "ena", - "is-terminal", - "itertools", - "lalrpop-util", - "petgraph", - "regex", - "regex-syntax 0.6.29", - "string_cache", - "term", - "tiny-keccak", - "unicode-xid", -] - -[[package]] -name = "lalrpop-util" -version = "0.19.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3c48237b9604c5a4702de6b824e02006c3214327564636aef27c1028a8fa0ed" - -[[package]] -name = "lazy_static" -version = "0.2.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76f033c7ad61445c5b347c7382dd1237847eb1bce590fe50365dcb33d546be73" - -[[package]] -name = "lazy_static" -version = "1.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646" - -[[package]] -name = "leb128" -version = "0.2.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "884e2677b40cc8c339eaefcb701c32ef1fd2493d71118dc0ca4b6a736c93bd67" - -[[package]] -name = "libc" -version = "0.2.151" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "302d7ab3130588088d277783b1e2d2e10c9e9e4a16dd9050e6ec93fb3e7048f4" - -[[package]] -name = "libloading" -version = "0.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b67380fd3b2fbe7527a606e18729d21c6f3951633d0500574c4dc22d2d638b9f" -dependencies = [ - "cfg-if", - "winapi", -] - -[[package]] -name = "libredox" -version = "0.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "85c833ca1e66078851dba29046874e38f08b2c883700aa29a03ddd3b23814ee8" -dependencies = [ - "bitflags 2.4.1", - "libc", - "redox_syscall 0.4.1", -] - -[[package]] -name = "linux-raw-sys" -version = "0.4.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c4cd1a83af159aa67994778be9070f0ae1bd732942279cabb14f86f986a21456" - -[[package]] -name = "lock_api" -version = "0.4.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3c168f8615b12bc01f9c17e2eb0cc07dcae1940121185446edc3744920e8ef45" -dependencies = [ - "autocfg", - "scopeguard", -] - -[[package]] -name = "log" -version = "0.4.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5e6163cb8c49088c2c36f57875e58ccd8c87c7427f7fbd50ea6710b2f3f2e8f" - -[[package]] -name = "loupe" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9b6a72dfa44fe15b5e76b94307eeb2ff995a8c5b283b55008940c02e0c5b634d" -dependencies = [ - "indexmap 1.9.3", - "loupe-derive", - "rustversion", -] - -[[package]] -name = "loupe-derive" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c0fbfc88337168279f2e9ae06e157cfed4efd3316e14dc96ed074d4f2e6c5952" -dependencies = [ - "quote", - "syn 1.0.109", -] - -[[package]] -name = "mach" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b823e83b2affd8f40a9ee8c29dbc56404c1e34cd2710921f2801e2cf29527afa" -dependencies = [ - "libc", -] - -[[package]] -name = "md-5" -version = "0.10.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d89e7ee0cfbedfc4da3340218492196241d89eefb6dab27de5df917a6d2e78cf" -dependencies = [ - "cfg-if", - "digest", -] - -[[package]] -name = "memchr" -version = "2.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149" - -[[package]] -name = "memmap2" -version = "0.5.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83faa42c0a078c393f6b29d5db232d8be22776a891f8f56e5284faee4a20b327" -dependencies = [ - "libc", -] - -[[package]] -name = "memmap2" -version = "0.9.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "45fd3a57831bf88bc63f8cebc0cf956116276e97fef3966103e96416209f7c92" -dependencies = [ - "libc", -] - -[[package]] -name = "memoffset" -version = "0.6.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5aa361d4faea93603064a027415f07bd8e1d5c88c9fbf68bf56a285428fd79ce" -dependencies = [ - "autocfg", -] - -[[package]] -name = "mime" -version = "0.3.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a" - -[[package]] -name = "miniz_oxide" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e7810e0be55b428ada41041c41f32c9f1a42817901b4ccf45fa3d4b6561e74c7" -dependencies = [ - "adler", -] - -[[package]] -name = "mio" -version = "0.8.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09" -dependencies = [ - "libc", - "wasi", - "windows-sys 0.48.0", -] - -[[package]] -name = "more-asserts" -version = "0.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7843ec2de400bcbc6a6328c958dc38e5359da6e93e72e37bc5246bf1ae776389" - -[[package]] -name = "new_debug_unreachable" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54" - -[[package]] -name = "num" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43db66d1170d347f9a065114077f7dccb00c1b9478c89384490a3425279a4606" -dependencies = [ - "num-bigint", - "num-complex", - "num-integer", - "num-iter", - "num-rational", - "num-traits", -] - -[[package]] -name = "num-bigint" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f" -dependencies = [ - "autocfg", - "num-integer", - "num-traits", - "rand", -] - -[[package]] -name = "num-complex" -version = "0.4.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1ba157ca0885411de85d6ca030ba7e2a83a28636056c7c699b07c8b6f7383214" -dependencies = [ - "num-traits", -] - -[[package]] -name = "num-integer" -version = "0.1.45" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9" -dependencies = [ - "autocfg", - "num-traits", -] - -[[package]] -name = "num-iter" -version = "0.1.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7d03e6c028c5dc5cac6e2dec0efda81fc887605bb3d884578bb6d6bf7514e252" -dependencies = [ - "autocfg", - "num-integer", - "num-traits", -] - -[[package]] -name = "num-rational" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0638a1c9d0a3c0914158145bc76cff373a75a627e6ecbfb71cbe6f453a5a19b0" -dependencies = [ - "autocfg", - "num-bigint", - "num-integer", - "num-traits", -] - -[[package]] -name = "num-traits" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" -dependencies = [ - "autocfg", -] - -[[package]] -name = "num_cpus" -version = "1.16.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4161fcb6d602d4d2081af7c3a45852d875a03dd337a6bfdd6e06407b61342a43" -dependencies = [ - "hermit-abi 0.3.3", - "libc", -] - -[[package]] -name = "num_enum" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7a015b430d3c108a207fd776d2e2196aaf8b1cf8cf93253e3a097ff3085076a1" -dependencies = [ - "num_enum_derive", -] - -[[package]] -name = "num_enum_derive" -version = "0.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "96667db765a921f7b295ffee8b60472b686a51d4f21c2ee4ffdb94c7013b65a6" -dependencies = [ - "proc-macro-crate 1.3.1", - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "object" -version = "0.28.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e42c982f2d955fac81dd7e1d0e1426a7d702acd9c98d19ab01083a6a0328c424" -dependencies = [ - "crc32fast", - "hashbrown 0.11.2", - "indexmap 1.9.3", - "memchr", -] - -[[package]] -name = "object" -version = "0.32.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a6a622008b6e321afc04970976f62ee297fdbaa6f95318ca343e3eebb9648441" -dependencies = [ - "memchr", -] - -[[package]] -name = "once_cell" -version = "1.19.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" - -[[package]] -name = "oorandom" -version = "11.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ab1bc2a289d34bd04a330323ac98a1b4bc82c9d9fcb1e66b63caa84da26b575" - -[[package]] -name = "open-fastrlp" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "786393f80485445794f6043fd3138854dd109cc6c4bd1a6383db304c9ce9b9ce" -dependencies = [ - "arrayvec", - "auto_impl", - "bytes", - "ethereum-types", - "open-fastrlp-derive", -] - -[[package]] -name = "open-fastrlp-derive" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "003b2be5c6c53c1cfeb0a238b8a1c3915cd410feb684457a36c10038f764bb1c" -dependencies = [ - "bytes", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "owo-colors" -version = "3.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1b04fb49957986fdce4d6ee7a65027d55d4b6d2265e5848bbb507b58ccfdb6f" - -[[package]] -name = "parity-scale-codec" -version = "3.6.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "881331e34fa842a2fb61cc2db9643a8fedc615e47cfcc52597d1af0db9a7e8fe" -dependencies = [ - "arrayvec", - "bitvec", - "byte-slice-cast", - "impl-trait-for-tuples", - "parity-scale-codec-derive", - "serde", -] - -[[package]] -name = "parity-scale-codec-derive" -version = "3.6.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be30eaf4b0a9fba5336683b38de57bb86d179a35862ba6bfcf57625d006bde5b" -dependencies = [ - "proc-macro-crate 2.0.0", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "parking_lot" -version = "0.12.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f" -dependencies = [ - "lock_api", - "parking_lot_core", -] - -[[package]] -name = "parking_lot_core" -version = "0.9.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4c42a9226546d68acdd9c0a280d17ce19bfe27a46bf68784e4066115788d008e" -dependencies = [ - "cfg-if", - "libc", - "redox_syscall 0.4.1", - "smallvec", - "windows-targets 0.48.5", -] - -[[package]] -name = "password-hash" -version = "0.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7676374caaee8a325c9e7a2ae557f216c5563a171d6997b0ef8a65af35147700" -dependencies = [ - "base64ct", - "rand_core", - "subtle", -] - -[[package]] -name = "paste" -version = "1.0.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c" - -[[package]] -name = "path-slash" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e91099d4268b0e11973f036e885d652fb0b21fedcf69738c627f94db6a44f42" - -[[package]] -name = "pbkdf2" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "83a0692ec44e4cf1ef28ca317f14f8f07da2d95ec3fa01f86e4467b725e60917" -dependencies = [ - "digest", - "hmac", - "password-hash", - "sha2", -] - -[[package]] -name = "pbkdf2" -version = "0.12.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8ed6a7761f76e3b9f92dfb0a60a6a6477c61024b775147ff0973a02653abaf2" -dependencies = [ - "digest", - "hmac", -] - -[[package]] -name = "percent-encoding" -version = "2.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e" - -[[package]] -name = "petgraph" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e1d3afd2628e69da2be385eb6f2fd57c8ac7977ceeff6dc166ff1657b0e386a9" -dependencies = [ - "fixedbitset", - "indexmap 2.1.0", -] - -[[package]] -name = "pharos" -version = "0.5.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e9567389417feee6ce15dd6527a8a1ecac205ef62c2932bcf3d9f6fc5b78b414" -dependencies = [ - "futures", - "rustc_version", -] - -[[package]] -name = "phf" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ade2d8b8f33c7333b51bcf0428d37e217e9f32192ae4772156f65063b8ce03dc" -dependencies = [ - "phf_macros", - "phf_shared 0.11.2", -] - -[[package]] -name = "phf_generator" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "48e4cc64c2ad9ebe670cb8fd69dd50ae301650392e81c05f9bfcb2d5bdbc24b0" -dependencies = [ - "phf_shared 0.11.2", - "rand", -] - -[[package]] -name = "phf_macros" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3444646e286606587e49f3bcf1679b8cef1dc2c5ecc29ddacaffc305180d464b" -dependencies = [ - "phf_generator", - "phf_shared 0.11.2", - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "phf_shared" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6796ad771acdc0123d2a88dc428b5e38ef24456743ddb1744ed628f9815c096" -dependencies = [ - "siphasher", -] - -[[package]] -name = "phf_shared" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "90fcb95eef784c2ac79119d1dd819e162b5da872ce6f3c3abe1e8ca1c082f72b" -dependencies = [ - "siphasher", -] - -[[package]] -name = "pin-project" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fda4ed1c6c173e3fc7a83629421152e01d7b1f9b7f65fb301e490e8cfc656422" -dependencies = [ - "pin-project-internal", -] - -[[package]] -name = "pin-project-internal" -version = "1.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4359fd9c9171ec6e8c62926d6faaf553a8dc3f64e1507e76da7911b4f6a04405" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "pin-project-lite" -version = "0.2.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8afb450f006bf6385ca15ef45d71d2288452bc3683ce2e2cacc0d18e4be60b58" - -[[package]] -name = "pin-utils" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b870d8c151b6f2fb93e84a13146138f05d02ed11c7e7c54f8826aaaf7c9f184" - -[[package]] -name = "pkcs8" -version = "0.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f950b2377845cebe5cf8b5165cb3cc1a5e0fa5cfa3e1f7f55707d8fd82e0a7b7" -dependencies = [ - "der", - "spki", -] - -[[package]] -name = "pkg-config" -version = "0.3.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "69d3587f8a9e599cc7ec2c00e331f71c4e69a5f9a4b8a6efd5b07466b9736f9a" - -[[package]] -name = "plotters" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d2c224ba00d7cadd4d5c660deaf2098e5e80e07846537c51f9cfa4be50c1fd45" -dependencies = [ - "num-traits", - "plotters-backend", - "plotters-svg", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "plotters-backend" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e76628b4d3a7581389a35d5b6e2139607ad7c75b17aed325f210aa91f4a9609" - -[[package]] -name = "plotters-svg" -version = "0.3.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38f6d39893cca0701371e3c27294f09797214b86f1fb951b89ade8ec04e2abab" -dependencies = [ - "plotters-backend", -] - -[[package]] -name = "powerfmt" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391" - -[[package]] -name = "ppv-lite86" -version = "0.2.17" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b40af805b3121feab8a3c29f04d8ad262fa8e0561883e7653e024ae4479e6de" - -[[package]] -name = "precomputed-hash" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "925383efa346730478fb4838dbe9137d2a47675ad789c546d150a6e1dd4ab31c" - -[[package]] -name = "prettyplease" -version = "0.2.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ae005bd773ab59b4725093fd7df83fd7892f7d8eafb48dbd7de6e024e4215f9d" -dependencies = [ - "proc-macro2", - "syn 2.0.43", -] - -[[package]] -name = "primitive-types" -version = "0.12.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b34d9fd68ae0b74a41b21c03c2f62847aa0ffea044eee893b4c140b37e244e2" -dependencies = [ - "fixed-hash", - "impl-codec", - "impl-rlp", - "impl-serde", - "scale-info", - "uint", -] - -[[package]] -name = "proc-macro-crate" -version = "1.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919" -dependencies = [ - "once_cell", - "toml_edit 0.19.15", -] - -[[package]] -name = "proc-macro-crate" -version = "2.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7e8366a6159044a37876a2b9817124296703c586a5c92e2c53751fa06d8d43e8" -dependencies = [ - "toml_edit 0.20.7", -] - -[[package]] -name = "proc-macro-error" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da25490ff9892aab3fcf7c36f08cfb902dd3e71ca0f9f9517bea02a73a5ce38c" -dependencies = [ - "proc-macro-error-attr", - "proc-macro2", - "quote", - "syn 1.0.109", - "version_check", -] - -[[package]] -name = "proc-macro-error-attr" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a1be40180e52ecc98ad80b184934baf3d0d29f979574e439af5a55274b35f869" -dependencies = [ - "proc-macro2", - "quote", - "version_check", -] - -[[package]] -name = "proc-macro2" -version = "1.0.72" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a293318316cf6478ec1ad2a21c49390a8d5b5eae9fab736467d93fbc0edc29c5" -dependencies = [ - "unicode-ident", -] - -[[package]] -name = "ptr_meta" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0738ccf7ea06b608c10564b31debd4f5bc5e197fc8bfe088f68ae5ce81e7a4f1" -dependencies = [ - "ptr_meta_derive", -] - -[[package]] -name = "ptr_meta_derive" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "16b845dbfca988fa33db069c0e230574d15a3088f147a87b64c7589eb662c9ac" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "quote" -version = "1.0.33" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae" -dependencies = [ - "proc-macro2", -] - -[[package]] -name = "radium" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09" - -[[package]] -name = "rand" -version = "0.8.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34af8d1a0e25924bc5b7c43c079c942339d8f0a8b57c39049bef581b46327404" -dependencies = [ - "libc", - "rand_chacha", - "rand_core", -] - -[[package]] -name = "rand_chacha" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e6c10a63a0fa32252be49d21e7709d4d4baf8d231c2dbce1eaa8141b9b127d88" -dependencies = [ - "ppv-lite86", - "rand_core", -] - -[[package]] -name = "rand_core" -version = "0.6.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec0be4795e2f6a28069bec0b5ff3e2ac9bafc99e6a9a7dc3547996c5c816922c" -dependencies = [ - "getrandom", -] - -[[package]] -name = "rayon" -version = "1.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c27db03db7734835b3f53954b534c91069375ce6ccaa2e065441e07d9b6cdb1" -dependencies = [ - "either", - "rayon-core", -] - -[[package]] -name = "rayon-core" -version = "1.12.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5ce3fb6ad83f861aac485e76e1985cd109d9a3713802152be56c3b1f0e0658ed" -dependencies = [ - "crossbeam-deque", - "crossbeam-utils", -] - -[[package]] -name = "redox_syscall" -version = "0.1.57" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "41cc0f7e4d5d4544e8861606a285bb08d3e70712ccc7d2b84d7c0ccfaf4b05ce" - -[[package]] -name = "redox_syscall" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4722d768eff46b75989dd134e5c353f0d6296e5aaa3132e776cbdb56be7731aa" -dependencies = [ - "bitflags 1.3.2", -] - -[[package]] -name = "redox_users" -version = "0.4.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a18479200779601e498ada4e8c1e1f50e3ee19deb0259c25825a98b5603b2cb4" -dependencies = [ - "getrandom", - "libredox", - "thiserror", -] - -[[package]] -name = "regalloc" -version = "0.0.34" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "62446b1d3ebf980bdc68837700af1d77b37bc430e524bf95319c6eada2a4cc02" -dependencies = [ - "log", - "rustc-hash", - "smallvec", -] - -[[package]] -name = "regex" -version = "1.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343" -dependencies = [ - "aho-corasick", - "memchr", - "regex-automata", - "regex-syntax 0.8.2", -] - -[[package]] -name = "regex-automata" -version = "0.4.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f" -dependencies = [ - "aho-corasick", - "memchr", - "regex-syntax 0.8.2", -] - -[[package]] -name = "regex-syntax" -version = "0.6.29" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f162c6dd7b008981e4d40210aca20b4bd0f9b60ca9271061b07f78537722f2e1" - -[[package]] -name = "regex-syntax" -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f" - -[[package]] -name = "region" -version = "3.0.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76e189c2369884dce920945e2ddf79b3dff49e071a167dd1817fa9c4c00d512e" -dependencies = [ - "bitflags 1.3.2", - "libc", - "mach", - "winapi", -] - -[[package]] -name = "rend" -version = "0.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2571463863a6bd50c32f94402933f03457a3fbaf697a707c5be741e459f08fd" -dependencies = [ - "bytecheck", -] - -[[package]] -name = "reqwest" -version = "0.11.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "37b1ae8d9ac08420c66222fb9096fc5de435c3c48542bc5336c51892cffafb41" -dependencies = [ - "base64 0.21.5", - "bytes", - "encoding_rs", - "futures-core", - "futures-util", - "h2", - "http", - "http-body", - "hyper", - "hyper-rustls", - "ipnet", - "js-sys", - "log", - "mime", - "once_cell", - "percent-encoding", - "pin-project-lite", - "rustls", - "rustls-pemfile", - "serde", - "serde_json", - "serde_urlencoded", - "system-configuration", - "tokio", - "tokio-rustls", - "tower-service", - "url", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", - "webpki-roots 0.25.3", - "winreg", -] - -[[package]] -name = "rfc6979" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f8dd2a808d456c4a54e300a23e9f5a67e122c3024119acbfd73e3bf664491cb2" -dependencies = [ - "hmac", - "subtle", -] - -[[package]] -name = "ring" -version = "0.16.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3053cf52e236a3ed746dfc745aa9cacf1b791d846bdaf412f60a8d7d6e17c8fc" -dependencies = [ - "cc", - "libc", - "once_cell", - "spin 0.5.2", - "untrusted 0.7.1", - "web-sys", - "winapi", -] - -[[package]] -name = "ring" -version = "0.17.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "688c63d65483050968b2a8937f7995f443e27041a0f7700aa59b0822aedebb74" -dependencies = [ - "cc", - "getrandom", - "libc", - "spin 0.9.8", - "untrusted 0.9.0", - "windows-sys 0.48.0", -] - -[[package]] -name = "ripemd" -version = "0.1.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bd124222d17ad93a644ed9d011a40f4fb64aa54275c08cc216524a9ea82fb09f" -dependencies = [ - "digest", -] - -[[package]] -name = "rkyv" -version = "0.7.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "527a97cdfef66f65998b5f3b637c26f5a5ec09cc52a3f9932313ac645f4190f5" -dependencies = [ - "bitvec", - "bytecheck", - "bytes", - "hashbrown 0.12.3", - "ptr_meta", - "rend", - "rkyv_derive", - "seahash", - "tinyvec", - "uuid 1.6.1", -] - -[[package]] -name = "rkyv_derive" -version = "0.7.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b5c462a1328c8e67e4d6dbad1eb0355dd43e8ab432c6e227a43657f16ade5033" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "rlp" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bb919243f34364b6bd2fc10ef797edbfa75f33c252e7998527479c6d6b47e1ec" -dependencies = [ - "bytes", - "rlp-derive", - "rustc-hex", -] - -[[package]] -name = "rlp-derive" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e33d7b2abe0c340d8797fe2907d3f20d3b5ea5908683618bfe80df7f621f672a" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "rustc-demangle" -version = "0.1.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d626bb9dae77e28219937af045c257c28bfd3f69333c512553507f5f9798cb76" - -[[package]] -name = "rustc-hash" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2" - -[[package]] -name = "rustc-hex" -version = "2.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3e75f6a532d0fd9f7f13144f392b6ad56a32696bfcd9c78f797f16bbb6f072d6" - -[[package]] -name = "rustc_version" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa0f585226d2e68097d4f95d113b15b83a82e819ab25717ec0590d9584ef366" -dependencies = [ - "semver", -] - -[[package]] -name = "rustix" -version = "0.38.28" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72e572a5e8ca657d7366229cdde4bd14c4eb5499a9573d4d366fe1b599daa316" -dependencies = [ - "bitflags 2.4.1", - "errno", - "libc", - "linux-raw-sys", - "windows-sys 0.52.0", -] - -[[package]] -name = "rustls" -version = "0.21.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f9d5a6813c0759e4609cd494e8e725babae6a2ca7b62a5536a13daaec6fcb7ba" -dependencies = [ - "log", - "ring 0.17.7", - "rustls-webpki 0.101.7", - "sct", -] - -[[package]] -name = "rustls-pemfile" -version = "1.0.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c74cae0a4cf6ccbbf5f359f08efdf8ee7e1dc532573bf0db71968cb56b1448c" -dependencies = [ - "base64 0.21.5", -] - -[[package]] -name = "rustls-webpki" -version = "0.100.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5f6a5fc258f1c1276dfe3016516945546e2d5383911efc0fc4f1cdc5df3a4ae3" -dependencies = [ - "ring 0.16.20", - "untrusted 0.7.1", -] - -[[package]] -name = "rustls-webpki" -version = "0.101.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b6275d1ee7a1cd780b64aca7726599a1dbc893b1e64144529e55c3c2f745765" -dependencies = [ - "ring 0.17.7", - "untrusted 0.9.0", -] - -[[package]] -name = "rustversion" -version = "1.0.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ffc183a10b4478d04cbbbfc96d0873219d962dd5accaff2ffbd4ceb7df837f4" - -[[package]] -name = "ryu" -version = "1.0.16" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c" - -[[package]] -name = "salsa20" -version = "0.10.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97a22f5af31f73a954c10289c93e8a50cc23d971e80ee446f1f6f7137a088213" -dependencies = [ - "cipher", -] - -[[package]] -name = "same-file" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "93fc1dc3aaa9bfed95e02e6eadabb4baf7e3078b0bd1b4d7b6b0b68378900502" -dependencies = [ - "winapi-util", -] - -[[package]] -name = "scale-info" -version = "2.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7f7d66a1128282b7ef025a8ead62a4a9fcf017382ec53b8ffbf4d7bf77bd3c60" -dependencies = [ - "cfg-if", - "derive_more", - "parity-scale-codec", - "scale-info-derive", -] - -[[package]] -name = "scale-info-derive" -version = "2.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "abf2c68b89cafb3b8d918dd07b42be0da66ff202cf1155c5739a4e0c1ea0dc19" -dependencies = [ - "proc-macro-crate 1.3.1", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "scopeguard" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49" - -[[package]] -name = "scrypt" -version = "0.10.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9f9e24d2b632954ded8ab2ef9fea0a0c769ea56ea98bddbafbad22caeeadf45d" -dependencies = [ - "hmac", - "pbkdf2 0.11.0", - "salsa20", - "sha2", -] - -[[package]] -name = "sct" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "da046153aa2352493d6cb7da4b6e5c0c057d8a1d0a9aa8560baffdd945acd414" -dependencies = [ - "ring 0.17.7", - "untrusted 0.9.0", -] - -[[package]] -name = "seahash" -version = "4.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1c107b6f4780854c8b126e228ea8869f4d7b71260f962fefb57b996b8959ba6b" - -[[package]] -name = "sec1" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3e97a565f76233a6003f9f5c54be1d9c5bdfa3eccfb189469f11ec4901c47dc" -dependencies = [ - "base16ct", - "der", - "generic-array", - "pkcs8", - "subtle", - "zeroize", -] - -[[package]] -name = "semver" -version = "1.0.20" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "836fa6a3e1e547f9a2c4040802ec865b5d85f4014efe00555d7090a3dcaa1090" -dependencies = [ - "serde", -] - -[[package]] -name = "send_wrapper" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f638d531eccd6e23b980caf34876660d38e265409d8e99b397ab71eb3612fad0" - -[[package]] -name = "send_wrapper" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd0b0ec5f1c1ca621c432a25813d8d60c88abe6d3e08a3eb9cf37d97a0fe3d73" - -[[package]] -name = "serde" -version = "1.0.193" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89" -dependencies = [ - "serde_derive", -] - -[[package]] -name = "serde_bytes" -version = "0.11.13" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8bb1879ea93538b78549031e2d54da3e901fd7e75f2e4dc758d760937b123d10" -dependencies = [ - "serde", -] - -[[package]] -name = "serde_cbor" -version = "0.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2bef2ebfde456fb76bbcf9f59315333decc4fda0b2b44b420243c11e0f5ec1f5" -dependencies = [ - "half", - "serde", -] - -[[package]] -name = "serde_derive" -version = "1.0.193" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "serde_json" -version = "1.0.108" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b" -dependencies = [ - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "serde_spanned" -version = "0.6.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "eb3622f419d1296904700073ea6cc23ad690adbd66f13ea683df73298736f0c1" -dependencies = [ - "serde", -] - -[[package]] -name = "serde_urlencoded" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d3491c14715ca2294c4d6a88f15e84739788c1d030eed8c110436aafdaa2f3fd" -dependencies = [ - "form_urlencoded", - "itoa", - "ryu", - "serde", -] - -[[package]] -name = "sha1" -version = "0.10.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e3bf829a2d51ab4a5ddf1352d8470c140cadc8301b2ae1789db023f01cedd6ba" -dependencies = [ - "cfg-if", - "cpufeatures", - "digest", -] - -[[package]] -name = "sha2" -version = "0.10.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "793db75ad2bcafc3ffa7c68b215fee268f537982cd901d132f89c6343f3a3dc8" -dependencies = [ - "cfg-if", - "cpufeatures", - "digest", -] - -[[package]] -name = "sha3" -version = "0.10.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "75872d278a8f37ef87fa0ddbda7802605cb18344497949862c0d4dcb291eba60" -dependencies = [ - "digest", - "keccak", -] - -[[package]] -name = "sharded-slab" -version = "0.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f40ca3c46823713e0d4209592e8d6e826aa57e928f09752619fc696c499637f6" -dependencies = [ - "lazy_static 1.4.0", -] - -[[package]] -name = "signal-hook-registry" -version = "1.4.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d8229b473baa5980ac72ef434c4415e70c4b5e71b423043adb4ba059f89c99a1" -dependencies = [ - "libc", -] - -[[package]] -name = "signature" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "77549399552de45a898a580c1b41d445bf730df867cc44e6c0233bbc4b8329de" -dependencies = [ - "digest", - "rand_core", -] - -[[package]] -name = "simdutf8" -version = "0.1.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f27f6278552951f1f2b8cf9da965d10969b2efdea95a6ec47987ab46edfe263a" - -[[package]] -name = "siphasher" -version = "0.3.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "38b58827f4464d87d377d175e90bf58eb00fd8716ff0a62f80356b5e61555d0d" - -[[package]] -name = "slab" -version = "0.4.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f92a496fb766b417c996b9c5e57daf2f7ad3b0bebe1ccfca4856390e3d3bb67" -dependencies = [ - "autocfg", -] - -[[package]] -name = "smallvec" -version = "1.11.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970" - -[[package]] -name = "socket2" -version = "0.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7b5fac59a5cb5dd637972e5fca70daf0523c9067fcdc4842f053dae04a18f8e9" -dependencies = [ - "libc", - "windows-sys 0.48.0", -] - -[[package]] -name = "solang-parser" -version = "0.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4a94494913728908efa7a25a2dd2e4f037e714897985c24273c40596638ed909" -dependencies = [ - "itertools", - "lalrpop", - "lalrpop-util", - "phf", - "thiserror", - "unicode-xid", -] - -[[package]] -name = "spin" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d" - -[[package]] -name = "spin" -version = "0.9.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6980e8d7511241f8acf4aebddbb1ff938df5eebe98691418c4468d0b72a96a67" - -[[package]] -name = "spki" -version = "0.7.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d91ed6c858b01f942cd56b37a94b3e0a1798290327d1236e4d9cf4eaca44d29d" -dependencies = [ - "base64ct", - "der", -] - -[[package]] -name = "stable_deref_trait" -version = "1.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3" - -[[package]] -name = "static_assertions" -version = "1.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f" - -[[package]] -name = "string_cache" -version = "0.8.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f91138e76242f575eb1d3b38b4f1362f10d3a43f47d182a5b359af488a02293b" -dependencies = [ - "new_debug_unreachable", - "once_cell", - "parking_lot", - "phf_shared 0.10.0", - "precomputed-hash", -] - -[[package]] -name = "strum" -version = "0.24.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "063e6045c0e62079840579a7e47a355ae92f60eb74daaf156fb1e84ba164e63f" -dependencies = [ - "strum_macros", -] - -[[package]] -name = "strum_macros" -version = "0.24.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1e385be0d24f186b4ce2f9982191e7101bb737312ad61c1f2f984f34bcf85d59" -dependencies = [ - "heck", - "proc-macro2", - "quote", - "rustversion", - "syn 1.0.109", -] - -[[package]] -name = "subtle" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "81cdd64d312baedb58e21336b31bc043b77e01cc99033ce76ef539f78e965ebc" - -[[package]] -name = "svm-rs" -version = "0.2.23" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3a04fc4f5cd35c700153b233f5575ccb3237e0f941fa5049d9e98254d10bf2fe" -dependencies = [ - "fs2", - "hex", - "home", - "once_cell", - "reqwest", - "semver", - "serde", - "serde_json", - "sha2", - "thiserror", - "url", - "zip", -] - -[[package]] -name = "syn" -version = "1.0.109" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "syn" -version = "2.0.43" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ee659fb5f3d355364e1f3e5bc10fb82068efbf824a1e9d1c9504244a6469ad53" -dependencies = [ - "proc-macro2", - "quote", - "unicode-ident", -] - -[[package]] -name = "system-configuration" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ba3a3adc5c275d719af8cb4272ea1c4a6d668a777f37e115f6d11ddbc1c8e0e7" -dependencies = [ - "bitflags 1.3.2", - "core-foundation", - "system-configuration-sys", -] - -[[package]] -name = "system-configuration-sys" -version = "0.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75fb188eb626b924683e3b95e3a48e63551fcfb51949de2f06a9d91dbee93c9" -dependencies = [ - "core-foundation-sys", - "libc", -] - -[[package]] -name = "tap" -version = "1.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369" - -[[package]] -name = "target-lexicon" -version = "0.12.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14c39fd04924ca3a864207c66fc2cd7d22d7c016007f9ce846cbb9326331930a" - -[[package]] -name = "tempfile" -version = "3.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "01ce4141aa927a6d1bd34a041795abd0db1cccba5d5f24b009f694bdf3a1f3fa" -dependencies = [ - "cfg-if", - "fastrand", - "redox_syscall 0.4.1", - "rustix", - "windows-sys 0.52.0", -] - -[[package]] -name = "term" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c59df8ac95d96ff9bede18eb7300b0fda5e5d8d90960e76f8e14ae765eedbf1f" -dependencies = [ - "dirs-next", - "rustversion", - "winapi", -] - -[[package]] -name = "textwrap" -version = "0.11.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d326610f408c7a4eb6f51c37c330e496b08506c9457c9d34287ecc38809fb060" -dependencies = [ - "unicode-width", -] - -[[package]] -name = "thiserror" -version = "1.0.39" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a5ab016db510546d856297882807df8da66a16fb8c4101cb8b30054b0d5b2d9c" -dependencies = [ - "thiserror-impl", -] - -[[package]] -name = "thiserror-impl" -version = "1.0.39" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5420d42e90af0c38c3290abcca25b9b3bdf379fc9f55c528f53a269d9c9a267e" -dependencies = [ - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "thread-id" -version = "3.3.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c7fbf4c9d56b320106cd64fd024dadfa0be7cb4706725fc44a7d7ce952d820c1" -dependencies = [ - "libc", - "redox_syscall 0.1.57", - "winapi", -] - -[[package]] -name = "thread_local" -version = "1.1.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3fdd6f064ccff2d6567adcb3873ca630700f00b5ad3f060c25b5dcfd9a4ce152" -dependencies = [ - "cfg-if", - "once_cell", -] - -[[package]] -name = "time" -version = "0.3.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f657ba42c3f86e7680e53c8cd3af8abbe56b5491790b46e22e19c0d57463583e" -dependencies = [ - "deranged", - "powerfmt", - "serde", - "time-core", -] - -[[package]] -name = "time-core" -version = "0.1.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ef927ca75afb808a4d64dd374f00a2adf8d0fcff8e7b184af886c3c87ec4a3f3" - -[[package]] -name = "tiny-keccak" -version = "2.0.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2c9d3793400a45f954c52e73d068316d76b6f4e36977e3fcebb13a2721e80237" -dependencies = [ - "crunchy", -] - -[[package]] -name = "tinytemplate" -version = "1.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "be4d6b5f19ff7664e8c98d03e2139cb510db9b0a60b55f8e8709b689d939b6bc" -dependencies = [ - "serde", - "serde_json", -] - -[[package]] -name = "tinyvec" -version = "1.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50" -dependencies = [ - "tinyvec_macros", -] - -[[package]] -name = "tinyvec_macros" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20" - -[[package]] -name = "tokio" -version = "1.35.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c89b4efa943be685f629b149f53829423f8f5531ea21249408e8e2f8671ec104" -dependencies = [ - "backtrace", - "bytes", - "libc", - "mio", - "num_cpus", - "parking_lot", - "pin-project-lite", - "signal-hook-registry", - "socket2", - "tokio-macros", - "windows-sys 0.48.0", -] - -[[package]] -name = "tokio-macros" -version = "2.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5b8a1e28f2deaa14e508979454cb3a223b10b938b45af148bc0986de36f1923b" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "tokio-rustls" -version = "0.24.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c28327cf380ac148141087fbfb9de9d7bd4e84ab5d2c28fbc911d753de8a7081" -dependencies = [ - "rustls", - "tokio", -] - -[[package]] -name = "tokio-tungstenite" -version = "0.19.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ec509ac96e9a0c43427c74f003127d953a265737636129424288d27cb5c4b12c" -dependencies = [ - "futures-util", - "log", - "rustls", - "tokio", - "tokio-rustls", - "tungstenite", - "webpki-roots 0.23.1", -] - -[[package]] -name = "tokio-util" -version = "0.7.10" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5419f34732d9eb6ee4c3578b7989078579b7f039cbbb9ca2c4da015749371e15" -dependencies = [ - "bytes", - "futures-core", - "futures-sink", - "pin-project-lite", - "tokio", - "tracing", -] - -[[package]] -name = "toml" -version = "0.7.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dd79e69d3b627db300ff956027cc6c3798cef26d22526befdfcd12feeb6d2257" -dependencies = [ - "serde", - "serde_spanned", - "toml_datetime", - "toml_edit 0.19.15", -] - -[[package]] -name = "toml_datetime" -version = "0.6.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1" -dependencies = [ - "serde", -] - -[[package]] -name = "toml_edit" -version = "0.19.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" -dependencies = [ - "indexmap 2.1.0", - "serde", - "serde_spanned", - "toml_datetime", - "winnow", -] - -[[package]] -name = "toml_edit" -version = "0.20.7" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "70f427fce4d84c72b5b732388bf4a9f4531b53f74e2887e3ecb2481f68f66d81" -dependencies = [ - "indexmap 2.1.0", - "toml_datetime", - "winnow", -] - -[[package]] -name = "tower-service" -version = "0.3.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b6bc1c9ce2b5135ac7f93c72918fc37feb872bdc6a5533a8b85eb4b86bfdae52" - -[[package]] -name = "tracing" -version = "0.1.40" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c3523ab5a71916ccf420eebdf5521fcef02141234bbc0b8a49f2fdc4544364ef" -dependencies = [ - "log", - "pin-project-lite", - "tracing-attributes", - "tracing-core", -] - -[[package]] -name = "tracing-attributes" -version = "0.1.27" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "34704c8d6ebcbc939824180af020566b01a7c01f80641264eba0999f6c2b6be7" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "tracing-core" -version = "0.1.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c06d3da6113f116aaee68e4d601191614c9053067f9ab7f6edbcb161237daa54" -dependencies = [ - "once_cell", - "valuable", -] - -[[package]] -name = "tracing-error" -version = "0.2.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d686ec1c0f384b1277f097b2f279a2ecc11afe8c133c1aabf036a27cb4cd206e" -dependencies = [ - "tracing", - "tracing-subscriber 0.3.18", -] - -[[package]] -name = "tracing-futures" -version = "0.2.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97d095ae15e245a057c8e8451bab9b3ee1e1f68e9ba2b4fbc18d0ac5237835f2" -dependencies = [ - "pin-project", - "tracing", -] - -[[package]] -name = "tracing-subscriber" -version = "0.2.25" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0e0d2eaa99c3c2e41547cfa109e910a68ea03823cccad4a0525dcbc9b01e8c71" -dependencies = [ - "tracing-core", -] - -[[package]] -name = "tracing-subscriber" -version = "0.3.18" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ad0f048c97dbd9faa9b7df56362b8ebcaa52adb06b498c050d2f4e32f90a7a8b" -dependencies = [ - "sharded-slab", - "thread_local", - "tracing-core", -] - -[[package]] -name = "try-lock" -version = "0.2.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e421abadd41a4225275504ea4d6566923418b7f05506fbc9c0fe86ba7396114b" - -[[package]] -name = "tungstenite" -version = "0.19.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "15fba1a6d6bb030745759a9a2a588bfe8490fc8b4751a277db3a0be1c9ebbf67" -dependencies = [ - "byteorder", - "bytes", - "data-encoding", - "http", - "httparse", - "log", - "rand", - "rustls", - "sha1", - "thiserror", - "url", - "utf-8", - "webpki", -] - -[[package]] -name = "typenum" -version = "1.17.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" - -[[package]] -name = "uint" -version = "0.9.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "76f64bba2c53b04fcab63c01a7d7427eadc821e3bc48c34dc9ba29c501164b52" -dependencies = [ - "byteorder", - "crunchy", - "hex", - "static_assertions", -] - -[[package]] -name = "unicode-bidi" -version = "0.3.14" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6f2528f27a9eb2b21e69c95319b30bd0efd85d09c379741b0f78ea1d86be2416" - -[[package]] -name = "unicode-ident" -version = "1.0.12" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" - -[[package]] -name = "unicode-normalization" -version = "0.1.22" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921" -dependencies = [ - "tinyvec", -] - -[[package]] -name = "unicode-width" -version = "0.1.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "e51733f11c9c4f72aa0c160008246859e340b00807569a0da0e7a1079b27ba85" - -[[package]] -name = "unicode-xid" -version = "0.2.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f962df74c8c05a667b5ee8bcf162993134c104e96440b663c8daa176dc772d8c" - -[[package]] -name = "untrusted" -version = "0.7.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a" - -[[package]] -name = "untrusted" -version = "0.9.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8ecb6da28b8a351d773b68d5825ac39017e680750f980f3a1a85cd8dd28a47c1" - -[[package]] -name = "url" -version = "2.5.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633" -dependencies = [ - "form_urlencoded", - "idna", - "percent-encoding", -] - -[[package]] -name = "utf-8" -version = "0.7.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09cc8ee72d2a9becf2f2febe0205bbed8fc6615b7cb429ad062dc7b7ddd036a9" - -[[package]] -name = "uuid" -version = "0.8.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7" -dependencies = [ - "getrandom", - "serde", -] - -[[package]] -name = "uuid" -version = "1.6.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5e395fcf16a7a3d8127ec99782007af141946b4795001f876d54fb0d55978560" - -[[package]] -name = "valuable" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "830b7e5d4d90034032940e4ace0d9a9a057e7a45cd94e6c007832e39edb82f6d" - -[[package]] -name = "version_check" -version = "0.9.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f" - -[[package]] -name = "walkdir" -version = "2.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d71d857dc86794ca4c280d616f7da00d2dbfd8cd788846559a6813e6aa4b54ee" -dependencies = [ - "same-file", - "winapi-util", -] - -[[package]] -name = "want" -version = "0.3.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bfa7760aed19e106de2c7c0b581b509f2f25d3dacaf737cb82ac61bc6d760b0e" -dependencies = [ - "try-lock", -] - -[[package]] -name = "wasi" -version = "0.11.0+wasi-snapshot-preview1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423" - -[[package]] -name = "wasm-bindgen" -version = "0.2.89" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ed0d4f68a3015cc185aff4db9506a015f4b96f95303897bfa23f846db54064e" -dependencies = [ - "cfg-if", - "wasm-bindgen-macro", -] - -[[package]] -name = "wasm-bindgen-backend" -version = "0.2.89" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b56f625e64f3a1084ded111c4d5f477df9f8c92df113852fa5a374dbda78826" -dependencies = [ - "bumpalo", - "log", - "once_cell", - "proc-macro2", - "quote", - "syn 2.0.43", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-futures" -version = "0.4.39" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac36a15a220124ac510204aec1c3e5db8a22ab06fd6706d881dc6149f8ed9a12" -dependencies = [ - "cfg-if", - "js-sys", - "wasm-bindgen", - "web-sys", -] - -[[package]] -name = "wasm-bindgen-macro" -version = "0.2.89" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0162dbf37223cd2afce98f3d0785506dcb8d266223983e4b5b525859e6e182b2" -dependencies = [ - "quote", - "wasm-bindgen-macro-support", -] - -[[package]] -name = "wasm-bindgen-macro-support" -version = "0.2.89" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f0eb82fcb7930ae6219a7ecfd55b217f5f0893484b7a13022ebb2b2bf20b5283" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.43", - "wasm-bindgen-backend", - "wasm-bindgen-shared", -] - -[[package]] -name = "wasm-bindgen-shared" -version = "0.2.89" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7ab9b36309365056cd639da3134bf87fa8f3d86008abf99e612384a6eecd459f" - -[[package]] -name = "wasm-encoder" -version = "0.38.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0ad2b51884de9c7f4fe2fd1043fccb8dcad4b1e29558146ee57a144d15779f3f" -dependencies = [ - "leb128", -] - -[[package]] -name = "wasmer" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "cfg-if", - "indexmap 1.9.3", - "js-sys", - "loupe", - "more-asserts", - "target-lexicon", - "thiserror", - "wasm-bindgen", - "wasmer-artifact", - "wasmer-compiler", - "wasmer-compiler-cranelift", - "wasmer-derive", - "wasmer-engine", - "wasmer-engine-dylib", - "wasmer-engine-universal", - "wasmer-types", - "wasmer-vm", - "wat", - "winapi", -] - -[[package]] -name = "wasmer-artifact" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "enumset", - "loupe", - "thiserror", - "wasmer-compiler", - "wasmer-types", -] - -[[package]] -name = "wasmer-compiler" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "enumset", - "loupe", - "rkyv", - "serde", - "serde_bytes", - "smallvec", - "target-lexicon", - "thiserror", - "wasmer-types", - "wasmparser", -] - -[[package]] -name = "wasmer-compiler-cranelift" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "cranelift-codegen", - "cranelift-entity", - "cranelift-frontend", - "gimli 0.26.2", - "loupe", - "more-asserts", - "rayon", - "smallvec", - "target-lexicon", - "tracing", - "wasmer-compiler", - "wasmer-types", -] - -[[package]] -name = "wasmer-derive" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "proc-macro-error", - "proc-macro2", - "quote", - "syn 1.0.109", -] - -[[package]] -name = "wasmer-engine" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "backtrace", - "enumset", - "lazy_static 1.4.0", - "loupe", - "memmap2 0.5.10", - "more-asserts", - "rustc-demangle", - "serde", - "serde_bytes", - "target-lexicon", - "thiserror", - "wasmer-artifact", - "wasmer-compiler", - "wasmer-types", - "wasmer-vm", -] - -[[package]] -name = "wasmer-engine-dylib" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "cfg-if", - "enum-iterator", - "enumset", - "leb128", - "libloading", - "loupe", - "object 0.28.4", - "rkyv", - "serde", - "tempfile", - "tracing", - "wasmer-artifact", - "wasmer-compiler", - "wasmer-engine", - "wasmer-object", - "wasmer-types", - "wasmer-vm", - "which", -] - -[[package]] -name = "wasmer-engine-universal" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "cfg-if", - "enumset", - "leb128", - "loupe", - "region", - "rkyv", - "wasmer-compiler", - "wasmer-engine", - "wasmer-engine-universal-artifact", - "wasmer-types", - "wasmer-vm", - "winapi", -] - -[[package]] -name = "wasmer-engine-universal-artifact" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "enum-iterator", - "enumset", - "loupe", - "rkyv", - "thiserror", - "wasmer-artifact", - "wasmer-compiler", - "wasmer-types", -] - -[[package]] -name = "wasmer-object" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "object 0.28.4", - "thiserror", - "wasmer-compiler", - "wasmer-types", -] - -[[package]] -name = "wasmer-types" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "backtrace", - "enum-iterator", - "indexmap 1.9.3", - "loupe", - "more-asserts", - "rkyv", - "serde", - "thiserror", -] - -[[package]] -name = "wasmer-vm" -version = "2.3.0" -source = "git+https://github.com/oskarth/wasmer.git?rev=09c7070#09c7070d8f0baf3aa949c990ad4972d0bcbd022c" -dependencies = [ - "backtrace", - "cc", - "cfg-if", - "corosensei", - "enum-iterator", - "indexmap 1.9.3", - "lazy_static 1.4.0", - "libc", - "loupe", - "mach", - "memoffset", - "more-asserts", - "region", - "rkyv", - "scopeguard", - "serde", - "thiserror", - "wasmer-artifact", - "wasmer-types", - "winapi", -] - -[[package]] -name = "wasmparser" -version = "0.83.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "718ed7c55c2add6548cca3ddd6383d738cd73b892df400e96b9aa876f0141d7a" - -[[package]] -name = "wast" -version = "69.0.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c1ee37317321afde358e4d7593745942c48d6d17e0e6e943704de9bbee121e7a" -dependencies = [ - "leb128", - "memchr", - "unicode-width", - "wasm-encoder", -] - -[[package]] -name = "wat" -version = "1.0.82" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "aeb338ee8dee4d4cd05e6426683f21c5087dc7cfc8903e839ccf48d43332da3c" -dependencies = [ - "wast", -] - -[[package]] -name = "web-sys" -version = "0.3.66" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50c24a44ec86bb68fbecd1b3efed7e85ea5621b39b35ef2766b66cd984f8010f" -dependencies = [ - "js-sys", - "wasm-bindgen", -] - -[[package]] -name = "webpki" -version = "0.22.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed63aea5ce73d0ff405984102c42de94fc55a6b75765d621c65262469b3c9b53" -dependencies = [ - "ring 0.17.7", - "untrusted 0.9.0", -] - -[[package]] -name = "webpki-roots" -version = "0.23.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b03058f88386e5ff5310d9111d53f48b17d732b401aeb83a8d5190f2ac459338" -dependencies = [ - "rustls-webpki 0.100.3", -] - -[[package]] -name = "webpki-roots" -version = "0.25.3" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1778a42e8b3b90bff8d0f5032bf22250792889a5cdc752aa0020c84abe3aaf10" - -[[package]] -name = "which" -version = "4.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7" -dependencies = [ - "either", - "home", - "once_cell", - "rustix", -] - -[[package]] -name = "winapi" -version = "0.3.9" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "5c839a674fcd7a98952e593242ea400abe93992746761e38641405d28b00f419" -dependencies = [ - "winapi-i686-pc-windows-gnu", - "winapi-x86_64-pc-windows-gnu", -] - -[[package]] -name = "winapi-i686-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6" - -[[package]] -name = "winapi-util" -version = "0.1.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "f29e6f9198ba0d26b4c9f07dbe6f9ed633e1f3d5b8b414090084349e46a52596" -dependencies = [ - "winapi", -] - -[[package]] -name = "winapi-x86_64-pc-windows-gnu" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f" - -[[package]] -name = "windows-sys" -version = "0.33.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "43dbb096663629518eb1dfa72d80243ca5a6aca764cae62a2df70af760a9be75" -dependencies = [ - "windows_aarch64_msvc 0.33.0", - "windows_i686_gnu 0.33.0", - "windows_i686_msvc 0.33.0", - "windows_x86_64_gnu 0.33.0", - "windows_x86_64_msvc 0.33.0", -] - -[[package]] -name = "windows-sys" -version = "0.48.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "677d2418bec65e3338edb076e806bc1ec15693c5d0104683f2efe857f61056a9" -dependencies = [ - "windows-targets 0.48.5", -] - -[[package]] -name = "windows-sys" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d" -dependencies = [ - "windows-targets 0.52.0", -] - -[[package]] -name = "windows-targets" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c" -dependencies = [ - "windows_aarch64_gnullvm 0.48.5", - "windows_aarch64_msvc 0.48.5", - "windows_i686_gnu 0.48.5", - "windows_i686_msvc 0.48.5", - "windows_x86_64_gnu 0.48.5", - "windows_x86_64_gnullvm 0.48.5", - "windows_x86_64_msvc 0.48.5", -] - -[[package]] -name = "windows-targets" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8a18201040b24831fbb9e4eb208f8892e1f50a37feb53cc7ff887feb8f50e7cd" -dependencies = [ - "windows_aarch64_gnullvm 0.52.0", - "windows_aarch64_msvc 0.52.0", - "windows_i686_gnu 0.52.0", - "windows_i686_msvc 0.52.0", - "windows_x86_64_gnu 0.52.0", - "windows_x86_64_gnullvm 0.52.0", - "windows_x86_64_msvc 0.52.0", -] - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8" - -[[package]] -name = "windows_aarch64_gnullvm" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cb7764e35d4db8a7921e09562a0304bf2f93e0a51bfccee0bd0bb0b666b015ea" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.33.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd761fd3eb9ab8cc1ed81e56e567f02dd82c4c837e48ac3b2181b9ffc5060807" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc" - -[[package]] -name = "windows_aarch64_msvc" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bbaa0368d4f1d2aaefc55b6fcfee13f41544ddf36801e793edbbfd7d7df075ef" - -[[package]] -name = "windows_i686_gnu" -version = "0.33.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cab0cf703a96bab2dc0c02c0fa748491294bf9b7feb27e1f4f96340f208ada0e" - -[[package]] -name = "windows_i686_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e" - -[[package]] -name = "windows_i686_gnu" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a28637cb1fa3560a16915793afb20081aba2c92ee8af57b4d5f28e4b3e7df313" - -[[package]] -name = "windows_i686_msvc" -version = "0.33.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8cfdbe89cc9ad7ce618ba34abc34bbb6c36d99e96cae2245b7943cd75ee773d0" - -[[package]] -name = "windows_i686_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406" - -[[package]] -name = "windows_i686_msvc" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ffe5e8e31046ce6230cc7215707b816e339ff4d4d67c65dffa206fd0f7aa7b9a" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.33.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b4dd9b0c0e9ece7bb22e84d70d01b71c6d6248b81a3c60d11869451b4cb24784" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e" - -[[package]] -name = "windows_x86_64_gnu" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "3d6fa32db2bc4a2f5abeacf2b69f7992cd09dca97498da74a151a3132c26befd" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc" - -[[package]] -name = "windows_x86_64_gnullvm" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1a657e1e9d3f514745a572a6846d3c7aa7dbe1658c056ed9c3344c4109a6949e" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.33.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ff1e4aa646495048ec7f3ffddc411e1d829c026a2ec62b39da15c1055e406eaa" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.48.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538" - -[[package]] -name = "windows_x86_64_msvc" -version = "0.52.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "dff9641d1cd4be8d1a070daf9e3773c5f67e78b4d9d42263020c057706765c04" - -[[package]] -name = "winnow" -version = "0.5.31" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "97a4882e6b134d6c28953a387571f1acdd3496830d5e36c5e3a1075580ea641c" -dependencies = [ - "memchr", -] - -[[package]] -name = "winreg" -version = "0.50.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "524e57b2c537c0f9b1e69f1965311ec12182b4122e45035b1508cd24d2adadb1" -dependencies = [ - "cfg-if", - "windows-sys 0.48.0", -] - -[[package]] -name = "ws_stream_wasm" -version = "0.7.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7999f5f4217fe3818726b66257a4475f71e74ffd190776ad053fa159e50737f5" -dependencies = [ - "async_io_stream", - "futures", - "js-sys", - "log", - "pharos", - "rustc_version", - "send_wrapper 0.6.0", - "thiserror", - "wasm-bindgen", - "wasm-bindgen-futures", - "web-sys", -] - -[[package]] -name = "wyz" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed" -dependencies = [ - "tap", -] - -[[package]] -name = "yansi" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09041cd90cf85f7f8b2df60c646f853b7f535ce68f85244eb6731cf89fa498ec" - -[[package]] -name = "zerocopy" -version = "0.7.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be" -dependencies = [ - "zerocopy-derive", -] - -[[package]] -name = "zerocopy-derive" -version = "0.7.32" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "zeroize" -version = "1.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "525b4ec142c6b68a2d10f01f7bbf6755599ca3f81ea53b8431b7dd348f5fdb2d" -dependencies = [ - "zeroize_derive", -] - -[[package]] -name = "zeroize_derive" -version = "1.4.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ce36e65b0d2999d2aafac989fb249189a141aee1f53c612c1f37d72631959f69" -dependencies = [ - "proc-macro2", - "quote", - "syn 2.0.43", -] - -[[package]] -name = "zip" -version = "0.6.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "760394e246e4c28189f19d488c058bf16f564016aefac5d32bb1f3b51d5e9261" -dependencies = [ - "aes", - "byteorder", - "bzip2", - "constant_time_eq", - "crc32fast", - "crossbeam-utils", - "flate2", - "hmac", - "pbkdf2 0.11.0", - "sha1", - "time", - "zstd", -] - -[[package]] -name = "zstd" -version = "0.11.2+zstd.1.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "20cc960326ece64f010d2d2107537f26dc589a6573a316bd5b1dba685fa5fde4" -dependencies = [ - "zstd-safe", -] - -[[package]] -name = "zstd-safe" -version = "5.0.2+zstd.1.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1d2a5585e04f9eea4b2a3d1eca508c4dee9592a89ef6f450c11719da0726f4db" -dependencies = [ - "libc", - "zstd-sys", -] - -[[package]] -name = "zstd-sys" -version = "2.0.9+zstd.1.5.5" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9e16efa8a874a0481a574084d34cc26fdb3b99627480f785888deb6386506656" -dependencies = [ - "cc", - "pkg-config", -] diff --git a/app/ark-circom-passport/Cargo.toml b/app/ark-circom-passport/Cargo.toml deleted file mode 100644 index 634a6c3ef..000000000 --- a/app/ark-circom-passport/Cargo.toml +++ /dev/null @@ -1,49 +0,0 @@ -[package] -name = "ark_circom_passport" -version = "0.1.0" -edition = "2021" - -[lib] -name = "ark_circom_passport" -path = "src/passport.rs" -crate-type = ["cdylib"] - -# [profile.dev] -# opt-level = 3 - -# XXX: Shouldn't be necessary, but this way we stay consistent with wasmer version and fix -# error[E0432]: unresolved import `wasmer` error -# (likely due to other packages) -[patch.crates-io] -wasmer = { git = "https://github.com/oskarth/wasmer.git", rev = "09c7070" } -# NOTE: Forked wasmer to work around memory limits -# See https://github.com/wasmerio/wasmer/commit/09c7070 - -[dependencies] -wasmer = { git = "https://github.com/oskarth/wasmer.git", rev = "09c7070" } -ark-circom = { git = "https://github.com/0xturboblitz/circom-compat.git" } -ark-bn254 = { version = "=0.4.0" } -ark-groth16 = { version = "=0.4.0", default-features = false, features = ["parallel"] } -ark-std = { version = "=0.4.0", default-features = false, features = ["parallel"] } -ark-crypto-primitives = { version = "=0.4.0" } -ark-ec = { version = "=0.4.1" } -ark-ff = { version = "=0.4.1", default-features = false, features = ["parallel", "asm"] } -ark-relations = { version = "=0.4.0", default-features = false } -ark-serialize = { version = "=0.4.1", default-features = false } -color-eyre = "=0.6.2" -ethers = "=2.0.7" -tokio = { version = "1", features = ["full"] } -jni = "0.18" -log = "0.4" -android_logger = "0.8" -serde = "1.0" -serde_json = "1.0" -serde_derive = "1.0" -byteorder = "=1.4.3" -num-traits = { version = "=0.2.15", default-features = false } -hex = "0.4" -once_cell = "1.8" -num-bigint = { version = "=0.4.3", default-features = false, features = [ - "rand", -] } -ark-zkey = { git = "https://github.com/oskarth/mopro.git", branch = "main" } diff --git a/app/ark-circom-passport/README.md b/app/ark-circom-passport/README.md deleted file mode 100644 index 55d43d568..000000000 --- a/app/ark-circom-passport/README.md +++ /dev/null @@ -1,14 +0,0 @@ -# rust module to generate the proof of passport android native lib - -To run tests and see logs: -``` -cargo test --release -- --nocapture -``` - -Could be replaced by mopro once mopro is available on Android. - -To generate the arkzkey, if you have installed arkzkey-util globally from the mopro repo, you can run -``` -cd passport -arkzkey-util proof_of_passport_final.zkey -``` \ No newline at end of file diff --git a/app/ark-circom-passport/artifacts/verifier_artifact.json b/app/ark-circom-passport/artifacts/verifier_artifact.json deleted file mode 100644 index 1a2b8cb6b..000000000 --- a/app/ark-circom-passport/artifacts/verifier_artifact.json +++ /dev/null @@ -1 +0,0 @@ -{"abi":[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"uint256[]","name":"input","type":"uint256[]"},{"components":[{"components":[{"internalType":"uint256","name":"X","type":"uint256"},{"internalType":"uint256","name":"Y","type":"uint256"}],"internalType":"struct Pairing.G1Point","name":"A","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"X","type":"uint256[2]"},{"internalType":"uint256[2]","name":"Y","type":"uint256[2]"}],"internalType":"struct Pairing.G2Point","name":"B","type":"tuple"},{"components":[{"internalType":"uint256","name":"X","type":"uint256"},{"internalType":"uint256","name":"Y","type":"uint256"}],"internalType":"struct Pairing.G1Point","name":"C","type":"tuple"}],"internalType":"struct Verifier.Proof","name":"proof","type":"tuple"},{"components":[{"components":[{"internalType":"uint256","name":"X","type":"uint256"},{"internalType":"uint256","name":"Y","type":"uint256"}],"internalType":"struct Pairing.G1Point","name":"alfa1","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"X","type":"uint256[2]"},{"internalType":"uint256[2]","name":"Y","type":"uint256[2]"}],"internalType":"struct Pairing.G2Point","name":"beta2","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"X","type":"uint256[2]"},{"internalType":"uint256[2]","name":"Y","type":"uint256[2]"}],"internalType":"struct Pairing.G2Point","name":"gamma2","type":"tuple"},{"components":[{"internalType":"uint256[2]","name":"X","type":"uint256[2]"},{"internalType":"uint256[2]","name":"Y","type":"uint256[2]"}],"internalType":"struct Pairing.G2Point","name":"delta2","type":"tuple"},{"components":[{"internalType":"uint256","name":"X","type":"uint256"},{"internalType":"uint256","name":"Y","type":"uint256"}],"internalType":"struct Pairing.G1Point[]","name":"IC","type":"tuple[]"}],"internalType":"struct Verifier.VerifyingKey","name":"vk","type":"tuple"}],"name":"verify","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}],"bytecode":{"object":"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","sourceMap":"1307:423:0:-:0;;;1334:16;;;;;;;;;;1307:423;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"1307:423:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1356:372;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;1509:4;1525:11;1539:79;1568:5;1587;1606:2;1539:15;:79::i;:::-;1525:93;-1:-1:-1;1633:8:0;1629:93;;1664:4;1657:11;;;;;1629:93;1706:5;1699:12;;;1356:372;;;;;;:::o;2075:1054::-;2375:5;;;;:12;2355;;2212:7;;2260:77;;2370:1;2355:16;:32;2347:63;;;;-1:-1:-1;;;2347:63:0;;;;;;;:::i;:::-;;;;;;;;;2497:21;;;;;;;;;2467:27;2497:21;;;;;;;;;2528:228;2552:5;:12;2548:1;:16;2528:228;;;2604:18;2593:5;2599:1;2593:8;;;;;;;;;;;;;;:29;2585:73;;;;-1:-1:-1;;;2585:73:0;;;;;;;:::i;:::-;2679:66;2696:4;2702:42;2721:2;:5;;;2727:1;2731;2727:5;2721:12;;;;;;;;;;;;;;2735:5;2741:1;2735:8;;;;;;;;;;;;;;2702:18;:42::i;:::-;2679:16;:66::i;:::-;2672:73;-1:-1:-1;2566:3:0;;2528:228;;;;2772:32;2789:4;2795:2;:5;;;2801:1;2795:8;;;;;;;;;;;;;;2772:16;:32::i;:::-;2765:39;;2832:253;2870:23;2885:5;:7;;;2870:14;:23::i;:::-;2911:5;:7;;;2936:2;:8;;;2962:2;:8;;;2988:4;3010:2;:9;;;3037:5;:7;;;3062:2;:9;;;2832:20;:253::i;:::-;2814:290;;3103:1;3096:8;;;;;;2814:290;-1:-1:-1;3121:1:0;;2075:1054;-1:-1:-1;;;;;2075:1054:0:o;6418:625::-;6514:16;;:::i;:::-;6546:23;;:::i;:::-;6590:3;;6579:14;;:8;6614:3;;;;6603:8;;;:14;6627:8;;;:12;;;-1:-1:-1;6817:4:0;6814:1;6808:4;6579:14;6798:1;6791:4;6784:5;6780:16;6769:53;6758:64;-1:-1:-1;6758:64:0;6923:56;;;;6892:87;;6923:56;6952:9;6892:87;;7006:7;6998:38;;;;-1:-1:-1;;;6998:38:0;;;;;;;:::i;:::-;6418:625;;;;;;:::o;5600:662::-;5703:16;;:::i;:::-;5735:23;;:::i;:::-;5779:4;;5768:15;;:8;5804:4;;;;5793:8;;;:15;5829:4;;5818:8;;;:15;5854:4;;;5843:8;;;;:15;;;;-1:-1:-1;;6033:1:0;6027:4;5768:15;6017:1;6010:4;6003:5;5999:16;5988:53;5977:64;-1:-1:-1;5977:64:0;6142:56;;;;6111:87;6225:7;6217:38;;;;-1:-1:-1;;;6217:38:0;;;;;;;:::i;5202:346::-;5259:16;;:::i;:::-;5455:3;;5364:77;;5455:8;:20;;;;-1:-1:-1;5467:3:0;;;;:8;5455:20;5451:46;;;-1:-1:-1;;5484:13:0;;;;;;;;;-1:-1:-1;5484:13:0;;;;;;;5477:20;;5451:46;5514:27;;;;;;;;5522:1;:3;;;5514:27;;;;5538:1;5532;:3;;;:7;;;;;;5527:1;:13;5514:27;;;5507:34;;;5202:346;;;;:::o;9554:568::-;9859:16;;;9873:1;9859:16;;;;;;;;;9821:4;;;;9859:16;;;;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;;9907:16:0;;;9921:1;9907:16;;;;;;;;;9837:38;;-1:-1:-1;9885:19:0;;9907:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;9885:38;;9941:2;9933;9936:1;9933:5;;;;;;;;;;;;;:10;;;;9961:2;9953;9956:1;9953:5;;;;;;;;;;;;;:10;;;;9981:2;9973;9976:1;9973:5;;;;;;;;;;;;;:10;;;;10001:2;9993;9996:1;9993:5;;;;;;;;;;;;;:10;;;;10021:2;10013;10016:1;10013:5;;;;;;;;;;;;;:10;;;;10041:2;10033;10036:1;10033:5;;;;;;;;;;;;;:10;;;;10061:2;10053;10056:1;10053:5;;;;;;;;;;;;;:10;;;;10081:2;10073;10076:1;10073:5;;;;;;;;;;;;;:10;;;;10100:15;10108:2;10112;10100:7;:15::i;:::-;10093:22;9554:568;-1:-1:-1;;;;;;;;;;;9554:568:0:o;7255:1238::-;7361:4;7402:2;:9;7389:2;:9;:22;7381:57;;;;-1:-1:-1;;;7381:57:0;;;;;;;:::i;:::-;7467:9;;7517:1;7506:12;;7448:16;7506:12;7553:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;7553:24:0;;7528:49;;7592:9;7587:302;7611:8;7607:1;:12;7587:302;;;7659:2;7662:1;7659:5;;;;;;;;;;;;;;:7;;;7640:5;7646:1;7650;7646:5;7654:1;7646:9;7640:16;;;;;;;;;;;;;:26;;;;;7699:2;7702:1;7699:5;;;;;;;;;;;;;;:7;;;7680:5;7686:1;7690;7686:5;7694:1;7686:9;7680:16;;;;;;;;;;;;;:26;;;;;7739:2;7742:1;7739:5;;;;;;;;;;;;;;;;;;:7;:10;7720:16;;:5;;7734:1;7730;7726:5;;:9;;7720:16;;;;;;;;;;;:29;;;;;7782:2;7785:1;7782:5;;;;;;;;;;;;;;;;;;:7;7790:1;7782:10;;;;7763:5;7769:1;7773;7769:5;7777:1;7769:9;7763:16;;;;;;;;;;;;;:29;;;;;7825:2;7828:1;7825:5;;;;;;;;;;;;;;:7;;;7833:1;7825:10;;;;;;;;;;;7806:5;7812:1;7816;7812:5;7820:1;7812:9;7806:16;;;;;;;;;;;;;:29;;;;;7868:2;7871:1;7868:5;;;;;;;;;;;;;;:7;;;7876:1;7868:10;;;;;;;;;;;7849:5;7855:1;7859;7855:5;7863:1;7855:9;7849:16;;;;;;;;;;;;;;;;;:29;7621:3;;7587:302;;;;7898:21;;:::i;:::-;7929:12;8223:4;8202:3;8179:4;8168:9;8164:20;8141:4;8134:5;8130:16;8111:1;8088:4;8081:5;8077:16;8049:192;8038:203;-1:-1:-1;8038:203:0;8342:56;;;;8311:87;8425:7;8417:41;;;;-1:-1:-1;;;8417:41:0;;;;;;;:::i;:::-;-1:-1:-1;8475:6:0;:11;;;;-1:-1:-1;;;;;;7255:1238:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;14:765:1:-;;135:3;128:4;120:6;116:17;112:27;102:2;;157:5;150;143:20;102:2;197:6;184:20;223:4;247:73;262:57;316:2;262:57;:::i;:::-;247:73;:::i;:::-;354:15;;;385:12;;;;417:15;;;451:4;486:11;;;474:24;;470:33;;467:42;-1:-1:-1;464:2:1;;;526:5;519;512:20;464:2;552:5;566:184;580:2;577:1;574:9;566:184;;;637:38;671:3;666;637:38;:::i;:::-;625:51;;696:12;;;;728;;;;598:1;591:9;566:184;;;-1:-1:-1;768:5:1;;92:687;-1:-1:-1;;;;;;;;92:687:1:o;784:698::-;;892:3;885:4;877:6;873:17;869:27;859:2;;914:5;907;900:20;859:2;951;945:9;993:2;985:6;981:15;1062:6;1050:10;1047:22;1026:18;1014:10;1011:34;1008:62;1005:2;;;1073:9;1005:2;1104:10;1100:2;1093:22;;1135:6;1161;1199:3;1194:2;1186:6;1182:15;1179:24;1176:2;;;1220:5;1213;1206:20;1176:2;1246:5;1260:192;1274:4;1271:1;1268:11;1260:192;;;1333:17;;1321:30;;1374:4;1398:12;;;;1430;;;;1294:1;1287:9;1260:192;;;-1:-1:-1;1470:6:1;;849:633;-1:-1:-1;;;;;849:633:1:o;1487:478::-;;1592:4;1580:9;1575:3;1571:19;1567:30;1564:2;;;1614:5;1607;1600:20;1564:2;1651:4;1645:11;1695:4;1687:6;1683:17;1766:6;1754:10;1751:22;1730:18;1718:10;1715:34;1712:62;1709:2;;;1777:9;1709:2;1804:4;1797:24;1869:23;;1854:39;;1954:2;1939:18;;;1926:32;1909:15;;;1902:57;;;;-1:-1:-1;1839:6:1;1554:411;-1:-1:-1;1554:411:1:o;1970:526::-;;2075:4;2063:9;2058:3;2054:19;2050:30;2047:2;;;2097:5;2090;2083:20;2047:2;2134:4;2128:11;2178:4;2170:6;2166:17;2249:6;2237:10;2234:22;2213:18;2201:10;2198:34;2195:62;2192:2;;;2260:9;2192:2;2287:4;2280:24;2322:6;-1:-1:-1;2322:6:1;2352:45;2393:3;2382:9;2352:45;:::i;:::-;2344:6;2337:61;2433:56;2485:3;2478:4;2467:9;2463:20;2433:56;:::i;:::-;2426:4;2418:6;2414:17;2407:83;;2037:459;;;;:::o;2501:606::-;;2604:6;2592:9;2587:3;2583:19;2579:32;2576:2;;;2628:5;2621;2614:20;2576:2;2665;2659:9;2707:4;2699:6;2695:17;2778:6;2766:10;2763:22;2742:18;2730:10;2727:34;2724:62;2721:2;;;2789:9;2721:2;2816;2809:22;2849:6;-1:-1:-1;2849:6:1;2879:44;2919:3;2908:9;2879:44;:::i;:::-;2871:6;2864:60;2959:53;3008:3;3003:2;2992:9;2988:18;2959:53;:::i;:::-;2952:4;2944:6;2940:17;2933:80;3046:54;3096:3;3090;3079:9;3075:19;3046:54;:::i;:::-;3041:2;3033:6;3029:15;3022:79;;2566:541;;;;:::o;3112:930::-;;3222:6;3210:9;3205:3;3201:19;3197:32;3194:2;;;3246:5;3239;3232:20;3194:2;3283;3277:9;3325:4;3317:6;3313:17;3349:18;3417:6;3405:10;3402:22;3397:2;3385:10;3382:18;3379:46;3376:2;;;3428:9;3376:2;3459:10;3455:2;3448:22;3488:6;3479:15;;3518:44;3558:3;3547:9;3518:44;:::i;:::-;3510:6;3503:60;3598:53;3647:3;3642:2;3631:9;3627:18;3598:53;:::i;:::-;3591:4;3583:6;3579:17;3572:80;3685:54;3735:3;3729;3718:9;3714:19;3685:54;:::i;:::-;3680:2;3672:6;3668:15;3661:79;3775:54;3825:3;3819;3808:9;3804:19;3775:54;:::i;:::-;3768:4;3760:6;3756:17;3749:81;3881:3;3870:9;3866:19;3853:33;3839:47;;3909:2;3901:6;3898:14;3895:2;;;3925:1;3922;3915:12;3895:2;;3964:71;4031:3;4022:6;4011:9;4007:22;3964:71;:::i;:::-;3957:4;3949:6;3945:17;3938:98;;;3184:858;;;;:::o;4047:1342::-;;;;4267:3;4255:9;4246:7;4242:23;4238:33;4235:2;;;4289:6;4281;4274:22;4235:2;4334:9;4321:23;4363:18;4404:2;4396:6;4393:14;4390:2;;;4425:6;4417;4410:22;4390:2;4468:6;4457:9;4453:22;4443:32;;4513:7;4506:4;4502:2;4498:13;4494:27;4484:2;;4540:6;4532;4525:22;4484:2;4581;4568:16;4603:4;4627:73;4642:57;4696:2;4642:57;:::i;4627:73::-;4734:15;;;4765:12;;;;4797:11;;;4835;;;4827:20;;4823:29;;4820:42;-1:-1:-1;4817:2:1;;;4880:6;4872;4865:22;4817:2;4907:6;4898:15;;4922:163;4936:2;4933:1;4930:9;4922:163;;;4993:17;;4981:30;;4954:1;4947:9;;;;;5031:12;;;;5063;;4922:163;;;-1:-1:-1;5104:5:1;-1:-1:-1;5128:55:1;;-1:-1:-1;5175:7:1;5155:18;;;5128:55;:::i;:::-;5118:65;;;;5236:3;5225:9;5221:19;5208:33;5192:49;;5266:2;5256:8;5253:16;5250:2;;;5287:6;5279;5272:22;5250:2;;5315:68;5375:7;5364:8;5353:9;5349:24;5315:68;:::i;:::-;5305:78;;;4225:1164;;;;;:::o;5394:187::-;5559:14;;5552:22;5534:41;;5522:2;5507:18;;5489:92::o;5586:342::-;5788:2;5770:21;;;5827:2;5807:18;;;5800:30;-1:-1:-1;;;5861:2:1;5846:18;;5839:48;5919:2;5904:18;;5760:168::o;5933:342::-;6135:2;6117:21;;;6174:2;6154:18;;;6147:30;-1:-1:-1;;;6208:2:1;6193:18;;6186:48;6266:2;6251:18;;6107:168::o;6280:355::-;6482:2;6464:21;;;6521:2;6501:18;;;6494:30;6560:33;6555:2;6540:18;;6533:61;6626:2;6611:18;;6454:181::o;6640:346::-;6842:2;6824:21;;;6881:2;6861:18;;;6854:30;-1:-1:-1;;;6915:2:1;6900:18;;6893:52;6977:2;6962:18;;6814:172::o;6991:342::-;7193:2;7175:21;;;7232:2;7212:18;;;7205:30;-1:-1:-1;;;7266:2:1;7251:18;;7244:48;7324:2;7309:18;;7165:168::o;7338:345::-;7540:2;7522:21;;;7579:2;7559:18;;;7552:30;-1:-1:-1;;;7613:2:1;7598:18;;7591:51;7674:2;7659:18;;7512:171::o;7688:242::-;7758:2;7752:9;7788:17;;;7835:18;7820:34;;7856:22;;;7817:62;7814:2;;;7882:9;7814:2;7909;7902:22;7732:198;;-1:-1:-1;7732:198:1:o;7935:191::-;;8042:18;8034:6;8031:30;8028:2;;;8064:9;8028:2;-1:-1:-1;8115:4:1;8096:17;;;8092:28;;8018:108::o","linkReferences":{}},"methodIdentifiers":{"verify(uint256[],((uint256,uint256),(uint256[2],uint256[2]),(uint256,uint256)),((uint256,uint256),(uint256[2],uint256[2]),(uint256[2],uint256[2]),(uint256[2],uint256[2]),(uint256,uint256)[]))":"9416c1ee"},"ast":{"absolutePath":"src\/verifier.sol","id":869,"exportedSymbols":{"Pairing":[868],"TestVerifier":[39],"Verifier":[279]},"nodeType":"SourceUnit","src":"1262:8864:0","nodes":[{"id":1,"nodeType":"PragmaDirective","src":"1262:23:0","literals":["solidity","^","0.7",".6"]},{"id":2,"nodeType":"PragmaDirective","src":"1286:19:0","literals":["abicoder","v2"]},{"id":39,"nodeType":"ContractDefinition","src":"1307:423:0","nodes":[{"id":6,"nodeType":"FunctionDefinition","src":"1334:16:0","body":{"id":5,"nodeType":"Block","src":"1348:2:0","statements":[]},"implemented":true,"kind":"constructor","modifiers":[],"name":"","parameters":{"id":3,"nodeType":"ParameterList","parameters":[],"src":"1345:2:0"},"returnParameters":{"id":4,"nodeType":"ParameterList","parameters":[],"src":"1348:0:0"},"scope":39,"stateMutability":"nonpayable","virtual":false,"visibility":"public"},{"id":38,"nodeType":"FunctionDefinition","src":"1356:372:0","body":{"id":37,"nodeType":"Block","src":"1515:213:0","statements":[{"assignments":[19],"declarations":[{"constant":false,"id":19,"mutability":"mutable","name":"err","nodeType":"VariableDeclaration","scope":37,"src":"1525:11:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":18,"name":"uint256","nodeType":"ElementaryTypeName","src":"1525:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":26,"initialValue":{"arguments":[{"id":22,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":9,"src":"1568:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},{"id":23,"name":"proof","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":11,"src":"1587:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"}},{"id":24,"name":"vk","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":13,"src":"1606:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"},{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"},{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}],"expression":{"id":20,"name":"Verifier","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":279,"src":"1539:8:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Verifier_$279_$","typeString":"type(library Verifier)"}},"id":21,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"verify","nodeType":"MemberAccess","referencedDeclaration":178,"src":"1539:15:0","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_array$_t_uint256_$dyn_memory_ptr_$_t_struct$_Proof_$60_memory_ptr_$_t_struct$_VerifyingKey_$53_memory_ptr_$returns$_t_uint256_$","typeString":"function (uint256[] memory,struct Verifier.Proof memory,struct Verifier.VerifyingKey memory) view returns (uint256)"}},"id":25,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"1539:79:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"VariableDeclarationStatement","src":"1525:93:0"},{"condition":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":29,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":27,"name":"err","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":19,"src":"1633:3:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"30","id":28,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"1640:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"src":"1633:8:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":35,"nodeType":"Block","src":"1685:37:0","statements":[{"expression":{"hexValue":"66616c7365","id":33,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"1706:5:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"false"},"functionReturnParameters":17,"id":34,"nodeType":"Return","src":"1699:12:0"}]},"id":36,"nodeType":"IfStatement","src":"1629:93:0","trueBody":{"id":32,"nodeType":"Block","src":"1643:36:0","statements":[{"expression":{"hexValue":"74727565","id":30,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"1664:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"},"functionReturnParameters":17,"id":31,"nodeType":"Return","src":"1657:11:0"}]}}]},"functionSelector":"9416c1ee","implemented":true,"kind":"function","modifiers":[],"name":"verify","parameters":{"id":14,"nodeType":"ParameterList","parameters":[{"constant":false,"id":9,"mutability":"mutable","name":"input","nodeType":"VariableDeclaration","scope":38,"src":"1381:22:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[]"},"typeName":{"baseType":{"id":7,"name":"uint256","nodeType":"ElementaryTypeName","src":"1381:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":8,"nodeType":"ArrayTypeName","src":"1381:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_storage_ptr","typeString":"uint256[]"}},"visibility":"internal"},{"constant":false,"id":11,"mutability":"mutable","name":"proof","nodeType":"VariableDeclaration","scope":38,"src":"1413:27:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof"},"typeName":{"id":10,"name":"Verifier.Proof","nodeType":"UserDefinedTypeName","referencedDeclaration":60,"src":"1413:14:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_storage_ptr","typeString":"struct Verifier.Proof"}},"visibility":"internal"},{"constant":false,"id":13,"mutability":"mutable","name":"vk","nodeType":"VariableDeclaration","scope":38,"src":"1450:31:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey"},"typeName":{"id":12,"name":"Verifier.VerifyingKey","nodeType":"UserDefinedTypeName","referencedDeclaration":53,"src":"1450:21:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_storage_ptr","typeString":"struct Verifier.VerifyingKey"}},"visibility":"internal"}],"src":"1371:116:0"},"returnParameters":{"id":17,"nodeType":"ParameterList","parameters":[{"constant":false,"id":16,"mutability":"mutable","name":"","nodeType":"VariableDeclaration","scope":38,"src":"1509:4:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":15,"name":"bool","nodeType":"ElementaryTypeName","src":"1509:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"1508:6:0"},"scope":39,"stateMutability":"view","virtual":false,"visibility":"public"}],"abstract":false,"baseContracts":[],"contractDependencies":[],"contractKind":"contract","fullyImplemented":true,"linearizedBaseContracts":[39],"name":"TestVerifier","scope":869},{"id":279,"nodeType":"ContractDefinition","src":"1732:1942:0","nodes":[{"id":41,"nodeType":"UsingForDirective","src":"1755:20:0","libraryName":{"id":40,"name":"Pairing","nodeType":"UserDefinedTypeName","referencedDeclaration":868,"src":"1761:7:0","typeDescriptions":{"typeIdentifier":"t_contract$_Pairing_$868","typeString":"library Pairing"}}},{"id":53,"nodeType":"StructDefinition","src":"1780:183:0","canonicalName":"Verifier.VerifyingKey","members":[{"constant":false,"id":43,"mutability":"mutable","name":"alfa1","nodeType":"VariableDeclaration","scope":53,"src":"1810:21:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":42,"name":"Pairing.G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"1810:15:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":45,"mutability":"mutable","name":"beta2","nodeType":"VariableDeclaration","scope":53,"src":"1841:21:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":44,"name":"Pairing.G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"1841:15:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":47,"mutability":"mutable","name":"gamma2","nodeType":"VariableDeclaration","scope":53,"src":"1872:22:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":46,"name":"Pairing.G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"1872:15:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":49,"mutability":"mutable","name":"delta2","nodeType":"VariableDeclaration","scope":53,"src":"1904:22:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":48,"name":"Pairing.G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"1904:15:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":52,"mutability":"mutable","name":"IC","nodeType":"VariableDeclaration","scope":53,"src":"1936:20:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_storage_$dyn_storage_ptr","typeString":"struct Pairing.G1Point[]"},"typeName":{"baseType":{"id":50,"name":"Pairing.G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"1936:15:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"id":51,"nodeType":"ArrayTypeName","src":"1936:17:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_storage_$dyn_storage_ptr","typeString":"struct Pairing.G1Point[]"}},"visibility":"internal"}],"name":"VerifyingKey","scope":279,"visibility":"public"},{"id":60,"nodeType":"StructDefinition","src":"1968:101:0","canonicalName":"Verifier.Proof","members":[{"constant":false,"id":55,"mutability":"mutable","name":"A","nodeType":"VariableDeclaration","scope":60,"src":"1991:17:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":54,"name":"Pairing.G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"1991:15:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":57,"mutability":"mutable","name":"B","nodeType":"VariableDeclaration","scope":60,"src":"2018:17:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":56,"name":"Pairing.G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"2018:15:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":59,"mutability":"mutable","name":"C","nodeType":"VariableDeclaration","scope":60,"src":"2045:17:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":58,"name":"Pairing.G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"2045:15:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"}],"name":"Proof","scope":279,"visibility":"public"},{"id":178,"nodeType":"FunctionDefinition","src":"2075:1054:0","body":{"id":177,"nodeType":"Block","src":"2221:908:0","statements":[{"assignments":[73],"declarations":[{"constant":false,"id":73,"mutability":"mutable","name":"snark_scalar_field","nodeType":"VariableDeclaration","scope":177,"src":"2231:26:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":72,"name":"uint256","nodeType":"ElementaryTypeName","src":"2231:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":75,"initialValue":{"hexValue":"3231383838323432383731383339323735323232323436343035373435323537323735303838353438333634343030343136303334333433363938323034313836353735383038343935363137","id":74,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2260:77:0","typeDescriptions":{"typeIdentifier":"t_rational_21888242871839275222246405745257275088548364400416034343698204186575808495617_by_1","typeString":"int_const 2188...(69 digits omitted)...5617"},"value":"21888242871839275222246405745257275088548364400416034343698204186575808495617"},"nodeType":"VariableDeclarationStatement","src":"2231:106:0"},{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":84,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":80,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":77,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":63,"src":"2355:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":78,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"length","nodeType":"MemberAccess","src":"2355:12:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"31","id":79,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2370:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"src":"2355:16:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"expression":{"id":81,"name":"vk","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":67,"src":"2375:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}},"id":82,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"IC","nodeType":"MemberAccess","referencedDeclaration":52,"src":"2375:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":83,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"length","nodeType":"MemberAccess","src":"2375:12:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"2355:32:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"76657269666965722d6261642d696e707574","id":85,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2389:20:0","typeDescriptions":{"typeIdentifier":"t_stringliteral_62f18c0da782e23b7e947e83d22170e983c1918040b5b1bd1c1e3ee5a50cc57a","typeString":"literal_string \"verifier-bad-input\""},"value":"verifier-bad-input"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_62f18c0da782e23b7e947e83d22170e983c1918040b5b1bd1c1e3ee5a50cc57a","typeString":"literal_string \"verifier-bad-input\""}],"id":76,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2347:7:0","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":86,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"2347:63:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":87,"nodeType":"ExpressionStatement","src":"2347:63:0"},{"assignments":[91],"declarations":[{"constant":false,"id":91,"mutability":"mutable","name":"vk_x","nodeType":"VariableDeclaration","scope":177,"src":"2467:27:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":90,"name":"Pairing.G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"2467:15:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"}],"id":97,"initialValue":{"arguments":[{"hexValue":"30","id":94,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2513:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},{"hexValue":"30","id":95,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2516:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"expression":{"id":92,"name":"Pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":868,"src":"2497:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Pairing_$868_$","typeString":"type(library Pairing)"}},"id":93,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"G1Point","nodeType":"MemberAccess","referencedDeclaration":284,"src":"2497:15:0","typeDescriptions":{"typeIdentifier":"t_type$_t_struct$_G1Point_$284_storage_ptr_$","typeString":"type(struct Pairing.G1Point storage pointer)"}},"id":96,"isConstant":false,"isLValue":false,"isPure":true,"kind":"structConstructorCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"2497:21:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"VariableDeclarationStatement","src":"2467:51:0"},{"body":{"id":137,"nodeType":"Block","src":"2571:185:0","statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":114,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"baseExpression":{"id":110,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":63,"src":"2593:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":112,"indexExpression":{"id":111,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":99,"src":"2599:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"2593:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"<","rightExpression":{"id":113,"name":"snark_scalar_field","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":73,"src":"2604:18:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"2593:29:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"76657269666965722d6774652d736e61726b2d7363616c61722d6669656c64","id":115,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"2624:33:0","typeDescriptions":{"typeIdentifier":"t_stringliteral_8cb5a586d84bd3fa5140c79c44fd5cd5a5b0e7e59a1ddee2846426486e57f847","typeString":"literal_string \"verifier-gte-snark-scalar-field\""},"value":"verifier-gte-snark-scalar-field"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_8cb5a586d84bd3fa5140c79c44fd5cd5a5b0e7e59a1ddee2846426486e57f847","typeString":"literal_string \"verifier-gte-snark-scalar-field\""}],"id":109,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"2585:7:0","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":116,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"2585:73:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":117,"nodeType":"ExpressionStatement","src":"2585:73:0"},{"expression":{"id":135,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":118,"name":"vk_x","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":91,"src":"2672:4:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[{"id":121,"name":"vk_x","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":91,"src":"2696:4:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},{"arguments":[{"baseExpression":{"expression":{"id":124,"name":"vk","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":67,"src":"2721:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}},"id":125,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"IC","nodeType":"MemberAccess","referencedDeclaration":52,"src":"2721:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":129,"indexExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":128,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":126,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":99,"src":"2727:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"31","id":127,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2731:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"src":"2727:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"2721:12:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},{"baseExpression":{"id":130,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":63,"src":"2735:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":132,"indexExpression":{"id":131,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":99,"src":"2741:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"2735:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":122,"name":"Pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":868,"src":"2702:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Pairing_$868_$","typeString":"type(library Pairing)"}},"id":123,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"scalar_mul","nodeType":"MemberAccess","referencedDeclaration":463,"src":"2702:18:0","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_struct$_G1Point_$284_memory_ptr_$_t_uint256_$returns$_t_struct$_G1Point_$284_memory_ptr_$","typeString":"function (struct Pairing.G1Point memory,uint256) view returns (struct Pairing.G1Point memory)"}},"id":133,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"2702:42:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"},{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}],"expression":{"id":119,"name":"Pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":868,"src":"2679:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Pairing_$868_$","typeString":"type(library Pairing)"}},"id":120,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"addition","nodeType":"MemberAccess","referencedDeclaration":416,"src":"2679:16:0","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_struct$_G1Point_$284_memory_ptr_$_t_struct$_G1Point_$284_memory_ptr_$returns$_t_struct$_G1Point_$284_memory_ptr_$","typeString":"function (struct Pairing.G1Point memory,struct Pairing.G1Point memory) view returns (struct Pairing.G1Point memory)"}},"id":134,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"2679:66:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"2672:73:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":136,"nodeType":"ExpressionStatement","src":"2672:73:0"}]},"condition":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":105,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":102,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":99,"src":"2548:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"<","rightExpression":{"expression":{"id":103,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":63,"src":"2552:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":104,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"length","nodeType":"MemberAccess","src":"2552:12:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"2548:16:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":138,"initializationExpression":{"assignments":[99],"declarations":[{"constant":false,"id":99,"mutability":"mutable","name":"i","nodeType":"VariableDeclaration","scope":138,"src":"2533:9:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":98,"name":"uint256","nodeType":"ElementaryTypeName","src":"2533:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":101,"initialValue":{"hexValue":"30","id":100,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2545:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"nodeType":"VariableDeclarationStatement","src":"2533:13:0"},"loopExpression":{"expression":{"id":107,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"UnaryOperation","operator":"++","prefix":false,"src":"2566:3:0","subExpression":{"id":106,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":99,"src":"2566:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":108,"nodeType":"ExpressionStatement","src":"2566:3:0"},"nodeType":"ForStatement","src":"2528:228:0"},{"expression":{"id":148,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"id":139,"name":"vk_x","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":91,"src":"2765:4:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[{"id":142,"name":"vk_x","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":91,"src":"2789:4:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},{"baseExpression":{"expression":{"id":143,"name":"vk","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":67,"src":"2795:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}},"id":144,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"IC","nodeType":"MemberAccess","referencedDeclaration":52,"src":"2795:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":146,"indexExpression":{"hexValue":"30","id":145,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"2801:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"2795:8:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"},{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}],"expression":{"id":140,"name":"Pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":868,"src":"2772:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Pairing_$868_$","typeString":"type(library Pairing)"}},"id":141,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"addition","nodeType":"MemberAccess","referencedDeclaration":416,"src":"2772:16:0","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_struct$_G1Point_$284_memory_ptr_$_t_struct$_G1Point_$284_memory_ptr_$returns$_t_struct$_G1Point_$284_memory_ptr_$","typeString":"function (struct Pairing.G1Point memory,struct Pairing.G1Point memory) view returns (struct Pairing.G1Point memory)"}},"id":147,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"2772:32:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"2765:39:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":149,"nodeType":"ExpressionStatement","src":"2765:39:0"},{"condition":{"id":171,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"UnaryOperation","operator":"!","prefix":true,"src":"2831:254:0","subExpression":{"arguments":[{"arguments":[{"expression":{"id":154,"name":"proof","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":65,"src":"2885:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"}},"id":155,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"A","nodeType":"MemberAccess","referencedDeclaration":55,"src":"2885:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}],"expression":{"id":152,"name":"Pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":868,"src":"2870:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Pairing_$868_$","typeString":"type(library Pairing)"}},"id":153,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"negate","nodeType":"MemberAccess","referencedDeclaration":361,"src":"2870:14:0","typeDescriptions":{"typeIdentifier":"t_function_internal_pure$_t_struct$_G1Point_$284_memory_ptr_$returns$_t_struct$_G1Point_$284_memory_ptr_$","typeString":"function (struct Pairing.G1Point memory) pure returns (struct Pairing.G1Point memory)"}},"id":156,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"2870:23:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},{"expression":{"id":157,"name":"proof","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":65,"src":"2911:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"}},"id":158,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"B","nodeType":"MemberAccess","referencedDeclaration":57,"src":"2911:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},{"expression":{"id":159,"name":"vk","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":67,"src":"2936:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}},"id":160,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"alfa1","nodeType":"MemberAccess","referencedDeclaration":43,"src":"2936:8:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},{"expression":{"id":161,"name":"vk","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":67,"src":"2962:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}},"id":162,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"beta2","nodeType":"MemberAccess","referencedDeclaration":45,"src":"2962:8:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},{"id":163,"name":"vk_x","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":91,"src":"2988:4:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},{"expression":{"id":164,"name":"vk","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":67,"src":"3010:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}},"id":165,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"gamma2","nodeType":"MemberAccess","referencedDeclaration":47,"src":"3010:9:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},{"expression":{"id":166,"name":"proof","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":65,"src":"3037:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"}},"id":167,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"C","nodeType":"MemberAccess","referencedDeclaration":59,"src":"3037:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},{"expression":{"id":168,"name":"vk","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":67,"src":"3062:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}},"id":169,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"delta2","nodeType":"MemberAccess","referencedDeclaration":49,"src":"3062:9:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"},{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"},{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"},{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"},{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"},{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"},{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"},{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}],"expression":{"id":150,"name":"Pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":868,"src":"2832:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Pairing_$868_$","typeString":"type(library Pairing)"}},"id":151,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"pairingProd4","nodeType":"MemberAccess","referencedDeclaration":867,"src":"2832:20:0","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_struct$_G1Point_$284_memory_ptr_$_t_struct$_G2Point_$293_memory_ptr_$_t_struct$_G1Point_$284_memory_ptr_$_t_struct$_G2Point_$293_memory_ptr_$_t_struct$_G1Point_$284_memory_ptr_$_t_struct$_G2Point_$293_memory_ptr_$_t_struct$_G1Point_$284_memory_ptr_$_t_struct$_G2Point_$293_memory_ptr_$returns$_t_bool_$","typeString":"function (struct Pairing.G1Point memory,struct Pairing.G2Point memory,struct Pairing.G1Point memory,struct Pairing.G2Point memory,struct Pairing.G1Point memory,struct Pairing.G2Point memory,struct Pairing.G1Point memory,struct Pairing.G2Point memory) view returns (bool)"}},"id":170,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"2832:253:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":174,"nodeType":"IfStatement","src":"2814:290:0","trueBody":{"expression":{"hexValue":"31","id":172,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3103:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"functionReturnParameters":71,"id":173,"nodeType":"Return","src":"3096:8:0"}},{"expression":{"hexValue":"30","id":175,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3121:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"functionReturnParameters":71,"id":176,"nodeType":"Return","src":"3114:8:0"}]},"implemented":true,"kind":"function","modifiers":[],"name":"verify","parameters":{"id":68,"nodeType":"ParameterList","parameters":[{"constant":false,"id":63,"mutability":"mutable","name":"input","nodeType":"VariableDeclaration","scope":178,"src":"2100:22:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[]"},"typeName":{"baseType":{"id":61,"name":"uint256","nodeType":"ElementaryTypeName","src":"2100:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":62,"nodeType":"ArrayTypeName","src":"2100:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_storage_ptr","typeString":"uint256[]"}},"visibility":"internal"},{"constant":false,"id":65,"mutability":"mutable","name":"proof","nodeType":"VariableDeclaration","scope":178,"src":"2132:18:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof"},"typeName":{"id":64,"name":"Proof","nodeType":"UserDefinedTypeName","referencedDeclaration":60,"src":"2132:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_storage_ptr","typeString":"struct Verifier.Proof"}},"visibility":"internal"},{"constant":false,"id":67,"mutability":"mutable","name":"vk","nodeType":"VariableDeclaration","scope":178,"src":"2160:22:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey"},"typeName":{"id":66,"name":"VerifyingKey","nodeType":"UserDefinedTypeName","referencedDeclaration":53,"src":"2160:12:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_storage_ptr","typeString":"struct Verifier.VerifyingKey"}},"visibility":"internal"}],"src":"2090:98:0"},"returnParameters":{"id":71,"nodeType":"ParameterList","parameters":[{"constant":false,"id":70,"mutability":"mutable","name":"","nodeType":"VariableDeclaration","scope":178,"src":"2212:7:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":69,"name":"uint256","nodeType":"ElementaryTypeName","src":"2212:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"2211:9:0"},"scope":279,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":278,"nodeType":"FunctionDefinition","src":"3135:537:0","body":{"id":277,"nodeType":"Block","src":"3345:327:0","statements":[{"assignments":[203],"declarations":[{"constant":false,"id":203,"mutability":"mutable","name":"proof","nodeType":"VariableDeclaration","scope":277,"src":"3355:18:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof"},"typeName":{"id":202,"name":"Proof","nodeType":"UserDefinedTypeName","referencedDeclaration":60,"src":"3355:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_storage_ptr","typeString":"struct Verifier.Proof"}},"visibility":"internal"}],"id":204,"nodeType":"VariableDeclarationStatement","src":"3355:18:0"},{"expression":{"id":217,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"expression":{"id":205,"name":"proof","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":203,"src":"3383:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"}},"id":207,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"memberName":"A","nodeType":"MemberAccess","referencedDeclaration":55,"src":"3383:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[{"baseExpression":{"id":210,"name":"a","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":182,"src":"3409:1:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":212,"indexExpression":{"hexValue":"30","id":211,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3411:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3409:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},{"baseExpression":{"id":213,"name":"a","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":182,"src":"3415:1:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":215,"indexExpression":{"hexValue":"31","id":214,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3417:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3415:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":208,"name":"Pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":868,"src":"3393:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Pairing_$868_$","typeString":"type(library Pairing)"}},"id":209,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"G1Point","nodeType":"MemberAccess","referencedDeclaration":284,"src":"3393:15:0","typeDescriptions":{"typeIdentifier":"t_type$_t_struct$_G1Point_$284_storage_ptr_$","typeString":"type(struct Pairing.G1Point storage pointer)"}},"id":216,"isConstant":false,"isLValue":false,"isPure":false,"kind":"structConstructorCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"3393:27:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"3383:37:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":218,"nodeType":"ExpressionStatement","src":"3383:37:0"},{"expression":{"id":247,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"expression":{"id":219,"name":"proof","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":203,"src":"3430:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"}},"id":221,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"memberName":"B","nodeType":"MemberAccess","referencedDeclaration":57,"src":"3430:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[{"components":[{"baseExpression":{"baseExpression":{"id":224,"name":"b","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":188,"src":"3457:1:0","typeDescriptions":{"typeIdentifier":"t_array$_t_array$_t_uint256_$2_memory_ptr_$2_memory_ptr","typeString":"uint256[2] memory[2] memory"}},"id":226,"indexExpression":{"hexValue":"30","id":225,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3459:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3457:4:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":228,"indexExpression":{"hexValue":"30","id":227,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3462:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3457:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},{"baseExpression":{"baseExpression":{"id":229,"name":"b","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":188,"src":"3466:1:0","typeDescriptions":{"typeIdentifier":"t_array$_t_array$_t_uint256_$2_memory_ptr_$2_memory_ptr","typeString":"uint256[2] memory[2] memory"}},"id":231,"indexExpression":{"hexValue":"30","id":230,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3468:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3466:4:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":233,"indexExpression":{"hexValue":"31","id":232,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3471:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3466:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"id":234,"isConstant":false,"isInlineArray":true,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"3456:18:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},{"components":[{"baseExpression":{"baseExpression":{"id":235,"name":"b","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":188,"src":"3477:1:0","typeDescriptions":{"typeIdentifier":"t_array$_t_array$_t_uint256_$2_memory_ptr_$2_memory_ptr","typeString":"uint256[2] memory[2] memory"}},"id":237,"indexExpression":{"hexValue":"31","id":236,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3479:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3477:4:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":239,"indexExpression":{"hexValue":"30","id":238,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3482:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3477:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},{"baseExpression":{"baseExpression":{"id":240,"name":"b","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":188,"src":"3486:1:0","typeDescriptions":{"typeIdentifier":"t_array$_t_array$_t_uint256_$2_memory_ptr_$2_memory_ptr","typeString":"uint256[2] memory[2] memory"}},"id":242,"indexExpression":{"hexValue":"31","id":241,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3488:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3486:4:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":244,"indexExpression":{"hexValue":"31","id":243,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3491:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3486:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"id":245,"isConstant":false,"isInlineArray":true,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"3476:18:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"},{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}],"expression":{"id":222,"name":"Pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":868,"src":"3440:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Pairing_$868_$","typeString":"type(library Pairing)"}},"id":223,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"G2Point","nodeType":"MemberAccess","referencedDeclaration":293,"src":"3440:15:0","typeDescriptions":{"typeIdentifier":"t_type$_t_struct$_G2Point_$293_storage_ptr_$","typeString":"type(struct Pairing.G2Point storage pointer)"}},"id":246,"isConstant":false,"isLValue":false,"isPure":false,"kind":"structConstructorCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"3440:55:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"3430:65:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":248,"nodeType":"ExpressionStatement","src":"3430:65:0"},{"expression":{"id":261,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"expression":{"id":249,"name":"proof","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":203,"src":"3505:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"}},"id":251,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"memberName":"C","nodeType":"MemberAccess","referencedDeclaration":59,"src":"3505:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"arguments":[{"baseExpression":{"id":254,"name":"c","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":192,"src":"3531:1:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":256,"indexExpression":{"hexValue":"30","id":255,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3533:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3531:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},{"baseExpression":{"id":257,"name":"c","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":192,"src":"3537:1:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":259,"indexExpression":{"hexValue":"31","id":258,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3539:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"3537:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"expression":{"id":252,"name":"Pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":868,"src":"3515:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_contract$_Pairing_$868_$","typeString":"type(library Pairing)"}},"id":253,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"G1Point","nodeType":"MemberAccess","referencedDeclaration":284,"src":"3515:15:0","typeDescriptions":{"typeIdentifier":"t_type$_t_struct$_G1Point_$284_storage_ptr_$","typeString":"type(struct Pairing.G1Point storage pointer)"}},"id":260,"isConstant":false,"isLValue":false,"isPure":false,"kind":"structConstructorCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"3515:27:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"3505:37:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":262,"nodeType":"ExpressionStatement","src":"3505:37:0"},{"condition":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":269,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"arguments":[{"id":264,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":195,"src":"3563:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},{"id":265,"name":"proof","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":203,"src":"3570:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"}},{"id":266,"name":"vk","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":197,"src":"3577:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"},{"typeIdentifier":"t_struct$_Proof_$60_memory_ptr","typeString":"struct Verifier.Proof memory"},{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey memory"}],"id":263,"name":"verify","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":178,"src":"3556:6:0","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_array$_t_uint256_$dyn_memory_ptr_$_t_struct$_Proof_$60_memory_ptr_$_t_struct$_VerifyingKey_$53_memory_ptr_$returns$_t_uint256_$","typeString":"function (uint256[] memory,struct Verifier.Proof memory,struct Verifier.VerifyingKey memory) view returns (uint256)"}},"id":267,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"3556:24:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"30","id":268,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3584:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"src":"3556:29:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"falseBody":{"id":275,"nodeType":"Block","src":"3629:37:0","statements":[{"expression":{"hexValue":"66616c7365","id":273,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"3650:5:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"false"},"functionReturnParameters":201,"id":274,"nodeType":"Return","src":"3643:12:0"}]},"id":276,"nodeType":"IfStatement","src":"3552:114:0","trueBody":{"id":272,"nodeType":"Block","src":"3587:36:0","statements":[{"expression":{"hexValue":"74727565","id":270,"isConstant":false,"isLValue":false,"isPure":true,"kind":"bool","lValueRequested":false,"nodeType":"Literal","src":"3608:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"value":"true"},"functionReturnParameters":201,"id":271,"nodeType":"Return","src":"3601:11:0"}]}}]},"implemented":true,"kind":"function","modifiers":[],"name":"verifyProof","parameters":{"id":198,"nodeType":"ParameterList","parameters":[{"constant":false,"id":182,"mutability":"mutable","name":"a","nodeType":"VariableDeclaration","scope":278,"src":"3165:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2]"},"typeName":{"baseType":{"id":179,"name":"uint256","nodeType":"ElementaryTypeName","src":"3165:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":181,"length":{"hexValue":"32","id":180,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3173:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"nodeType":"ArrayTypeName","src":"3165:10:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_storage_ptr","typeString":"uint256[2]"}},"visibility":"internal"},{"constant":false,"id":188,"mutability":"mutable","name":"b","nodeType":"VariableDeclaration","scope":278,"src":"3194:22:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_array$_t_uint256_$2_memory_ptr_$2_memory_ptr","typeString":"uint256[2][2]"},"typeName":{"baseType":{"baseTyp":{"id":183,"name":"uint256","nodeType":"ElementaryTypeName","src":"3194:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":185,"length":{"hexValue":"32","id":184,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3202:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"nodeType":"ArrayTypeName","src":"3194:10:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_storage_ptr","typeString":"uint256[2]"}},"id":187,"length":{"hexValue":"32","id":186,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3205:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"nodeType":"ArrayTypeName","src":"3194:13:0","typeDescriptions":{"typeIdentifier":"t_array$_t_array$_t_uint256_$2_storage_$2_storage_ptr","typeString":"uint256[2][2]"}},"visibility":"internal"},{"constant":false,"id":192,"mutability":"mutable","name":"c","nodeType":"VariableDeclaration","scope":278,"src":"3226:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2]"},"typeName":{"baseType":{"id":189,"name":"uint256","nodeType":"ElementaryTypeName","src":"3226:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":191,"length":{"hexValue":"32","id":190,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3234:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"nodeType":"ArrayTypeName","src":"3226:10:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_storage_ptr","typeString":"uint256[2]"}},"visibility":"internal"},{"constant":false,"id":195,"mutability":"mutable","name":"input","nodeType":"VariableDeclaration","scope":278,"src":"3255:22:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[]"},"typeName":{"baseType":{"id":193,"name":"uint256","nodeType":"ElementaryTypeName","src":"3255:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":194,"nodeType":"ArrayTypeName","src":"3255:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_storage_ptr","typeString":"uint256[]"}},"visibility":"internal"},{"constant":false,"id":197,"mutability":"mutable","name":"vk","nodeType":"VariableDeclaration","scope":278,"src":"3287:22:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_memory_ptr","typeString":"struct Verifier.VerifyingKey"},"typeName":{"id":196,"name":"VerifyingKey","nodeType":"UserDefinedTypeName","referencedDeclaration":53,"src":"3287:12:0","typeDescriptions":{"typeIdentifier":"t_struct$_VerifyingKey_$53_storage_ptr","typeString":"struct Verifier.VerifyingKey"}},"visibility":"internal"}],"src":"3155:160:0"},"returnParameters":{"id":201,"nodeType":"ParameterList","parameters":[{"constant":false,"id":200,"mutability":"mutable","name":"","nodeType":"VariableDeclaration","scope":278,"src":"3339:4:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":199,"name":"bool","nodeType":"ElementaryTypeName","src":"3339:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"3338:6:0"},"scope":279,"stateMutability":"view","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[],"contractDependencies":[],"contractKind":"library","fullyImplemented":true,"linearizedBaseContracts":[279],"name":"Verifier","scope":869},{"id":868,"nodeType":"ContractDefinition","src":"3676:6448:0","nodes":[{"id":284,"nodeType":"StructDefinition","src":"3698:60:0","canonicalName":"Pairing.G1Point","members":[{"constant":false,"id":281,"mutability":"mutable","name":"X","nodeType":"VariableDeclaration","scope":284,"src":"3723:9:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":280,"name":"uint256","nodeType":"ElementaryTypeName","src":"3723:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"},{"constant":false,"id":283,"mutability":"mutable","name":"Y","nodeType":"VariableDeclaration","scope":284,"src":"3742:9:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":282,"name":"uint256","nodeType":"ElementaryTypeName","src":"3742:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"name":"G1Point","scope":868,"visibility":"public"},{"id":293,"nodeType":"StructDefinition","src":"3817:66:0","canonicalName":"Pairing.G2Point","members":[{"constant":false,"id":288,"mutability":"mutable","name":"X","nodeType":"VariableDeclaration","scope":293,"src":"3842:12:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_storage_ptr","typeString":"uint256[2]"},"typeName":{"baseType":{"id":285,"name":"uint256","nodeType":"ElementaryTypeName","src":"3842:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":287,"length":{"hexValue":"32","id":286,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3850:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"nodeType":"ArrayTypeName","src":"3842:10:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_storage_ptr","typeString":"uint256[2]"}},"visibility":"internal"},{"constant":false,"id":292,"mutability":"mutable","name":"Y","nodeType":"VariableDeclaration","scope":293,"src":"3864:12:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_storage_ptr","typeString":"uint256[2]"},"typeName":{"baseType":{"id":289,"name":"uint256","nodeType":"ElementaryTypeName","src":"3864:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":291,"length":{"hexValue":"32","id":290,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"3872:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"nodeType":"ArrayTypeName","src":"3864:10:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_storage_ptr","typeString":"uint256[2]"}},"visibility":"internal"}],"name":"G2Point","scope":868,"visibility":"public"},{"id":305,"nodeType":"FunctionDefinition","src":"3925:90:0","body":{"id":304,"nodeType":"Block","src":"3978:37:0","statements":[{"expression":{"arguments":[{"hexValue":"31","id":300,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"4003:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},{"hexValue":"32","id":301,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"4006:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"}],"id":299,"name":"G1Point","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":284,"src":"3995:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_struct$_G1Point_$284_storage_ptr_$","typeString":"type(struct Pairing.G1Point storage pointer)"}},"id":302,"isConstant":false,"isLValue":false,"isPure":true,"kind":"structConstructorCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"3995:13:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"functionReturnParameters":298,"id":303,"nodeType":"Return","src":"3988:20:0"}]},"documentation":{"id":294,"nodeType":"StructuredDocumentation","src":"3889:31:0","text":"@return the generator of G1"},"implemented":true,"kind":"function","modifiers":[],"name":"P1","parameters":{"id":295,"nodeType":"ParameterList","parameters":[],"src":"3936:2:0"},"returnParameters":{"id":298,"nodeType":"ParameterList","parameters":[{"constant":false,"id":297,"mutability":"mutable","name":"","nodeType":"VariableDeclaration","scope":305,"src":"3962:14:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":296,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"3962:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"}],"src":"3961:16:0"},"scope":868,"stateMutability":"pure","virtual":false,"visibility":"internal"},{"id":321,"nodeType":"FunctionDefinition","src":"4057:1058:0","body":{"id":320,"nodeType":"Block","src":"4110:1005:0","statements":[{"expression":{"arguments":[{"components":[{"hexValue":"3131353539373332303332393836333837313037393931303034303231333932323835373833393235383132383631383231313932353330393137343033313531343532333931383035363334","id":312,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"4217:77:0","typeDescriptions":{"typeIdentifier":"t_rational_11559732032986387107991004021392285783925812861821192530917403151452391805634_by_1","typeString":"int_const 1155...(69 digits omitted)...5634"},"value":"11559732032986387107991004021392285783925812861821192530917403151452391805634"},{"hexValue":"3130383537303436393939303233303537313335393434353730373632323332383239343831333730373536333539353738353138303836393930353139393933323835363535383532373831","id":313,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"4316:77:0","typeDescriptions":{"typeIdentifier":"t_rational_10857046999023057135944570762232829481370756359578518086990519993285655852781_by_1","typeString":"int_const 1085...(69 digits omitted)...2781"},"value":"10857046999023057135944570762232829481370756359578518086990519993285655852781"}],"id":314,"isConstant":false,"isInlineArray":true,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"4195:216:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},{"components":[{"hexValue":"34303832333637383735383633343333363831333332323033343033313435343335353638333136383531333237353933343031323038313035373431303736323134313230303933353331","id":315,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"4451:76:0","typeDescriptions":{"typeIdentifier":"t_rational_4082367875863433681332203403145435568316851327593401208105741076214120093531_by_1","typeString":"int_const 4082...(68 digits omitted)...3531"},"value":"4082367875863433681332203403145435568316851327593401208105741076214120093531"},{"hexValue":"38343935363533393233313233343331343137363034393733323437343839323732343338343138313930353837323633363030313438373730323830363439333036393538313031393330","id":316,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"4549:76:0","typeDescriptions":{"typeIdentifier":"t_rational_8495653923123431417604973247489272438418190587263600148770280649306958101930_by_1","typeString":"int_const 8495...(68 digits omitted)...1930"},"value":"8495653923123431417604973247489272438418190587263600148770280649306958101930"}],"id":317,"isConstant":false,"isInlineArray":true,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"TupleExpression","src":"4429:214:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"},{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}],"id":311,"name":"G2Point","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":293,"src":"4170:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_struct$_G2Point_$293_storage_ptr_$","typeString":"type(struct Pairing.G2Point storage pointer)"}},"id":318,"isConstant":false,"isLValue":false,"isPure":true,"kind":"structConstructorCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"4170:487:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"functionReturnParameters":310,"id":319,"nodeType":"Return","src":"4151:506:0"}]},"documentation":{"id":306,"nodeType":"StructuredDocumentation","src":"4021:31:0","text":"@return the generator of G2"},"implemented":true,"kind":"function","modifiers":[],"name":"P2","parameters":{"id":307,"nodeType":"ParameterList","parameters":[],"src":"4068:2:0"},"returnParameters":{"id":310,"nodeType":"ParameterList","parameters":[{"constant":false,"id":309,"mutability":"mutable","name":"","nodeType":"VariableDeclaration","scope":321,"src":"4094:14:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":308,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"4094:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"}],"src":"4093:16:0"},"scope":868,"stateMutability":"pure","virtual":false,"visibility":"internal"},{"id":361,"nodeType":"FunctionDefinition","src":"5202:346:0","body":{"id":360,"nodeType":"Block","src":"5277:271:0","statements":[{"assignments":[330],"declarations":[{"constant":false,"id":330,"mutability":"mutable","name":"q","nodeType":"VariableDeclaration","scope":360,"src":"5343:9:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":329,"name":"uint256","nodeType":"ElementaryTypeName","src":"5343:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":332,"initialValue":{"hexValue":"3231383838323432383731383339323735323232323436343035373435323537323735303838363936333131313537323937383233363632363839303337383934363435323236323038353833","id":331,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5364:77:0","typeDescriptions":{"typeIdentifier":"t_rational_21888242871839275222246405745257275088696311157297823662689037894645226208583_by_1","typeString":"int_const 2188...(69 digits omitted)...8583"},"value":"21888242871839275222246405745257275088696311157297823662689037894645226208583"},"nodeType":"VariableDeclarationStatement","src":"5343:98:0"},{"condition":{"commonType":{"typeIdentifier":"t_bool","typeString":"bool"},"id":341,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":336,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":333,"name":"p","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":324,"src":"5455:1:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":334,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"X","nodeType":"MemberAccess","referencedDeclaration":281,"src":"5455:3:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"30","id":335,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5462:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"src":"5455:8:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"nodeType":"BinaryOperation","operator":"&&","rightExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":340,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":337,"name":"p","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":324,"src":"5467:1:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":338,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"Y","nodeType":"MemberAccess","referencedDeclaration":283,"src":"5467:3:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"hexValue":"30","id":339,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5474:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"src":"5467:8:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"src":"5455:20:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":347,"nodeType":"IfStatement","src":"5451:46:0","trueBody":{"expression":{"arguments":[{"hexValue":"30","id":343,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5492:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},{"hexValue":"30","id":344,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5495:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"}],"id":342,"name":"G1Point","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":284,"src":"5484:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_struct$_G1Point_$284_storage_ptr_$","typeString":"type(struct Pairing.G1Point storage pointer)"}},"id":345,"isConstant":false,"isLValue":false,"isPure":true,"kind":"structConstructorCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"5484:13:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"functionReturnParameters":328,"id":346,"nodeType":"Return","src":"5477:20:0"}},{"expression":{"arguments":[{"expression":{"id":349,"name":"p","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":324,"src":"5522:1:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":350,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"X","nodeType":"MemberAccess","referencedDeclaration":281,"src":"5522:3:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":357,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":351,"name":"q","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":330,"src":"5527:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"-","rightExpression":{"components":[{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":355,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":352,"name":"p","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":324,"src":"5532:1:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":353,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"Y","nodeType":"MemberAccess","referencedDeclaration":283,"src":"5532:3:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"%","rightExpression":{"id":354,"name":"q","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":330,"src":"5538:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"5532:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"id":356,"isConstant":false,"isInlineArray":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"TupleExpression","src":"5531:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"5527:13:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"},{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":348,"name":"G1Point","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":284,"src":"5514:7:0","typeDescriptions":{"typeIdentifier":"t_type$_t_struct$_G1Point_$284_storage_ptr_$","typeString":"type(struct Pairing.G1Point storage pointer)"}},"id":358,"isConstant":false,"isLValue":false,"isPure":false,"kind":"structConstructorCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"5514:27:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"functionReturnParameters":328,"id":359,"nodeType":"Return","src":"5507:34:0"}]},"documentation":{"id":322,"nodeType":"StructuredDocumentation","src":"5121:76:0","text":"@return r the negation of p, i.e. p.addition(p.negate()) should be zero."},"implemented":true,"kind":"function","modifiers":[],"name":"negate","parameters":{"id":325,"nodeType":"ParameterList","parameters":[{"constant":false,"id":324,"mutability":"mutable","name":"p","nodeType":"VariableDeclaration","scope":361,"src":"5218:16:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":323,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"5218:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"}],"src":"5217:18:0"},"returnParameters":{"id":328,"nodeType":"ParameterList","parameters":[{"constant":false,"id":327,"mutability":"mutable","name":"r","nodeType":"VariableDeclaration","scope":361,"src":"5259:16:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":326,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"5259:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"}],"src":"5258:18:0"},"scope":868,"stateMutability":"pure","virtual":false,"visibility":"internal"},{"id":416,"nodeType":"FunctionDefinition","src":"5600:662:0","body":{"id":415,"nodeType":"Block","src":"5725:537:0","statements":[{"assignments":[376],"declarations":[{"constant":false,"id":376,"mutability":"mutable","name":"input","nodeType":"VariableDeclaration","scope":415,"src":"5735:23:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$4_memory_ptr","typeString":"uint256[4]"},"typeName":{"baseType":{"id":374,"name":"uint256","nodeType":"ElementaryTypeName","src":"5735:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":375,"length":{"hexValue":"34","id":373,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5743:1:0","typeDescriptions":{"typeIdentifier":"t_rational_4_by_1","typeString":"int_const 4"},"value":"4"},"nodeType":"ArrayTypeName","src":"5735:10:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$4_storage_ptr","typeString":"uint256[4]"}},"visibility":"internal"}],"id":377,"nodeType":"VariableDeclarationStatement","src":"5735:23:0"},{"expression":{"id":383,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":378,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":376,"src":"5768:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$4_memory_ptr","typeString":"uint256[4] memory"}},"id":380,"indexExpression":{"hexValue":"30","id":379,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5774:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"5768:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"expression":{"id":381,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":364,"src":"5779:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":382,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"X","nodeType":"MemberAccess","referencedDeclaration":281,"src":"5779:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"5768:15:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":384,"nodeType":"ExpressionStatement","src":"5768:15:0"},{"expression":{"id":390,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":385,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":376,"src":"5793:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$4_memory_ptr","typeString":"uint256[4] memory"}},"id":387,"indexExpression":{"hexValue":"31","id":386,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5799:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"5793:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"expression":{"id":388,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":364,"src":"5804:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":389,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"Y","nodeType":"MemberAccess","referencedDeclaration":283,"src":"5804:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"5793:15:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":391,"nodeType":"ExpressionStatement","src":"5793:15:0"},{"expression":{"id":397,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":392,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":376,"src":"5818:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$4_memory_ptr","typeString":"uint256[4] memory"}},"id":394,"indexExpression":{"hexValue":"32","id":393,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5824:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"5818:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"expression":{"id":395,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":366,"src":"5829:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":396,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"X","nodeType":"MemberAccess","referencedDeclaration":281,"src":"5829:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"5818:15:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":398,"nodeType":"ExpressionStatement","src":"5818:15:0"},{"expression":{"id":404,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":399,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":376,"src":"5843:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$4_memory_ptr","typeString":"uint256[4] memory"}},"id":401,"indexExpression":{"hexValue":"33","id":400,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"5849:1:0","typeDescriptions":{"typeIdentifier":"t_rational_3_by_1","typeString":"int_const 3"},"value":"3"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"5843:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"expression":{"id":402,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":366,"src":"5854:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":403,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"Y","nodeType":"MemberAccess","referencedDeclaration":283,"src":"5854:4:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"5843:15:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":405,"nodeType":"ExpressionStatement","src":"5843:15:0"},{"assignments":[407],"declarations":[{"constant":false,"id":407,"mutability":"mutable","name":"success","nodeType":"VariableDeclaration","scope":415,"src":"5868:12:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":406,"name":"bool","nodeType":"ElementaryTypeName","src":"5868:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"id":408,"nodeType":"VariableDeclarationStatement","src":"5868:12:0"},{"AST":{"nodeType":"YulBlock","src":"5963:245:0","statements":[{"nodeType":"YulAssignment","src":"5977:64:0","value":{"arguments":[{"arguments":[{"arguments":[],"functionName":{"name":"gas","nodeType":"YulIdentifier","src":"6003:3:0"},"nodeType":"YulFunctionCall","src":"6003:5:0"},{"kind":"number","nodeType":"YulLiteral","src":"6010:4:0","type":"","value":"2000"}],"functionName":{"name":"sub","nodeType":"YulIdentifier","src":"5999:3:0"},"nodeType":"YulFunctionCall","src":"5999:16:0"},{"kind":"number","nodeType":"YulLiteral","src":"6017:1:0","type":"","value":"6"},{"name":"input","nodeType":"YulIdentifier","src":"6020:5:0"},{"kind":"number","nodeType":"YulLiteral","src":"6027:4:0","type":"","value":"0xc0"},{"name":"r","nodeType":"YulIdentifier","src":"6033:1:0"},{"kind":"number","nodeType":"YulLiteral","src":"6036:4:0","type":"","value":"0x60"}],"functionName":{"name":"staticcall","nodeType":"YulIdentifier","src":"5988:10:0"},"nodeType":"YulFunctionCall","src":"5988:53:0"},"variableNames":[{"name":"success","nodeType":"YulIdentifier","src":"5977:7:0"}]},{"cases":[{"body":{"nodeType":"YulBlock","src":"6149:49:0","statements":[{"expression":{"arguments":[],"functionName":{"name":"invalid","nodeType":"YulIdentifier","src":"6171:7:0"},"nodeType":"YulFunctionCall","src":"6171:9:0"},"nodeType":"YulExpressionStatement","src":"6171:9:0"}]},"nodeType":"YulCase","src":"6142:56:0","value":{"kind":"number","nodeType":"YulLiteral","src":"6147:1:0","type":"","value":"0"}}],"expression":{"name":"success","nodeType":"YulIdentifier","src":"6118:7:0"},"nodeType":"YulSwitch","src":"6111:87:0"}]},"evmVersion":"istanbul","externalReferences":[{"declaration":376,"isOffset":false,"isSlot":false,"src":"6020:5:0","valueSize":1},{"declaration":369,"isOffset":false,"isSlot":false,"src":"6033:1:0","valueSize":1},{"declaration":407,"isOffset":false,"isSlot":false,"src":"5977:7:0","valueSize":1},{"declaration":407,"isOffset":false,"isSlot":false,"src":"6118:7:0","valueSize":1}],"id":409,"nodeType":"InlineAssembly","src":"5954:254:0"},{"expression":{"arguments":[{"id":411,"name":"success","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":407,"src":"6225:7:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"70616972696e672d6164642d6661696c6564","id":412,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"6234:20:0","typeDescriptions":{"typeIdentifier":"t_stringliteral_e428a53e578d13ee2fc3b8849114332d6a94afed893fa747a37e281039728688","typeString":"literal_string \"pairing-add-failed\""},"value":"pairing-add-failed"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_e428a53e578d13ee2fc3b8849114332d6a94afed893fa747a37e281039728688","typeString":"literal_string \"pairing-add-failed\""}],"id":410,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"6217:7:0","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":413,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"6217:38:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":414,"nodeType":"ExpressionStatement","src":"6217:38:0"}]},"documentation":{"id":362,"nodeType":"StructuredDocumentation","src":"5554:41:0","text":"@return r the sum of two points of G1"},"implemented":true,"kind":"function","modifiers":[],"name":"addition","parameters":{"id":367,"nodeType":"ParameterList","parameters":[{"constant":false,"id":364,"mutability":"mutable","name":"p1","nodeType":"VariableDeclaration","scope":416,"src":"5618:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":363,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"5618:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":366,"mutability":"mutable","name":"p2","nodeType":"VariableDeclaration","scope":416,"src":"5637:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":365,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"5637:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"}],"src":"5617:38:0"},"returnParameters":{"id":370,"nodeType":"ParameterList","parameters":[{"constant":false,"id":369,"mutability":"mutable","name":"r","nodeType":"VariableDeclaration","scope":416,"src":"5703:16:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":368,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"5703:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"}],"src":"5702:18:0"},"scope":868,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":463,"nodeType":"FunctionDefinition","src":"6418:625:0","body":{"id":462,"nodeType":"Block","src":"6536:507:0","statements":[{"assignments":[431],"declarations":[{"constant":false,"id":431,"mutability":"mutable","name":"input","nodeType":"VariableDeclaration","scope":462,"src":"6546:23:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$3_memory_ptr","typeString":"uint256[3]"},"typeName":{"baseType":{"id":429,"name":"uint256","nodeType":"ElementaryTypeName","src":"6546:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":430,"length":{"hexValue":"33","id":428,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"6554:1:0","typeDescriptions":{"typeIdentifier":"t_rational_3_by_1","typeString":"int_const 3"},"value":"3"},"nodeType":"ArrayTypeName","src":"6546:10:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$3_storage_ptr","typeString":"uint256[3]"}},"visibility":"internal"}],"id":432,"nodeType":"VariableDeclarationStatement","src":"6546:23:0"},{"expression":{"id":438,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":433,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":431,"src":"6579:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$3_memory_ptr","typeString":"uint256[3] memory"}},"id":435,"indexExpression":{"hexValue":"30","id":434,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"6585:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"6579:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"expression":{"id":436,"name":"p","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":419,"src":"6590:1:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":437,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"X","nodeType":"MemberAccess","referencedDeclaration":281,"src":"6590:3:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"6579:14:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":439,"nodeType":"ExpressionStatement","src":"6579:14:0"},{"expression":{"id":445,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":440,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":431,"src":"6603:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$3_memory_ptr","typeString":"uint256[3] memory"}},"id":442,"indexExpression":{"hexValue":"31","id":441,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"6609:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"6603:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"expression":{"id":443,"name":"p","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":419,"src":"6614:1:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":444,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"Y","nodeType":"MemberAccess","referencedDeclaration":283,"src":"6614:3:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"6603:14:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":446,"nodeType":"ExpressionStatement","src":"6603:14:0"},{"expression":{"id":451,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":447,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":431,"src":"6627:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$3_memory_ptr","typeString":"uint256[3] memory"}},"id":449,"indexExpression":{"hexValue":"32","id":448,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"6633:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"6627:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":450,"name":"s","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":421,"src":"6638:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"6627:12:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":452,"nodeType":"ExpressionStatement","src":"6627:12:0"},{"assignments":[454],"declarations":[{"constant":false,"id":454,"mutability":"mutable","name":"success","nodeType":"VariableDeclaration","scope":462,"src":"6649:12:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":453,"name":"bool","nodeType":"ElementaryTypeName","src":"6649:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"id":455,"nodeType":"VariableDeclarationStatement","src":"6649:12:0"},{"AST":{"nodeType":"YulBlock","src":"6744:245:0","statements":[{"nodeType":"YulAssignment","src":"6758:64:0","value":{"arguments":[{"arguments":[{"arguments":[],"functionName":{"name":"gas","nodeType":"YulIdentifier","src":"6784:3:0"},"nodeType":"YulFunctionCall","src":"6784:5:0"},{"kind":"number","nodeType":"YulLiteral","src":"6791:4:0","type":"","value":"2000"}],"functionName":{"name":"sub","nodeType":"YulIdentifier","src":"6780:3:0"},"nodeType":"YulFunctionCall","src":"6780:16:0"},{"kind":"number","nodeType":"YulLiteral","src":"6798:1:0","type":"","value":"7"},{"name":"input","nodeType":"YulIdentifier","src":"6801:5:0"},{"kind":"number","nodeType":"YulLiteral","src":"6808:4:0","type":"","value":"0x80"},{"name":"r","nodeType":"YulIdentifier","src":"6814:1:0"},{"kind":"number","nodeType":"YulLiteral","src":"6817:4:0","type":"","value":"0x60"}],"functionName":{"name":"staticcall","nodeType":"YulIdentifier","src":"6769:10:0"},"nodeType":"YulFunctionCall","src":"6769:53:0"},"variableNames":[{"name":"success","nodeType":"YulIdentifier","src":"6758:7:0"}]},{"cases":[{"body":{"nodeType":"YulBlock","src":"6930:49:0","statements":[{"expression":{"arguments":[],"functionName":{"name":"invalid","nodeType":"YulIdentifier","src":"6952:7:0"},"nodeType":"YulFunctionCall","src":"6952:9:0"},"nodeType":"YulExpressionStatement","src":"6952:9:0"}]},"nodeType":"YulCase","src":"6923:56:0","value":{"kind":"number","nodeType":"YulLiteral","src":"6928:1:0","type":"","value":"0"}}],"expression":{"name":"success","nodeType":"YulIdentifier","src":"6899:7:0"},"nodeType":"YulSwitch","src":"6892:87:0"}]},"evmVersion":"istanbul","externalReferences":[{"declaration":431,"isOffset":false,"isSlot":false,"src":"6801:5:0","valueSize":1},{"declaration":424,"isOffset":false,"isSlot":false,"src":"6814:1:0","valueSize":1},{"declaration":454,"isOffset":false,"isSlot":false,"src":"6758:7:0","valueSize":1},{"declaration":454,"isOffset":false,"isSlot":false,"src":"6899:7:0","valueSize":1}],"id":456,"nodeType":"InlineAssembly","src":"6735:254:0"},{"expression":{"arguments":[{"id":458,"name":"success","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":454,"src":"7006:7:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"70616972696e672d6d756c2d6661696c6564","id":459,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7015:20:0","typeDescriptions":{"typeIdentifier":"t_stringliteral_63b4943691e0891cf5adcfe6e3eb490783b718accceadc0166bc4e56cf1df5de","typeString":"literal_string \"pairing-mul-failed\""},"value":"pairing-mul-failed"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_63b4943691e0891cf5adcfe6e3eb490783b718accceadc0166bc4e56cf1df5de","typeString":"literal_string \"pairing-mul-failed\""}],"id":457,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"6998:7:0","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":460,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"6998:38:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":461,"nodeType":"ExpressionStatement","src":"6998:38:0"}]},"documentation":{"id":417,"nodeType":"StructuredDocumentation","src":"6268:145:0","text":"@return r the product of a point on G1 and a scalar, i.e.\n p == p.scalar_mul(1) and p.addition(p) == p.scalar_mul(2) for all points p."},"implemented":true,"kind":"function","modifiers":[],"name":"scalar_mul","parameters":{"id":422,"nodeType":"ParameterList","parameters":[{"constant":false,"id":419,"mutability":"mutable","name":"p","nodeType":"VariableDeclaration","scope":463,"src":"6438:16:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":418,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"6438:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":421,"mutability":"mutable","name":"s","nodeType":"VariableDeclaration","scope":463,"src":"6456:9:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":420,"name":"uint256","nodeType":"ElementaryTypeName","src":"6456:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"src":"6437:29:0"},"returnParameters":{"id":425,"nodeType":"ParameterList","parameters":[{"constant":false,"id":424,"mutability":"mutable","name":"r","nodeType":"VariableDeclaration","scope":463,"src":"6514:16:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":423,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"6514:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"}],"src":"6513:18:0"},"scope":868,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":627,"nodeType":"FunctionDefinition","src":"7255:1238:0","body":{"id":626,"nodeType":"Block","src":"7371:1122:0","statements":[{"expression":{"arguments":[{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":480,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"expression":{"id":476,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":467,"src":"7389:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":477,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"length","nodeType":"MemberAccess","src":"7389:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"==","rightExpression":{"expression":{"id":478,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":470,"src":"7402:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":479,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"length","nodeType":"MemberAccess","src":"7402:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"7389:22:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"70616972696e672d6c656e677468732d6661696c6564","id":481,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"7413:24:0","typeDescriptions":{"typeIdentifier":"t_stringliteral_d4c505601ed3bad1341fbb75434dd6541f91bae974d0b2bc28d5491a5c4a21cc","typeString":"literal_string \"pairing-lengths-failed\""},"value":"pairing-lengths-failed"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_d4c505601ed3bad1341fbb75434dd6541f91bae974d0b2bc28d5491a5c4a21cc","typeString":"literal_string \"pairing-lengths-failed\""}],"id":475,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"7381:7:0","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":482,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"7381:57:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":483,"nodeType":"ExpressionStatement","src":"7381:57:0"},{"assignments":[485],"declarations":[{"constant":false,"id":485,"mutability":"mutable","name":"elements","nodeType":"VariableDeclaration","scope":626,"src":"7448:16:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":484,"name":"uint256","nodeType":"ElementaryTypeName","src":"7448:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":488,"initialValue":{"expression":{"id":486,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":467,"src":"7467:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":487,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"memberName":"length","nodeType":"MemberAccess","src":"7467:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"VariableDeclarationStatement","src":"7448:28:0"},{"assignments":[490],"declarations":[{"constant":false,"id":490,"mutability":"mutable","name":"inputSize","nodeType":"VariableDeclaration","scope":626,"src":"7486:17:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":489,"name":"uint256","nodeType":"ElementaryTypeName","src":"7486:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":494,"initialValue":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":493,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":491,"name":"elements","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":485,"src":"7506:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"*","rightExpression":{"hexValue":"36","id":492,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7517:1:0","typeDescriptions":{"typeIdentifier":"t_rational_6_by_1","typeString":"int_const 6"},"value":"6"},"src":"7506:12:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"VariableDeclarationStatement","src":"7486:32:0"},{"assignments":[499],"declarations":[{"constant":false,"id":499,"mutability":"mutable","name":"input","nodeType":"VariableDeclaration","scope":626,"src":"7528:22:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[]"},"typeName":{"baseType":{"id":497,"name":"uint256","nodeType":"ElementaryTypeName","src":"7528:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":498,"nodeType":"ArrayTypeName","src":"7528:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_storage_ptr","typeString":"uint256[]"}},"visibility":"internal"}],"id":505,"initialValue":{"arguments":[{"id":503,"name":"inputSize","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":490,"src":"7567:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_uint256","typeString":"uint256"}],"id":502,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"NewExpression","src":"7553:13:0","typeDescriptions":{"typeIdentifier":"t_function_objectcreation_pure$_t_uint256_$returns$_t_array$_t_uint256_$dyn_memory_ptr_$","typeString":"function (uint256) pure returns (uint256[] memory)"},"typeName":{"baseType":{"id":500,"name":"uint256","nodeType":"ElementaryTypeName","src":"7557:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":501,"nodeType":"ArrayTypeName","src":"7557:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_storage_ptr","typeString":"uint256[]"}}},"id":504,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"7553:24:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"nodeType":"VariableDeclarationStatement","src":"7528:49:0"},{"body":{"id":602,"nodeType":"Block","src":"7626:263:0","statements":[{"expression":{"id":527,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":516,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":499,"src":"7640:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":522,"indexExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":521,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":519,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":517,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7646:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"*","rightExpression":{"hexValue":"36","id":518,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7650:1:0","typeDescriptions":{"typeIdentifier":"t_rational_6_by_1","typeString":"int_const 6"},"value":"6"},"src":"7646:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"30","id":520,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7654:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"src":"7646:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"7640:16:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"expression":{"baseExpression":{"id":523,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":467,"src":"7659:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":525,"indexExpression":{"id":524,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7662:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7659:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":526,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"X","nodeType":"MemberAccess","referencedDeclaration":281,"src":"7659:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"7640:26:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":528,"nodeType":"ExpressionStatement","src":"7640:26:0"},{"expression":{"id":540,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":529,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":499,"src":"7680:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":535,"indexExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":534,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":532,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":530,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7686:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"*","rightExpression":{"hexValue":"36","id":531,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7690:1:0","typeDescriptions":{"typeIdentifier":"t_rational_6_by_1","typeString":"int_const 6"},"value":"6"},"src":"7686:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"31","id":533,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7694:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"src":"7686:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"7680:16:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"expression":{"baseExpression":{"id":536,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":467,"src":"7699:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":538,"indexExpression":{"id":537,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7702:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7699:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":539,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"Y","nodeType":"MemberAccess","referencedDeclaration":283,"src":"7699:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"7680:26:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":541,"nodeType":"ExpressionStatement","src":"7680:26:0"},{"expression":{"id":555,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":542,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":499,"src":"7720:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":548,"indexExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":547,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":545,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":543,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7726:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"*","rightExpression":{"hexValue":"36","id":544,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7730:1:0","typeDescriptions":{"typeIdentifier":"t_rational_6_by_1","typeString":"int_const 6"},"value":"6"},"src":"7726:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"32","id":546,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7734:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"src":"7726:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"7720:16:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"baseExpression":{"expression":{"baseExpression":{"id":549,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":470,"src":"7739:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":551,"indexExpression":{"id":550,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7742:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7739:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":552,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"X","nodeType":"MemberAccess","referencedDeclaration":288,"src":"7739:7:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":554,"indexExpression":{"hexValue":"30","id":553,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7747:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7739:10:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"7720:29:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":556,"nodeType":"ExpressionStatement","src":"7720:29:0"},{"expression":{"id":570,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":557,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":499,"src":"7763:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":563,"indexExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":562,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":560,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":558,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7769:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"*","rightExpression":{"hexValue":"36","id":559,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7773:1:0","typeDescriptions":{"typeIdentifier":"t_rational_6_by_1","typeString":"int_const 6"},"value":"6"},"src":"7769:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"33","id":561,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7777:1:0","typeDescriptions":{"typeIdentifier":"t_rational_3_by_1","typeString":"int_const 3"},"value":"3"},"src":"7769:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"7763:16:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"baseExpression":{"expression":{"baseExpression":{"id":564,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":470,"src":"7782:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":566,"indexExpression":{"id":565,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7785:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7782:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":567,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"X","nodeType":"MemberAccess","referencedDeclaration":288,"src":"7782:7:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":569,"indexExpression":{"hexValue":"31","id":568,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7790:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7782:10:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"7763:29:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":571,"nodeType":"ExpressionStatement","src":"7763:29:0"},{"expression":{"id":585,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":572,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":499,"src":"7806:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":578,"indexExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":577,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":575,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":573,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7812:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"*","rightExpression":{"hexValue":"36","id":574,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7816:1:0","typeDescriptions":{"typeIdentifier":"t_rational_6_by_1","typeString":"int_const 6"},"value":"6"},"src":"7812:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"34","id":576,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7820:1:0","typeDescriptions":{"typeIdentifier":"t_rational_4_by_1","typeString":"int_const 4"},"value":"4"},"src":"7812:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"7806:16:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"baseExpression":{"expression":{"baseExpression":{"id":579,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":470,"src":"7825:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":581,"indexExpression":{"id":580,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7828:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7825:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":582,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"Y","nodeType":"MemberAccess","referencedDeclaration":292,"src":"7825:7:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":584,"indexExpression":{"hexValue":"30","id":583,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7833:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7825:10:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"7806:29:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":586,"nodeType":"ExpressionStatement","src":"7806:29:0"},{"expression":{"id":600,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":587,"name":"input","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":499,"src":"7849:5:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$dyn_memory_ptr","typeString":"uint256[] memory"}},"id":593,"indexExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":592,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":590,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":588,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7855:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"*","rightExpression":{"hexValue":"36","id":589,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7859:1:0","typeDescriptions":{"typeIdentifier":"t_rational_6_by_1","typeString":"int_const 6"},"value":"6"},"src":"7855:5:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"+","rightExpression":{"hexValue":"35","id":591,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7863:1:0","typeDescriptions":{"typeIdentifier":"t_rational_5_by_1","typeString":"int_const 5"},"value":"5"},"src":"7855:9:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"7849:16:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"baseExpression":{"expression":{"baseExpression":{"id":594,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":470,"src":"7868:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":596,"indexExpression":{"id":595,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7871:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7868:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":597,"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"memberName":"Y","nodeType":"MemberAccess","referencedDeclaration":292,"src":"7868:7:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$2_memory_ptr","typeString":"uint256[2] memory"}},"id":599,"indexExpression":{"hexValue":"31","id":598,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7876:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"7868:10:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"7849:29:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":601,"nodeType":"ExpressionStatement","src":"7849:29:0"}]},"condition":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":512,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"id":510,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7607:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"<","rightExpression":{"id":511,"name":"elements","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":485,"src":"7611:8:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"src":"7607:12:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"id":603,"initializationExpression":{"assignments":[507],"declarations":[{"constant":false,"id":507,"mutability":"mutable","name":"i","nodeType":"VariableDeclaration","scope":603,"src":"7592:9:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"},"typeName":{"id":506,"name":"uint256","nodeType":"ElementaryTypeName","src":"7592:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"visibility":"internal"}],"id":509,"initialValue":{"hexValue":"30","id":508,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7604:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"nodeType":"VariableDeclarationStatement","src":"7592:13:0"},"loopExpression":{"expression":{"id":514,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"nodeType":"UnaryOperation","operator":"++","prefix":false,"src":"7621:3:0","subExpression":{"id":513,"name":"i","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":507,"src":"7621:1:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":515,"nodeType":"ExpressionStatement","src":"7621:3:0"},"nodeType":"ForStatement","src":"7587:302:0"},{"assignments":[609],"declarations":[{"constant":false,"id":609,"mutability":"mutable","name":"out","nodeType":"VariableDeclaration","scope":626,"src":"7898:21:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$1_memory_ptr","typeString":"uint256[1]"},"typeName":{"baseType":{"id":607,"name":"uint256","nodeType":"ElementaryTypeName","src":"7898:7:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"id":608,"length":{"hexValue":"31","id":606,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"7906:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"nodeType":"ArrayTypeName","src":"7898:10:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$1_storage_ptr","typeString":"uint256[1]"}},"visibility":"internal"}],"id":610,"nodeType":"VariableDeclarationStatement","src":"7898:21:0"},{"assignments":[612],"declarations":[{"constant":false,"id":612,"mutability":"mutable","name":"success","nodeType":"VariableDeclaration","scope":626,"src":"7929:12:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":611,"name":"bool","nodeType":"ElementaryTypeName","src":"7929:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"id":613,"nodeType":"VariableDeclarationStatement","src":"7929:12:0"},{"AST":{"nodeType":"YulBlock","src":"8024:384:0","statements":[{"nodeType":"YulAssignment","src":"8038:203:0","value":{"arguments":[{"arguments":[{"arguments":[],"functionName":{"name":"gas","nodeType":"YulIdentifier","src":"8081:3:0"},"nodeType":"YulFunctionCall","src":"8081:5:0"},{"kind":"number","nodeType":"YulLiteral","src":"8088:4:0","type":"","value":"2000"}],"functionName":{"name":"sub","nodeType":"YulIdentifier","src":"8077:3:0"},"nodeType":"YulFunctionCall","src":"8077:16:0"},{"kind":"number","nodeType":"YulLiteral","src":"8111:1:0","type":"","value":"8"},{"arguments":[{"name":"input","nodeType":"YulIdentifier","src":"8134:5:0"},{"kind":"number","nodeType":"YulLiteral","src":"8141:4:0","type":"","value":"0x20"}],"functionName":{"name":"add","nodeType":"YulIdentifier","src":"8130:3:0"},"nodeType":"YulFunctionCall","src":"8130:16:0"},{"arguments":[{"name":"inputSize","nodeType":"YulIdentifier","src":"8168:9:0"},{"kind":"number","nodeType":"YulLiteral","src":"8179:4:0","type":"","value":"0x20"}],"functionName":{"name":"mul","nodeType":"YulIdentifier","src":"8164:3:0"},"nodeType":"YulFunctionCall","src":"8164:20:0"},{"name":"out","nodeType":"YulIdentifier","src":"8202:3:0"},{"kind":"number","nodeType":"YulLiteral","src":"8223:4:0","type":"","value":"0x20"}],"functionName":{"name":"staticcall","nodeType":"YulIdentifier","src":"8049:10:0"},"nodeType":"YulFunctionCall","src":"8049:192:0"},"variableNames":[{"name":"success","nodeType":"YulIdentifier","src":"8038:7:0"}]},{"cases":[{"body":{"nodeType":"YulBlock","src":"8349:49:0","statements":[{"expression":{"arguments":[],"functionName":{"name":"invalid","nodeType":"YulIdentifier","src":"8371:7:0"},"nodeType":"YulFunctionCall","src":"8371:9:0"},"nodeType":"YulExpressionStatement","src":"8371:9:0"}]},"nodeType":"YulCase","src":"8342:56:0","value":{"kind":"number","nodeType":"YulLiteral","src":"8347:1:0","type":"","value":"0"}}],"expression":{"name":"success","nodeType":"YulIdentifier","src":"8318:7:0"},"nodeType":"YulSwitch","src":"8311:87:0"}]},"evmVersion":"istanbul","externalReferences":[{"declaration":499,"isOffset":false,"isSlot":false,"src":"8134:5:0","valueSize":1},{"declaration":490,"isOffset":false,"isSlot":false,"src":"8168:9:0","valueSize":1},{"declaration":609,"isOffset":false,"isSlot":false,"src":"8202:3:0","valueSize":1},{"declaration":612,"isOffset":false,"isSlot":false,"src":"8038:7:0","valueSize":1},{"declaration":612,"isOffset":false,"isSlot":false,"src":"8318:7:0","valueSize":1}],"id":614,"nodeType":"InlineAssembly","src":"8015:393:0"},{"expression":{"arguments":[{"id":616,"name":"success","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":612,"src":"8425:7:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},{"hexValue":"70616972696e672d6f70636f64652d6661696c6564","id":617,"isConstant":false,"isLValue":false,"isPure":true,"kind":"string","lValueRequested":false,"nodeType":"Literal","src":"8434:23:0","typeDescriptions":{"typeIdentifier":"t_stringliteral_f3220b3ef654fc0d9a13e2b6d8c956cb8fb22df61a3a050ded181d8902069fe5","typeString":"literal_string \"pairing-opcode-failed\""},"value":"pairing-opcode-failed"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_bool","typeString":"bool"},{"typeIdentifier":"t_stringliteral_f3220b3ef654fc0d9a13e2b6d8c956cb8fb22df61a3a050ded181d8902069fe5","typeString":"literal_string \"pairing-opcode-failed\""}],"id":615,"name":"require","nodeType":"Identifier","overloadedDeclarations":[-18,-18],"referencedDeclaration":-18,"src":"8417:7:0","typeDescriptions":{"typeIdentifier":"t_function_require_pure$_t_bool_$_t_string_memory_ptr_$returns$__$","typeString":"function (bool,string memory) pure"}},"id":618,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"8417:41:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_tuple$__$","typeString":"tuple()"}},"id":619,"nodeType":"ExpressionStatement","src":"8417:41:0"},{"expression":{"commonType":{"typeIdentifier":"t_uint256","typeString":"uint256"},"id":624,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftExpression":{"baseExpression":{"id":620,"name":"out","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":609,"src":"8475:3:0","typeDescriptions":{"typeIdentifier":"t_array$_t_uint256_$1_memory_ptr","typeString":"uint256[1] memory"}},"id":622,"indexExpression":{"hexValue":"30","id":621,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8479:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":false,"nodeType":"IndexAccess","src":"8475:6:0","typeDescriptions":{"typeIdentifier":"t_uint256","typeString":"uint256"}},"nodeType":"BinaryOperation","operator":"!=","rightExpression":{"hexValue":"30","id":623,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8485:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"src":"8475:11:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":474,"id":625,"nodeType":"Return","src":"8468:18:0"}]},"documentation":{"id":464,"nodeType":"StructuredDocumentation","src":"7049:201:0","text":"@return the result of computing the pairing check\n e(p1[0], p2[0]) * .... * e(p1[n], p2[n]) == 1\n For example pairing([P1(), P1().negate()], [P2(), P2()]) should\n return true."},"implemented":true,"kind":"function","modifiers":[],"name":"pairing","parameters":{"id":471,"nodeType":"ParameterList","parameters":[{"constant":false,"id":467,"mutability":"mutable","name":"p1","nodeType":"VariableDeclaration","scope":627,"src":"7272:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point[]"},"typeName":{"baseType":{"id":465,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"7272:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"id":466,"nodeType":"ArrayTypeName","src":"7272:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_storage_$dyn_storage_ptr","typeString":"struct Pairing.G1Point[]"}},"visibility":"internal"},{"constant":false,"id":470,"mutability":"mutable","name":"p2","nodeType":"VariableDeclaration","scope":627,"src":"7293:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point[]"},"typeName":{"baseType":{"id":468,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"7293:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"id":469,"nodeType":"ArrayTypeName","src":"7293:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_storage_$dyn_storage_ptr","typeString":"struct Pairing.G2Point[]"}},"visibility":"internal"}],"src":"7271:42:0"},"returnParameters":{"id":474,"nodeType":"ParameterList","parameters":[{"constant":false,"id":473,"mutability":"mutable","name":"","nodeType":"VariableDeclaration","scope":627,"src":"7361:4:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":472,"name":"bool","nodeType":"ElementaryTypeName","src":"7361:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"7360:6:0"},"scope":868,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":691,"nodeType":"FunctionDefinition","src":"8561:380:0","body":{"id":690,"nodeType":"Block","src":"8726:215:0","statements":[{"assignments":[644],"declarations":[{"constant":false,"id":644,"mutability":"mutable","name":"p1","nodeType":"VariableDeclaration","scope":690,"src":"8736:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point[]"},"typeName":{"baseType":{"id":642,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"8736:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"id":643,"nodeType":"ArrayTypeName","src":"8736:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_storage_$dyn_storage_ptr","typeString":"struct Pairing.G1Point[]"}},"visibility":"internal"}],"id":650,"initialValue":{"arguments":[{"hexValue":"32","id":648,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8772:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"}],"id":647,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"NewExpression","src":"8758:13:0","typeDescriptions":{"typeIdentifier":"t_function_objectcreation_pure$_t_uint256_$returns$_t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr_$","typeString":"function (uint256) pure returns (struct Pairing.G1Point memory[] memory)"},"typeName":{"baseType":{"id":645,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"8762:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"id":646,"nodeType":"ArrayTypeName","src":"8762:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_storage_$dyn_storage_ptr","typeString":"struct Pairing.G1Point[]"}}},"id":649,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"8758:16:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"nodeType":"VariableDeclarationStatement","src":"8736:38:0"},{"assignments":[654],"declarations":[{"constant":false,"id":654,"mutability":"mutable","name":"p2","nodeType":"VariableDeclaration","scope":690,"src":"8784:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point[]"},"typeName":{"baseType":{"id":652,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"8784:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"id":653,"nodeType":"ArrayTypeName","src":"8784:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_storage_$dyn_storage_ptr","typeString":"struct Pairing.G2Point[]"}},"visibility":"internal"}],"id":660,"initialValue":{"arguments":[{"hexValue":"32","id":658,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8820:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"}],"id":657,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"NewExpression","src":"8806:13:0","typeDescriptions":{"typeIdentifier":"t_function_objectcreation_pure$_t_uint256_$returns$_t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr_$","typeString":"function (uint256) pure returns (struct Pairing.G2Point memory[] memory)"},"typeName":{"baseType":{"id":655,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"8810:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"id":656,"nodeType":"ArrayTypeName","src":"8810:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_storage_$dyn_storage_ptr","typeString":"struct Pairing.G2Point[]"}}},"id":659,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"8806:16:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"nodeType":"VariableDeclarationStatement","src":"8784:38:0"},{"expression":{"id":665,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":661,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":644,"src":"8832:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":663,"indexExpression":{"hexValue":"30","id":662,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8835:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"8832:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":664,"name":"a1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":630,"src":"8840:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"8832:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":666,"nodeType":"ExpressionStatement","src":"8832:10:0"},{"expression":{"id":671,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":667,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":644,"src":"8852:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":669,"indexExpression":{"hexValue":"31","id":668,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8855:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"8852:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":670,"name":"b1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":634,"src":"8860:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"8852:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":672,"nodeType":"ExpressionStatement","src":"8852:10:0"},{"expression":{"id":677,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":673,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":654,"src":"8872:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":675,"indexExpression":{"hexValue":"30","id":674,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8875:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"8872:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":676,"name":"a2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":632,"src":"8880:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"8872:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":678,"nodeType":"ExpressionStatement","src":"8872:10:0"},{"expression":{"id":683,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":679,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":654,"src":"8892:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":681,"indexExpression":{"hexValue":"31","id":680,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"8895:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"8892:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":682,"name":"b2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":636,"src":"8900:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"8892:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":684,"nodeType":"ExpressionStatement","src":"8892:10:0"},{"expression":{"arguments":[{"id":686,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":644,"src":"8927:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},{"id":687,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":654,"src":"8931:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"},{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}],"id":685,"name":"pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":627,"src":"8919:7:0","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr_$_t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr_$returns$_t_bool_$","typeString":"function (struct Pairing.G1Point memory[] memory,struct Pairing.G2Point memory[] memory) view returns (bool)"}},"id":688,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"8919:15:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":640,"id":689,"nodeType":"Return","src":"8912:22:0"}]},"documentation":{"id":628,"nodeType":"StructuredDocumentation","src":"8499:57:0","text":"Convenience method for a pairing check for two pairs."},"implemented":true,"kind":"function","modifiers":[],"name":"pairingProd2","parameters":{"id":637,"nodeType":"ParameterList","parameters":[{"constant":false,"id":630,"mutability":"mutable","name":"a1","nodeType":"VariableDeclaration","scope":691,"src":"8592:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":629,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"8592:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":632,"mutability":"mutable","name":"a2","nodeType":"VariableDeclaration","scope":691,"src":"8619:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":631,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"8619:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":634,"mutability":"mutable","name":"b1","nodeType":"VariableDeclaration","scope":691,"src":"8646:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":633,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"8646:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":636,"mutability":"mutable","name":"b2","nodeType":"VariableDeclaration","scope":691,"src":"8673:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":635,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"8673:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"}],"src":"8582:114:0"},"returnParameters":{"id":640,"nodeType":"ParameterList","parameters":[{"constant":false,"id":639,"mutability":"mutable","name":"","nodeType":"VariableDeclaration","scope":691,"src":"8720:4:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":638,"name":"bool","nodeType":"ElementaryTypeName","src":"8720:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"8719:6:0"},"scope":868,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":771,"nodeType":"FunctionDefinition","src":"9011:474:0","body":{"id":770,"nodeType":"Block","src":"9230:255:0","statements":[{"assignments":[712],"declarations":[{"constant":false,"id":712,"mutability":"mutable","name":"p1","nodeType":"VariableDeclaration","scope":770,"src":"9240:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point[]"},"typeName":{"baseType":{"id":710,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9240:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"id":711,"nodeType":"ArrayTypeName","src":"9240:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_storage_$dyn_storage_ptr","typeString":"struct Pairing.G1Point[]"}},"visibility":"internal"}],"id":718,"initialValue":{"arguments":[{"hexValue":"33","id":716,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9276:1:0","typeDescriptions":{"typeIdentifier":"t_rational_3_by_1","typeString":"int_const 3"},"value":"3"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_3_by_1","typeString":"int_const 3"}],"id":715,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"NewExpression","src":"9262:13:0","typeDescriptions":{"typeIdentifier":"t_function_objectcreation_pure$_t_uint256_$returns$_t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr_$","typeString":"function (uint256) pure returns (struct Pairing.G1Point memory[] memory)"},"typeName":{"baseType":{"id":713,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9266:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"id":714,"nodeType":"ArrayTypeName","src":"9266:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_storage_$dyn_storage_ptr","typeString":"struct Pairing.G1Point[]"}}},"id":717,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"9262:16:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"nodeType":"VariableDeclarationStatement","src":"9240:38:0"},{"assignments":[722],"declarations":[{"constant":false,"id":722,"mutability":"mutable","name":"p2","nodeType":"VariableDeclaration","scope":770,"src":"9288:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point[]"},"typeName":{"baseType":{"id":720,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9288:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"id":721,"nodeType":"ArrayTypeName","src":"9288:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_storage_$dyn_storage_ptr","typeString":"struct Pairing.G2Point[]"}},"visibility":"internal"}],"id":728,"initialValue":{"arguments":[{"hexValue":"33","id":726,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9324:1:0","typeDescriptions":{"typeIdentifier":"t_rational_3_by_1","typeString":"int_const 3"},"value":"3"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_3_by_1","typeString":"int_const 3"}],"id":725,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"NewExpression","src":"9310:13:0","typeDescriptions":{"typeIdentifier":"t_function_objectcreation_pure$_t_uint256_$returns$_t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr_$","typeString":"function (uint256) pure returns (struct Pairing.G2Point memory[] memory)"},"typeName":{"baseType":{"id":723,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9314:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"id":724,"nodeType":"ArrayTypeName","src":"9314:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_storage_$dyn_storage_ptr","typeString":"struct Pairing.G2Point[]"}}},"id":727,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"9310:16:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"nodeType":"VariableDeclarationStatement","src":"9288:38:0"},{"expression":{"id":733,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":729,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":712,"src":"9336:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":731,"indexExpression":{"hexValue":"30","id":730,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9339:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9336:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":732,"name":"a1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":694,"src":"9344:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"9336:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":734,"nodeType":"ExpressionStatement","src":"9336:10:0"},{"expression":{"id":739,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":735,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":712,"src":"9356:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":737,"indexExpression":{"hexValue":"31","id":736,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9359:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9356:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":738,"name":"b1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":698,"src":"9364:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"9356:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":740,"nodeType":"ExpressionStatement","src":"9356:10:0"},{"expression":{"id":745,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":741,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":712,"src":"9376:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":743,"indexExpression":{"hexValue":"32","id":742,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9379:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9376:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":744,"name":"c1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":702,"src":"9384:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"9376:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":746,"nodeType":"ExpressionStatement","src":"9376:10:0"},{"expression":{"id":751,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":747,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":722,"src":"9396:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":749,"indexExpression":{"hexValue":"30","id":748,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9399:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9396:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":750,"name":"a2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":696,"src":"9404:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"9396:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":752,"nodeType":"ExpressionStatement","src":"9396:10:0"},{"expression":{"id":757,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":753,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":722,"src":"9416:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":755,"indexExpression":{"hexValue":"31","id":754,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9419:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9416:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":756,"name":"b2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":700,"src":"9424:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"9416:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":758,"nodeType":"ExpressionStatement","src":"9416:10:0"},{"expression":{"id":763,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":759,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":722,"src":"9436:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":761,"indexExpression":{"hexValue":"32","id":760,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9439:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9436:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":762,"name":"c2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":704,"src":"9444:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"9436:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":764,"nodeType":"ExpressionStatement","src":"9436:10:0"},{"expression":{"arguments":[{"id":766,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":712,"src":"9471:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},{"id":767,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":722,"src":"9475:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"},{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}],"id":765,"name":"pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":627,"src":"9463:7:0","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr_$_t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr_$returns$_t_bool_$","typeString":"function (struct Pairing.G1Point memory[] memory,struct Pairing.G2Point memory[] memory) view returns (bool)"}},"id":768,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"9463:15:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":708,"id":769,"nodeType":"Return","src":"9456:22:0"}]},"documentation":{"id":692,"nodeType":"StructuredDocumentation","src":"8947:59:0","text":"Convenience method for a pairing check for three pairs."},"implemented":true,"kind":"function","modifiers":[],"name":"pairingProd3","parameters":{"id":705,"nodeType":"ParameterList","parameters":[{"constant":false,"id":694,"mutability":"mutable","name":"a1","nodeType":"VariableDeclaration","scope":771,"src":"9042:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":693,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9042:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":696,"mutability":"mutable","name":"a2","nodeType":"VariableDeclaration","scope":771,"src":"9069:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":695,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9069:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":698,"mutability":"mutable","name":"b1","nodeType":"VariableDeclaration","scope":771,"src":"9096:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":697,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9096:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":700,"mutability":"mutable","name":"b2","nodeType":"VariableDeclaration","scope":771,"src":"9123:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":699,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9123:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":702,"mutability":"mutable","name":"c1","nodeType":"VariableDeclaration","scope":771,"src":"9150:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":701,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9150:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":704,"mutability":"mutable","name":"c2","nodeType":"VariableDeclaration","scope":771,"src":"9177:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":703,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9177:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"}],"src":"9032:168:0"},"returnParameters":{"id":708,"nodeType":"ParameterList","parameters":[{"constant":false,"id":707,"mutability":"mutable","name":"","nodeType":"VariableDeclaration","scope":771,"src":"9224:4:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":706,"name":"bool","nodeType":"ElementaryTypeName","src":"9224:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"9223:6:0"},"scope":868,"stateMutability":"view","virtual":false,"visibility":"internal"},{"id":867,"nodeType":"FunctionDefinition","src":"9554:568:0","body":{"id":866,"nodeType":"Block","src":"9827:295:0","statements":[{"assignments":[796],"declarations":[{"constant":false,"id":796,"mutability":"mutable","name":"p1","nodeType":"VariableDeclaration","scope":866,"src":"9837:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point[]"},"typeName":{"baseType":{"id":794,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9837:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"id":795,"nodeType":"ArrayTypeName","src":"9837:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_storage_$dyn_storage_ptr","typeString":"struct Pairing.G1Point[]"}},"visibility":"internal"}],"id":802,"initialValue":{"arguments":[{"hexValue":"34","id":800,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9873:1:0","typeDescriptions":{"typeIdentifier":"t_rational_4_by_1","typeString":"int_const 4"},"value":"4"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_4_by_1","typeString":"int_const 4"}],"id":799,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"NewExpression","src":"9859:13:0","typeDescriptions":{"typeIdentifier":"t_function_objectcreation_pure$_t_uint256_$returns$_t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr_$","typeString":"function (uint256) pure returns (struct Pairing.G1Point memory[] memory)"},"typeName":{"baseType":{"id":797,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9863:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"id":798,"nodeType":"ArrayTypeName","src":"9863:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_storage_$dyn_storage_ptr","typeString":"struct Pairing.G1Point[]"}}},"id":801,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"9859:16:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"nodeType":"VariableDeclarationStatement","src":"9837:38:0"},{"assignments":[806],"declarations":[{"constant":false,"id":806,"mutability":"mutable","name":"p2","nodeType":"VariableDeclaration","scope":866,"src":"9885:19:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point[]"},"typeName":{"baseType":{"id":804,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9885:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"id":805,"nodeType":"ArrayTypeName","src":"9885:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_storage_$dyn_storage_ptr","typeString":"struct Pairing.G2Point[]"}},"visibility":"internal"}],"id":812,"initialValue":{"arguments":[{"hexValue":"34","id":810,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9921:1:0","typeDescriptions":{"typeIdentifier":"t_rational_4_by_1","typeString":"int_const 4"},"value":"4"}],"expression":{"argumentTypes":[{"typeIdentifier":"t_rational_4_by_1","typeString":"int_const 4"}],"id":809,"isConstant":false,"isLValue":false,"isPure":true,"lValueRequested":false,"nodeType":"NewExpression","src":"9907:13:0","typeDescriptions":{"typeIdentifier":"t_function_objectcreation_pure$_t_uint256_$returns$_t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr_$","typeString":"function (uint256) pure returns (struct Pairing.G2Point memory[] memory)"},"typeName":{"baseType":{"id":807,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9911:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"id":808,"nodeType":"ArrayTypeName","src":"9911:9:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_storage_$dyn_storage_ptr","typeString":"struct Pairing.G2Point[]"}}},"id":811,"isConstant":false,"isLValue":false,"isPure":true,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"9907:16:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"nodeType":"VariableDeclarationStatement","src":"9885:38:0"},{"expression":{"id":817,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":813,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":796,"src":"9933:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":815,"indexExpression":{"hexValue":"30","id":814,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9936:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9933:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":816,"name":"a1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":774,"src":"9941:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"9933:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":818,"nodeType":"ExpressionStatement","src":"9933:10:0"},{"expression":{"id":823,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":819,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":796,"src":"9953:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":821,"indexExpression":{"hexValue":"31","id":820,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9956:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9953:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":822,"name":"b1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":778,"src":"9961:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"9953:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":824,"nodeType":"ExpressionStatement","src":"9953:10:0"},{"expression":{"id":829,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":825,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":796,"src":"9973:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":827,"indexExpression":{"hexValue":"32","id":826,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9976:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9973:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":828,"name":"c1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":782,"src":"9981:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"9973:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":830,"nodeType":"ExpressionStatement","src":"9973:10:0"},{"expression":{"id":835,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":831,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":796,"src":"9993:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},"id":833,"indexExpression":{"hexValue":"33","id":832,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"9996:1:0","typeDescriptions":{"typeIdentifier":"t_rational_3_by_1","typeString":"int_const 3"},"value":"3"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"9993:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":834,"name":"d1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":786,"src":"10001:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"src":"9993:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point memory"}},"id":836,"nodeType":"ExpressionStatement","src":"9993:10:0"},{"expression":{"id":841,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":837,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":806,"src":"10013:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":839,"indexExpression":{"hexValue":"30","id":838,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10016:1:0","typeDescriptions":{"typeIdentifier":"t_rational_0_by_1","typeString":"int_const 0"},"value":"0"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"10013:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":840,"name":"a2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":776,"src":"10021:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"10013:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":842,"nodeType":"ExpressionStatement","src":"10013:10:0"},{"expression":{"id":847,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":843,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":806,"src":"10033:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":845,"indexExpression":{"hexValue":"31","id":844,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10036:1:0","typeDescriptions":{"typeIdentifier":"t_rational_1_by_1","typeString":"int_const 1"},"value":"1"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"10033:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":846,"name":"b2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":780,"src":"10041:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"10033:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":848,"nodeType":"ExpressionStatement","src":"10033:10:0"},{"expression":{"id":853,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":849,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":806,"src":"10053:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":851,"indexExpression":{"hexValue":"32","id":850,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10056:1:0","typeDescriptions":{"typeIdentifier":"t_rational_2_by_1","typeString":"int_const 2"},"value":"2"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"10053:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":852,"name":"c2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":784,"src":"10061:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"10053:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":854,"nodeType":"ExpressionStatement","src":"10053:10:0"},{"expression":{"id":859,"isConstant":false,"isLValue":false,"isPure":false,"lValueRequested":false,"leftHandSide":{"baseExpression":{"id":855,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":806,"src":"10073:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}},"id":857,"indexExpression":{"hexValue":"33","id":856,"isConstant":false,"isLValue":false,"isPure":true,"kind":"number","lValueRequested":false,"nodeType":"Literal","src":"10076:1:0","typeDescriptions":{"typeIdentifier":"t_rational_3_by_1","typeString":"int_const 3"},"value":"3"},"isConstant":false,"isLValue":true,"isPure":false,"lValueRequested":true,"nodeType":"IndexAccess","src":"10073:5:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"nodeType":"Assignment","operator":"=","rightHandSide":{"id":858,"name":"d2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":788,"src":"10081:2:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"src":"10073:10:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point memory"}},"id":860,"nodeType":"ExpressionStatement","src":"10073:10:0"},{"expression":{"arguments":[{"id":862,"name":"p1","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":796,"src":"10108:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"}},{"id":863,"name":"p2","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":806,"src":"10112:2:0","typeDescriptions":{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}}],"expression":{"argumentTypes":[{"typeIdentifier":"t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G1Point memory[] memory"},{"typeIdentifier":"t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr","typeString":"struct Pairing.G2Point memory[] memory"}],"id":861,"name":"pairing","nodeType":"Identifier","overloadedDeclarations":[],"referencedDeclaration":627,"src":"10100:7:0","typeDescriptions":{"typeIdentifier":"t_function_internal_view$_t_array$_t_struct$_G1Point_$284_memory_ptr_$dyn_memory_ptr_$_t_array$_t_struct$_G2Point_$293_memory_ptr_$dyn_memory_ptr_$returns$_t_bool_$","typeString":"function (struct Pairing.G1Point memory[] memory,struct Pairing.G2Point memory[] memory) view returns (bool)"}},"id":864,"isConstant":false,"isLValue":false,"isPure":false,"kind":"functionCall","lValueRequested":false,"names":[],"nodeType":"FunctionCall","src":"10100:15:0","tryCall":false,"typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"functionReturnParameters":792,"id":865,"nodeType":"Return","src":"10093:22:0"}]},"documentation":{"id":772,"nodeType":"StructuredDocumentation","src":"9491:58:0","text":"Convenience method for a pairing check for four pairs."},"implemented":true,"kind":"function","modifiers":[],"name":"pairingProd4","parameters":{"id":789,"nodeType":"ParameterList","parameters":[{"constant":false,"id":774,"mutability":"mutable","name":"a1","nodeType":"VariableDeclaration","scope":867,"src":"9585:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":773,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9585:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":776,"mutability":"mutable","name":"a2","nodeType":"VariableDeclaration","scope":867,"src":"9612:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":775,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9612:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":778,"mutability":"mutable","name":"b1","nodeType":"VariableDeclaration","scope":867,"src":"9639:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":777,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9639:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":780,"mutability":"mutable","name":"b2","nodeType":"VariableDeclaration","scope":867,"src":"9666:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":779,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9666:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":782,"mutability":"mutable","name":"c1","nodeType":"VariableDeclaration","scope":867,"src":"9693:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":781,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9693:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":784,"mutability":"mutable","name":"c2","nodeType":"VariableDeclaration","scope":867,"src":"9720:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":783,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9720:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"},{"constant":false,"id":786,"mutability":"mutable","name":"d1","nodeType":"VariableDeclaration","scope":867,"src":"9747:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_memory_ptr","typeString":"struct Pairing.G1Point"},"typeName":{"id":785,"name":"G1Point","nodeType":"UserDefinedTypeName","referencedDeclaration":284,"src":"9747:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G1Point_$284_storage_ptr","typeString":"struct Pairing.G1Point"}},"visibility":"internal"},{"constant":false,"id":788,"mutability":"mutable","name":"d2","nodeType":"VariableDeclaration","scope":867,"src":"9774:17:0","stateVariable":false,"storageLocation":"memory","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_memory_ptr","typeString":"struct Pairing.G2Point"},"typeName":{"id":787,"name":"G2Point","nodeType":"UserDefinedTypeName","referencedDeclaration":293,"src":"9774:7:0","typeDescriptions":{"typeIdentifier":"t_struct$_G2Point_$293_storage_ptr","typeString":"struct Pairing.G2Point"}},"visibility":"internal"}],"src":"9575:222:0"},"returnParameters":{"id":792,"nodeType":"ParameterList","parameters":[{"constant":false,"id":791,"mutability":"mutable","name":"","nodeType":"VariableDeclaration","scope":867,"src":"9821:4:0","stateVariable":false,"storageLocation":"default","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"},"typeName":{"id":790,"name":"bool","nodeType":"ElementaryTypeName","src":"9821:4:0","typeDescriptions":{"typeIdentifier":"t_bool","typeString":"bool"}},"visibility":"internal"}],"src":"9820:6:0"},"scope":868,"stateMutability":"view","virtual":false,"visibility":"internal"}],"abstract":false,"baseContracts":[],"contractDependencies":[],"contractKind":"library","fullyImplemented":true,"linearizedBaseContracts":[868],"name":"Pairing","scope":869}]},"id":0} diff --git a/app/ark-circom-passport/rust-toolchain.toml b/app/ark-circom-passport/rust-toolchain.toml deleted file mode 100644 index 74cb24ad9..000000000 --- a/app/ark-circom-passport/rust-toolchain.toml +++ /dev/null @@ -1,3 +0,0 @@ -[toolchain] -channel = "stable" -version = "1.67.0" \ No newline at end of file diff --git a/app/ark-circom-passport/src/passport.rs b/app/ark-circom-passport/src/passport.rs deleted file mode 100644 index f8f828b55..000000000 --- a/app/ark-circom-passport/src/passport.rs +++ /dev/null @@ -1,588 +0,0 @@ -use ark_circom::{ethereum, CircomBuilder, CircomConfig, circom::CircomReduction, WitnessCalculator}; -use ark_std::rand::thread_rng; -use color_eyre::Result; - -use ark_bn254::Bn254; -use ark_crypto_primitives::snark::SNARK; -use ark_groth16::{Groth16, Proof}; -use ark_ec::AffineRepr; -use ark_ff::UniformRand; -use ark_groth16::{ProvingKey}; -use ark_relations::r1cs::ConstraintMatrices; -use ark_bn254::{Fr}; - -use num_bigint::{BigInt, Sign, ToBigInt}; -extern crate hex; -use hex::decode; - -type GrothBn = Groth16; - -extern crate jni; -use jni::objects::{JClass, JObject, JValue, JString}; -use jni::JNIEnv; -use jni::sys::jstring; - -use log::Level; -use android_logger::Config; - -extern crate serde; -extern crate serde_json; -use serde_json::json; -#[macro_use] -extern crate serde_derive; - -use std::{ - collections::HashMap, - time::Instant, - convert::TryInto, - sync::Mutex, - {os::raw::c_int, io::BufReader}, - fs::File, - path::Path -}; - -use wasmer::{Module, Store}; -use once_cell::sync::{Lazy, OnceCell}; - -mod zkey; -pub use zkey::{read_zkey, read_zkey_from_include_bytes}; - -use ark_zkey::{read_arkzkey, read_arkzkey_from_bytes}; - -#[no_mangle] -pub extern "C" fn Java_io_tradle_nfc_RNPassportReaderModule_callRustCode( - env: JNIEnv, - _: JClass, -) -> jstring { - android_logger::init_once(Config::default().with_min_level(Level::Trace)); - log::error!("PROOF OF PASSPORT ---- log before imports"); - - let my_int: c_int = -1; - let my_str: String = "no_proof".to_string(); - - let combined = json!({ - "my_int": my_int, - "my_str": my_str - }); - - let combined_str = combined.to_string(); - let output = env.new_string(combined_str).expect("Couldn't create java string!"); - - output.into_inner() -} - -const WASM: &[u8] = include_bytes!("../passport/proof_of_passport.wasm"); - -static WITNESS_CALCULATOR: OnceCell> = OnceCell::new(); - -#[cfg(not(feature = "dylib"))] -#[must_use] -pub fn witness_calculator() -> &'static Mutex { - WITNESS_CALCULATOR.get_or_init(|| { - let store = Store::default(); - let module = Module::from_binary(&store, WASM).expect("WASM should be valid"); - let result = - WitnessCalculator::from_module(module).expect("Failed to create WitnessCalculator"); - Mutex::new(result) - }) -} - -fn load_arkzkey_from_file(zkey_path: &Path) -> Result<(ProvingKey, ConstraintMatrices), Box> { - let file = File::open(zkey_path)?; - let mut reader = BufReader::new(file); - let (proving_key, matrices) = read_zkey(&mut reader)?; - Ok((proving_key, matrices)) -} - -#[no_mangle] -pub extern "C" fn Java_io_tradle_nfc_RNPassportReaderModule_provePassport( - env: JNIEnv, - _: JClass, - mrz: JObject, - reveal_bitmap: JObject, - data_hashes: JObject, - datahashes_padded_length: JString, - e_content_bytes: JObject, - signature: JObject, - signature_algorithm: JString, - pubkey: JObject, - path_indices: JObject, - siblings: JObject, - root: JString, - address: JString, - zkeypath: JString, -) -> jstring { - log::error!("PROOF OF PASSPORT ---- formatting inputs..."); - - fn run_proof( - mrz: JObject, - reveal_bitmap: JObject, - data_hashes: JObject, - datahashes_padded_length: JString, - e_content_bytes: JObject, - signature: JObject, - signature_algorithm: JString, - pubkey: JObject, - path_indices: JObject, - siblings: JObject, - root: JString, - address: JString, - zkeypath: JString, - env: JNIEnv - ) -> Result> { - let start = Instant::now(); - android_logger::init_once(Config::default().with_min_level(Level::Trace)); - let mut rng = thread_rng(); - let rng = &mut rng; - let r = ark_bn254::Fr::rand(rng); - let s = ark_bn254::Fr::rand(rng); - - log::error!("PROOF OF PASSPORT ---- formatting inputs..."); - let mut inputs: HashMap> = HashMap::new(); - let mrz_vec: Vec = java_arraylist_to_rust_vec(&env, mrz)?; - let reveal_bitmap_vec: Vec = java_arraylist_to_rust_vec(&env, reveal_bitmap)?; - let data_hashes_vec: Vec = java_arraylist_to_rust_vec(&env, data_hashes)?; - let e_content_bytes_vec: Vec = java_arraylist_to_rust_vec(&env, e_content_bytes)?; - let signature_vec: Vec = java_arraylist_to_rust_vec(&env, signature)?; - let pubkey_vec: Vec = java_arraylist_to_rust_vec(&env, pubkey)?; - let path_indices_vec: Vec = java_arraylist_to_rust_vec(&env, path_indices)?; - let siblings_vec: Vec = java_arraylist_to_rust_vec(&env, siblings)?; - - let signature_algorithm_str: String = env.get_string(signature_algorithm)?.into(); - let root_str: String = env.get_string(root)?.into(); - let address_str: String = env.get_string(address)?.into(); - let datahashes_padded_length_str: String = env.get_string(datahashes_padded_length)?.into(); - - log::error!("PROOF OF PASSPORT ---- mrz_vec {:?}", mrz_vec); - log::error!("PROOF OF PASSPORT ---- reveal_bitmap_vec {:?}", reveal_bitmap_vec); - log::error!("PROOF OF PASSPORT ---- data_hashes_vec {:?}", data_hashes_vec); - log::error!("PROOF OF PASSPORT ---- e_content_bytes_vec {:?}", e_content_bytes_vec); - log::error!("PROOF OF PASSPORT ---- signature_vec {:?}", signature_vec); - log::error!("PROOF OF PASSPORT ---- signature_algorithm_str {:?}", signature_algorithm_str); - log::error!("PROOF OF PASSPORT ---- pubkey_vec {:?}", pubkey_vec); - log::error!("PROOF OF PASSPORT ---- path_indices_vec {:?}", path_indices_vec); - log::error!("PROOF OF PASSPORT ---- siblings_vec {:?}", siblings_vec); - log::error!("PROOF OF PASSPORT ---- root_str {:?}", root_str); - log::error!("PROOF OF PASSPORT ---- address_str {:?}", address_str); - log::error!("PROOF OF PASSPORT ---- datahashes_padded_length_str {:?}", datahashes_padded_length_str); - - fn parse_and_insert(hash_map: &mut HashMap>, key: &str, data: Vec<&str>) { - let parsed_data: Vec = data.into_iter() - .filter_map(|s| s.parse::().ok().and_then(|num| num.to_bigint())) - .collect(); - hash_map.insert(key.to_string(), parsed_data); - } - - parse_and_insert(&mut inputs, "mrz", mrz_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "reveal_bitmap", reveal_bitmap_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "dataHashes", data_hashes_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "eContentBytes", e_content_bytes_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "signature", signature_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "pubkey", pubkey_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "pathIndices", path_indices_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "siblings", siblings_vec.iter().map(AsRef::as_ref).collect()); - - let address_bigint = BigInt::from_bytes_be(Sign::Plus, &decode(&address_str[2..])?); - inputs.insert("address".to_string(), vec![address_bigint]); - - let datahashes_padded_length_i32 = datahashes_padded_length_str.parse::().expect("Failed to parse datahashes_padded_length to i32"); - let datahashes_padded_length_bigint = BigInt::from(datahashes_padded_length_i32); - inputs.insert("datahashes_padded_length".to_string(), vec![datahashes_padded_length_bigint]); - - let signature_algorithm_i32 = signature_algorithm_str.parse::().expect("Failed to parse signature_algorithm_str to i32"); - let signature_algorithm_bigint = BigInt::from(signature_algorithm_i32); - inputs.insert("signature_algorithm".to_string(), vec![signature_algorithm_bigint]); - let root_bigint = BigInt::parse_bytes(root_str.as_bytes(), 10).unwrap(); - inputs.insert("root".to_string(), vec![root_bigint]); - - println!("generating witness..."); - let now = Instant::now(); - let full_assignment = witness_calculator() - .lock() - .expect("Failed to lock witness calculator") - .calculate_witness_element::(inputs, false) - .map_err(|e| e.to_string())?; - - log::error!("PROOF OF PASSPORT ---- Witness generation took. Took: {:?}", now.elapsed()); - - log::error!("PROOF OF PASSPORT ---- loading zkey..."); - let now = Instant::now(); - let zkey_path_jstring = env.get_string(zkeypath).expect("Couldn't get zkey path string"); - let zkey_path_str = zkey_path_jstring.to_str().unwrap(); - - // To load classic zkey - // let file = std::fs::File::open(zkey_path_str).expect("Failed to open zkey file"); - // let zkey = read_zkey(&mut BufReader::new(file)).expect("Failed to read zkey from file"); - - // Loading arkzkey - let (serialized_proving_key, serialized_constraint_matrices) = read_arkzkey(zkey_path_str).expect("Failed to read zkey from file"); - // Formatting for ark-circom API here as it's not done in mopro rn - let proving_key: ProvingKey = serialized_proving_key.0; - let constraint_matrices: ConstraintMatrices = ConstraintMatrices { - num_instance_variables: serialized_constraint_matrices.num_instance_variables, - num_witness_variables: serialized_constraint_matrices.num_witness_variables, - num_constraints: serialized_constraint_matrices.num_constraints, - a_num_non_zero: serialized_constraint_matrices.a_num_non_zero, - b_num_non_zero: serialized_constraint_matrices.b_num_non_zero, - c_num_non_zero: serialized_constraint_matrices.c_num_non_zero, - a: serialized_constraint_matrices.a.data, - b: serialized_constraint_matrices.b.data, - c: serialized_constraint_matrices.c.data, - }; - let zkey = (proving_key, constraint_matrices); - - log::error!("PROOF OF PASSPORT ---- zkey loaded from path. Took: {:?}", now.elapsed()); - println!("Loading arkzkey took: {:.2?}", now.elapsed()); - let now = Instant::now(); - - let public_inputs = full_assignment.as_slice()[1..zkey.1.num_instance_variables].to_vec(); - let ark_proof = Groth16::<_, CircomReduction>::create_proof_with_reduction_and_matrices( - &zkey.0, - r, - s, - &zkey.1, - zkey.1.num_instance_variables, - zkey.1.num_constraints, - full_assignment.as_slice(), - ); - - let proof = ark_proof.map_err(|e| e.to_string())?; - - log::error!("PROOF OF PASSPORT ---- proof: {:?}", proof); - log::error!("PROOF OF PASSPORT ---- proof done. Took: {:?}", now.elapsed()); - let now = Instant::now(); - - println!("proof generation took: {:.2?}", now.elapsed()); - - println!("proof {:?}", proof); - println!("public_inputs {:?}", public_inputs); - - // previous way of verifying proof - // let pvk = Groth16::::process_vk(¶ms.vk).unwrap(); - // let verified = Groth16::::verify_with_processed_vk(&pvk, &inputs, &proof).unwrap(); - // println!("Proof verified. Took: {:?}", now.elapsed()); - // log::error!("PROOF OF PASSPORT ---- proof verified. Took: {:?}", now.elapsed()); - // assert!(verified); - - log::error!("PROOF OF PASSPORT ---- public_inputs: {:?}", public_inputs); - - let converted_inputs: ethereum::Inputs = public_inputs.as_slice().into(); - let inputs_str: Vec = converted_inputs.0.iter().map(|value| format!("{}", value)).collect(); - let serialized_inputs = serde_json::to_string(&inputs_str).unwrap(); - log::error!("PROOF OF PASSPORT ---- Serialized inputs: {:?}", serialized_inputs); - - let proof_str = proof_to_proof_str(&proof); - let serialized_proof = serde_json::to_string(&proof_str).unwrap(); - - log::error!("PROOF OF PASSPORT ---- Serialized proof: {:?}", serialized_proof); - - let combined = json!({ - "duration": start.elapsed().as_millis(), - "serialized_proof": serialized_proof, - "serialized_inputs": serialized_inputs - }); - - let combined_str = combined.to_string(); - let output = env.new_string(combined_str).expect("Couldn't create java string!"); - - Ok(output.into_inner()) - } - - match run_proof( - mrz, - reveal_bitmap, - data_hashes, - datahashes_padded_length, - e_content_bytes, - signature, - signature_algorithm, - pubkey, - path_indices, - siblings, - root, - address, - zkeypath, - env - ) { - Ok(output) => output, - Err(_) => env.new_string("error").expect("Couldn't create java string!").into_inner(), - } -} - -fn java_arraylist_to_rust_vec(env: &JNIEnv, java_list: JObject) -> Result, jni::errors::Error> { - let size = env.call_method(java_list, "size", "()I", &[])?.i()? as i32; - let mut vec = Vec::with_capacity(size.try_into().unwrap()); - - for i in 0..size { - let java_string = env.call_method(java_list, "get", "(I)Ljava/lang/Object;", &[JValue::from(i)])?.l()?; - let rust_string: String = env.get_string(java_string.into())?.into(); - vec.push(rust_string); - } - - Ok(vec) -} - -#[derive(Debug)] -#[derive(Serialize)] -struct ProofStr { - a: (String, String), - b: ((String, String), (String, String)), - c: (String, String), -} - -fn proof_to_proof_str(proof: &Proof) -> ProofStr { - let a_xy = proof.a.xy().unwrap(); - let b_xy = proof.b.xy().unwrap(); - let c_xy = proof.c.xy().unwrap(); - - let b_c0_c0 = b_xy.0.c0.to_string(); - let b_c0_c1 = b_xy.0.c1.to_string(); - let b_c1_c0 = b_xy.1.c0.to_string(); - let b_c1_c1 = b_xy.1.c1.to_string(); - - ProofStr { - a: (a_xy.0.to_string(), a_xy.1.to_string()), - b: ((b_c0_c0, b_c0_c1), (b_c1_c0, b_c1_c1)), - c: (c_xy.0.to_string(), c_xy.1.to_string()), - } -} - -#[cfg(test)] -mod tests { - use super::*; - - use ethers::{ - contract::ContractError, - prelude::abigen, - providers::{Http, Middleware, Provider}, - utils::Anvil, - }; - use std::{ - error::Error, - fs::File, - sync::{Arc, Mutex}, - collections::HashMap - }; - use wasmer::{Module, Store}; - - use ark_circom::{ - circom::CircomReduction, - WitnessCalculator - }; - use once_cell::sync::{Lazy, OnceCell}; - use ark_groth16::{Groth16, ProvingKey}; - use ark_relations::r1cs::ConstraintMatrices; - use ark_ff::UniformRand; - use ark_bn254::{Bn254, Fq, Fq2, Fr, G1Affine, G2Affine}; - use num_bigint::ToBigInt; - use ark_zkey::read_arkzkey_from_bytes; //SerializableConstraintMatrices - - - // We need to implement the conversion from the Ark-Circom's internal Ethereum types to - // the ones expected by the abigen'd types. Could we maybe provide a convenience - // macro for these, given that there's room for implementation error? - abigen!(Groth16Verifier, "./artifacts/verifier_artifact.json"); - use groth_16_verifier::{G1Point, G2Point, Proof as EthProof, VerifyingKey as Groth16VerifyingKey}; - - impl From for G1Point { - fn from(src: ethereum::G1) -> Self { - Self { x: src.x, y: src.y } - } - } - - impl From for G2Point { - fn from(src: ethereum::G2) -> Self { - // We should use the `.as_tuple()` method which handles converting - // the G2 elements to have the second limb first - let src = src.as_tuple(); - Self { x: src.0, y: src.1 } - } - } - impl From for EthProof { - fn from(src: ethereum::Proof) -> Self { - Self { - a: src.a.into(), - b: src.b.into(), - c: src.c.into(), - } - } - } - impl From for Groth16VerifyingKey { - fn from(src: ethereum::VerifyingKey) -> Self { - Self { - alfa_1: src.alpha1.into(), - beta_2: src.beta2.into(), - gamma_2: src.gamma2.into(), - delta_2: src.delta2.into(), - ic: src.ic.into_iter().map(|i| i.into()).collect(), - } - } - } - - impl Groth16Verifier { - async fn check_proof< - I: Into, - P: Into, - VK: Into, - >( - &self, - proof: P, - vk: VK, - inputs: I, - ) -> Result> { - // convert into the expected format by the contract - let proof = proof.into().into(); - let vk = vk.into().into(); - let inputs = inputs.into().0; - println!("inputs in gorth16 verifier: {:?}", &inputs); - - // query the contract - let res = self.verify(inputs, proof, vk).call().await?; - - Ok(res) - } - } - - const WASM: &[u8] = include_bytes!("../passport/proof_of_passport.wasm"); - - static WITNESS_CALCULATOR: OnceCell> = OnceCell::new(); - - #[cfg(not(feature = "dylib"))] - #[must_use] - pub fn witness_calculator() -> &'static Mutex { - WITNESS_CALCULATOR.get_or_init(|| { - let store = Store::default(); - let module = Module::from_binary(&store, WASM).expect("WASM should be valid"); - let result = - WitnessCalculator::from_module(module).expect("Failed to create WitnessCalculator"); - Mutex::new(result) - }) - } - - const ARKZKEY_BYTES: &[u8] = include_bytes!("../passport/proof_of_passport_final.arkzkey"); - - static ARKZKEY: Lazy<(ProvingKey, ConstraintMatrices)> = Lazy::new(|| { - //let mut reader = Cursor::new(ARKZKEY_BYTES); - // TODO: Use reader? More flexible; unclear if perf diff - read_arkzkey_from_bytes(ARKZKEY_BYTES).expect("Failed to read arkzkey") - }); - - // Experimental - #[must_use] - pub fn arkzkey() -> &'static (ProvingKey, ConstraintMatrices) { - &ARKZKEY - } - - #[tokio::test] - async fn test_proof() -> Result<(), Box> { - let mut rng = thread_rng(); - let rng = &mut rng; - let r = ark_bn254::Fr::rand(rng); - let s = ark_bn254::Fr::rand(rng); - - let mut inputs: HashMap> = HashMap::new(); - let values = inputs.entry("a".to_string()).or_insert_with(Vec::new); - values.push(3.into()); - - let mrz_vec: Vec = vec![ "97", "91", "95", "31", "88", "80", "60", "70", "82", "65", "68", "85", "80", "79", "78", "84", "60", "60", "65", "76", "80", "72", "79", "78", "83", "69", "60", "72", "85", "71", "85", "69", "83", "60", "65", "76", "66", "69", "82", "84", "60", "60", "60", "60", "60", "60", "60", "60", "60", "50", "52", "72", "66", "56", "49", "56", "51", "50", "52", "70", "82", "65", "48", "52", "48", "50", "49", "49", "49", "77", "51", "49", "49", "49", "49", "49", "53", "60", "60", "60", "60", "60", "60", "60", "60", "60", "60", "60", "60", "60", "60", "48", "50"].iter().map(|&s| s.to_string()).collect(); - let reveal_bitmap_vec: Vec = vec![ "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1", "1"].iter().map(|&s| s.to_string()).collect(); - let data_hashes_vec: Vec = vec![ "48", "130", "1", "37", "2", "1", "0", "48", "11", "6", "9", "96", "134", "72", "1", "101", "3", "4", "2", "1", "48", "130", "1", "17", "48", "37", "2", "1", "1", "4", "32", "176", "223", "31", "133", "108", "84", "158", "102", "70", "11", "165", "175", "196", "12", "201", "130", "25", "131", "46", "125", "156", "194", "28", "23", "55", "133", "157", "164", "135", "136", "220", "78", "48", "37", "2", "1", "2", "4", "32", "190", "82", "180", "235", "222", "33", "79", "50", "152", "136", "142", "35", "116", "224", "6", "242", "156", "141", "128", "248", "10", "61", "98", "86", "248", "45", "207", "210", "90", "232", "175", "38", "48", "37", "2", "1", "3", "4", "32", "0", "194", "104", "108", "237", "246", "97", "230", "116", "198", "69", "110", "26", "87", "17", "89", "110", "199", "108", "250", "36", "21", "39", "87", "110", "102", "250", "213", "174", "131", "171", "174", "48", "37", "2", "1", "11", "4", "32", "136", "155", "87", "144", "111", "15", "152", "127", "85", "25", "154", "81", "20", "58", "51", "75", "193", "116", "234", "0", "60", "30", "29", "30", "183", "141", "72", "247", "255", "203", "100", "124", "48", "37", "2", "1", "12", "4", "32", "41", "234", "106", "78", "31", "11", "114", "137", "237", "17", "92", "71", "134", "47", "62", "78", "189", "233", "201", "214", "53", "4", "47", "189", "201", "133", "6", "121", "34", "131", "64", "142", "48", "37", "2", "1", "13", "4", "32", "91", "222", "210", "193", "62", "222", "104", "82", "36", "41", "138", "253", "70", "15", "148", "208", "156", "45", "105", "171", "241", "195", "185", "43", "217", "162", "146", "201", "222", "89", "238", "38", "48", "37", "2", "1", "14", "4", "32", "76", "123", "216", "13", "51", "227", "72", "245", "59", "193", "238", "166", "103", "49", "23", "164", "171", "188", "194", "197", "156", "187", "249", "28", "198", "95", "69", "15", "182", "56", "54", "38", "128", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "0", "9", "72"].iter().map(|&s| s.to_string()).collect(); - let datahashes_padded_length_str: String = "320".to_string(); - let e_content_bytes_vec: Vec = vec![ "49", "102", "48", "21", "6", "9", "42", "134", "72", "134", "247", "13", "1", "9", "3", "49", "8", "6", "6", "103", "129", "8", "1", "1", "1", "48", "28", "6", "9", "42", "134", "72", "134", "247", "13", "1", "9", "5", "49", "15", "23", "13", "49", "57", "49", "50", "49", "54", "49", "55", "50", "50", "51", "56", "90", "48", "47", "6", "9", "42", "134", "72", "134", "247", "13", "1", "9", "4", "49", "34", "4", "32", "32", "85", "108", "174", "127", "112", "178", "182", "8", "43", "134", "123", "192", "211", "131", "66", "184", "240", "212", "181", "240", "180", "106", "195", "24", "117", "54", "129", "19", "10", "250", "53"].iter().map(|&s| s.to_string()).collect(); - let pubkey_vec: Vec = vec![ "14877258137020857405", "14318023465818440622", "669762396243626034", "2098174905787760109", "13512184631463232752", "1151033230807403051", "1750794423069476136", "5398558687849555435", "7358703642447293896", "14972964178681968444", "17927376393065624666", "12136698642738483635", "13028589389954236416", "11728294669438967583", "11944475542136244450", "12725379692537957031", "16433947280623454013", "13881303350788339044", "8072426876492282526", "6117387215636660433", "4538720981552095319", "1804042726655603403", "5977651198873791747", "372166053406449710", "14344596050894147197", "10779070237704917237", "16780599956687811964", "17935955203645787728", "16348714160740996118", "15226818430852970175", "10311930392912784455", "16078982568357050303"].iter().map(|&s| s.to_string()).collect(); - let signature_vec: Vec = vec![ "5246435566823387901", "994140068779018945", "15914471451186462512", "7880571667552251248", "6469307986104572621", "12461949630634658221", "12450885696843643385", "13947454655189776216", "15974551328200116785", "931381626091656069", "1385903161379602775", "12855786061091617297", "15094260651801937779", "13471621228825251570", "17294887199620944108", "14311703967543697647", "12973402331891058776", "4499641933342092059", "10578231994395748441", "10761169031539003508", "9946908810756942959", "4164708910663312563", "1838078345835967157", "3031966336456751199", "12952597393846567366", "7709884308070068222", "2297541532764959033", "6155424118644397184", "10223511940510133693", "2888993604729528860", "2817846539210919674", "9919760476291903645"].iter().map(|&s| s.to_string()).collect(); - let address_str: String = "0xEde0fA5A7b196F512204f286666E5eC03E1005D2".to_string(); - - fn parse_and_insert(hash_map: &mut HashMap>, key: &str, data: Vec<&str>) { - let parsed_data: Vec = data.into_iter() - .filter_map(|s| s.parse::().ok().and_then(|num| num.to_bigint())) - .collect(); - hash_map.insert(key.to_string(), parsed_data); - } - - parse_and_insert(&mut inputs, "mrz", mrz_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "reveal_bitmap", reveal_bitmap_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "dataHashes", data_hashes_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "eContentBytes", e_content_bytes_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "signature", signature_vec.iter().map(AsRef::as_ref).collect()); - parse_and_insert(&mut inputs, "pubkey", pubkey_vec.iter().map(AsRef::as_ref).collect()); - - let address_bigint = BigInt::from_bytes_be(Sign::Plus, &decode(&address_str[2..])?); - inputs.insert("address".to_string(), vec![address_bigint]); - - let datahashes_padded_length_i32 = datahashes_padded_length_str.parse::().expect("Failed to parse datahashes_padded_length to i32"); - let datahashes_padded_length_bigint = BigInt::from(datahashes_padded_length_i32); - inputs.insert("datahashes_padded_length".to_string(), vec![datahashes_padded_length_bigint]); - - println!("generating witness..."); - let now = Instant::now(); - let full_assignment = witness_calculator() - .lock() - .expect("Failed to lock witness calculator") - .calculate_witness_element::(inputs, false) - .map_err(|e| e.to_string())?; - - println!("Witness generation took: {:.2?}", now.elapsed()); - println!("loading circuit..."); - let now = Instant::now(); - let zkey = arkzkey(); - println!("Loading arkzkey took: {:.2?}", now.elapsed()); - - let public_inputs = full_assignment.as_slice()[1..zkey.1.num_instance_variables].to_vec(); - let now = Instant::now(); - let ark_proof = Groth16::<_, CircomReduction>::create_proof_with_reduction_and_matrices( - &zkey.0, - r, - s, - &zkey.1, - zkey.1.num_instance_variables, - zkey.1.num_constraints, - full_assignment.as_slice(), - ); - - let proof = ark_proof.map_err(|e| e.to_string())?; - - println!("proof generation took: {:.2?}", now.elapsed()); - - println!("proof {:?}", proof); - println!("public_inputs {:?}", public_inputs); - - Ok(()) - // Ok((SerializableProof(proof), SerializableInputs(public_inputs))) - // now = Instant::now(); - - // let pvk = Groth16::::process_vk(¶ms.vk).unwrap(); - // let verified = Groth16::::verify_with_processed_vk(&pvk, &inputs, &proof).unwrap(); - // println!("Proof verified. Took: {:?}", now.elapsed()); - - // assert!(verified); - - // // launch the network & compile the verifier - // println!("launching network"); - - // let anvil = Anvil::new().spawn(); - // let acc = anvil.addresses()[0]; - // let provider = Provider::::try_from(anvil.endpoint())?; - // let provider = provider.with_sender(acc); - // let provider = Arc::new(provider); - - // // deploy the verifier - // let contract = Groth16Verifier::deploy(provider.clone(), ())? - // .send() - // .await?; - - // println!("verifier deployed"); - // println!("contract {:?}", contract); - // // check the proof on chain - // let onchain_verified = contract - // .check_proof(proof, params.vk, inputs.as_slice()) - // .await?; - - // println!("proof verified on chain"); - // println!("onchain_verified {:?}", onchain_verified); - - // assert!(onchain_verified); - - // Ok(()) - } -} diff --git a/app/ark-circom-passport/src/zkey.rs b/app/ark-circom-passport/src/zkey.rs deleted file mode 100644 index e22b1157a..000000000 --- a/app/ark-circom-passport/src/zkey.rs +++ /dev/null @@ -1,379 +0,0 @@ -//! ZKey Parsing -//! -//! Each ZKey file is broken into sections: -//! Header(1) -//! Prover Type 1 Groth -//! HeaderGroth(2) -//! n8q -//! q -//! n8r -//! r -//! NVars -//! NPub -//! DomainSize (multiple of 2 -//! alpha1 -//! beta1 -//! delta1 -//! beta2 -//! gamma2 -//! delta2 -//! IC(3) -//! Coefs(4) -//! PointsA(5) -//! PointsB1(6) -//! PointsB2(7) -//! PointsC(8) -//! PointsH(9) -//! Contributions(10) -use ark_ff::{BigInteger256, PrimeField}; -use ark_relations::r1cs::ConstraintMatrices; -use ark_serialize::{CanonicalDeserialize, SerializationError}; -use ark_std::log2; -use byteorder::{LittleEndian, ReadBytesExt}; - -use std::{ - collections::HashMap, - io::{Read, Seek, SeekFrom}, -}; - -use ark_bn254::{Bn254, Fq, Fq2, Fr, G1Affine, G2Affine}; -use ark_groth16::{ProvingKey, VerifyingKey}; -use num_traits::Zero; -use std::io::Cursor; - -type IoResult = Result; - -#[derive(Clone, Debug)] -struct Section { - position: u64, - #[allow(dead_code)] - size: usize, -} - -/// Reads a SnarkJS ZKey file into an Arkworks ProvingKey. -pub fn read_zkey( - reader: &mut R, -) -> IoResult<(ProvingKey, ConstraintMatrices)> { - let mut binfile = BinFile::new(reader)?; - let proving_key = binfile.proving_key()?; - let matrices = binfile.matrices()?; - Ok((proving_key, matrices)) -} - -pub fn read_zkey_from_include_bytes( - data: &[u8], -) -> IoResult<(ProvingKey, ConstraintMatrices)> { - let mut cursor = Cursor::new(data); - let mut binfile = BinFile::new(&mut cursor)?; - let proving_key = binfile.proving_key()?; - let matrices = binfile.matrices()?; - Ok((proving_key, matrices)) -} - -#[derive(Debug)] -struct BinFile<'a, R> { - #[allow(dead_code)] - ftype: String, - #[allow(dead_code)] - version: u32, - sections: HashMap>, - reader: &'a mut R, -} - -impl<'a, R: Read + Seek> BinFile<'a, R> { - fn new(reader: &'a mut R) -> IoResult { - let mut magic = [0u8; 4]; - reader.read_exact(&mut magic)?; - - let version = reader.read_u32::()?; - - let num_sections = reader.read_u32::()?; - - let mut sections = HashMap::new(); - for _ in 0..num_sections { - let section_id = reader.read_u32::()?; - let section_length = reader.read_u64::()?; - - let section = sections.entry(section_id).or_insert_with(Vec::new); - section.push(Section { - position: reader.stream_position()?, - size: section_length as usize, - }); - - reader.seek(SeekFrom::Current(section_length as i64))?; - } - - Ok(Self { - ftype: std::str::from_utf8(&magic[..]).unwrap().to_string(), - version, - sections, - reader, - }) - } - - fn proving_key(&mut self) -> IoResult> { - let header = self.groth_header()?; - let ic = self.ic(header.n_public)?; - - let a_query = self.a_query(header.n_vars)?; - let b_g1_query = self.b_g1_query(header.n_vars)?; - let b_g2_query = self.b_g2_query(header.n_vars)?; - let l_query = self.l_query(header.n_vars - header.n_public - 1)?; - let h_query = self.h_query(header.domain_size as usize)?; - - let vk = VerifyingKey:: { - alpha_g1: header.verifying_key.alpha_g1, - beta_g2: header.verifying_key.beta_g2, - gamma_g2: header.verifying_key.gamma_g2, - delta_g2: header.verifying_key.delta_g2, - gamma_abc_g1: ic, - }; - - let pk = ProvingKey:: { - vk, - beta_g1: header.verifying_key.beta_g1, - delta_g1: header.verifying_key.delta_g1, - a_query, - b_g1_query, - b_g2_query, - h_query, - l_query, - }; - - Ok(pk) - } - - fn get_section(&self, id: u32) -> Section { - self.sections.get(&id).unwrap()[0].clone() - } - - fn groth_header(&mut self) -> IoResult { - let section = self.get_section(2); - let header = HeaderGroth::new(&mut self.reader, §ion)?; - Ok(header) - } - - fn ic(&mut self, n_public: usize) -> IoResult> { - // the range is non-inclusive so we do +1 to get all inputs - self.g1_section(n_public + 1, 3) - } - - /// Returns the [`ConstraintMatrices`] corresponding to the zkey - pub fn matrices(&mut self) -> IoResult> { - let header = self.groth_header()?; - - let section = self.get_section(4); - self.reader.seek(SeekFrom::Start(section.position))?; - let num_coeffs: u32 = self.reader.read_u32::()?; - - // insantiate AB - let mut matrices = vec![vec![vec![]; header.domain_size as usize]; 2]; - let mut max_constraint_index = 0; - for _ in 0..num_coeffs { - let matrix: u32 = self.reader.read_u32::()?; - let constraint: u32 = self.reader.read_u32::()?; - let signal: u32 = self.reader.read_u32::()?; - - let value: Fr = deserialize_field_fr(&mut self.reader)?; - max_constraint_index = std::cmp::max(max_constraint_index, constraint); - matrices[matrix as usize][constraint as usize].push((value, signal as usize)); - } - - let num_constraints = max_constraint_index as usize - header.n_public; - // Remove the public input constraints, Arkworks adds them later - matrices.iter_mut().for_each(|m| { - m.truncate(num_constraints); - }); - // This is taken from Arkworks' to_matrices() function - let a = matrices[0].clone(); - let b = matrices[1].clone(); - let a_num_non_zero: usize = a.iter().map(|lc| lc.len()).sum(); - let b_num_non_zero: usize = b.iter().map(|lc| lc.len()).sum(); - let matrices = ConstraintMatrices { - num_instance_variables: header.n_public + 1, - num_witness_variables: header.n_vars - header.n_public, - num_constraints, - - a_num_non_zero, - b_num_non_zero, - c_num_non_zero: 0, - - a, - b, - c: vec![], - }; - - Ok(matrices) - } - - fn a_query(&mut self, n_vars: usize) -> IoResult> { - self.g1_section(n_vars, 5) - } - - fn b_g1_query(&mut self, n_vars: usize) -> IoResult> { - self.g1_section(n_vars, 6) - } - - fn b_g2_query(&mut self, n_vars: usize) -> IoResult> { - self.g2_section(n_vars, 7) - } - - fn l_query(&mut self, n_vars: usize) -> IoResult> { - self.g1_section(n_vars, 8) - } - - fn h_query(&mut self, n_vars: usize) -> IoResult> { - self.g1_section(n_vars, 9) - } - - fn g1_section(&mut self, num: usize, section_id: usize) -> IoResult> { - let section = self.get_section(section_id as u32); - self.reader.seek(SeekFrom::Start(section.position))?; - deserialize_g1_vec(self.reader, num as u32) - } - - fn g2_section(&mut self, num: usize, section_id: usize) -> IoResult> { - let section = self.get_section(section_id as u32); - self.reader.seek(SeekFrom::Start(section.position))?; - deserialize_g2_vec(self.reader, num as u32) - } -} - -#[derive(Default, Clone, Debug, CanonicalDeserialize)] -pub struct ZVerifyingKey { - alpha_g1: G1Affine, - beta_g1: G1Affine, - beta_g2: G2Affine, - gamma_g2: G2Affine, - delta_g1: G1Affine, - delta_g2: G2Affine, -} - -impl ZVerifyingKey { - fn new(reader: &mut R) -> IoResult { - let alpha_g1 = deserialize_g1(reader)?; - let beta_g1 = deserialize_g1(reader)?; - let beta_g2 = deserialize_g2(reader)?; - let gamma_g2 = deserialize_g2(reader)?; - let delta_g1 = deserialize_g1(reader)?; - let delta_g2 = deserialize_g2(reader)?; - - Ok(Self { - alpha_g1, - beta_g1, - beta_g2, - gamma_g2, - delta_g1, - delta_g2, - }) - } -} - -#[derive(Clone, Debug)] -struct HeaderGroth { - #[allow(dead_code)] - n8q: u32, - #[allow(dead_code)] - q: BigInteger256, - #[allow(dead_code)] - n8r: u32, - #[allow(dead_code)] - r: BigInteger256, - - n_vars: usize, - n_public: usize, - - domain_size: u32, - #[allow(dead_code)] - power: u32, - - verifying_key: ZVerifyingKey, -} - -impl HeaderGroth { - fn new(reader: &mut R, section: &Section) -> IoResult { - reader.seek(SeekFrom::Start(section.position))?; - Self::read(reader) - } - - fn read(mut reader: &mut R) -> IoResult { - // TODO: Impl From in Arkworks - let n8q: u32 = u32::deserialize_uncompressed(&mut reader)?; - // group order r of Bn254 - let q = BigInteger256::deserialize_uncompressed(&mut reader)?; - - let n8r: u32 = u32::deserialize_uncompressed(&mut reader)?; - // Prime field modulus - let r = BigInteger256::deserialize_uncompressed(&mut reader)?; - - let n_vars = u32::deserialize_uncompressed(&mut reader)? as usize; - let n_public = u32::deserialize_uncompressed(&mut reader)? as usize; - - let domain_size: u32 = u32::deserialize_uncompressed(&mut reader)?; - let power = log2(domain_size as usize); - - let verifying_key = ZVerifyingKey::new(&mut reader)?; - - Ok(Self { - n8q, - q, - n8r, - r, - n_vars, - n_public, - domain_size, - power, - verifying_key, - }) - } -} - -// need to divide by R, since snarkjs outputs the zkey with coefficients -// multiplieid by R^2 -fn deserialize_field_fr(reader: &mut R) -> IoResult { - let bigint = BigInteger256::deserialize_uncompressed(reader)?; - Ok(Fr::new_unchecked(Fr::new_unchecked(bigint).into_bigint())) -} - -// skips the multiplication by R because Circom points are already in Montgomery form -fn deserialize_field(reader: &mut R) -> IoResult { - let bigint = BigInteger256::deserialize_uncompressed(reader)?; - // if you use Fq::new it multiplies by R - Ok(Fq::new_unchecked(bigint)) -} - -pub fn deserialize_field2(reader: &mut R) -> IoResult { - let c0 = deserialize_field(reader)?; - let c1 = deserialize_field(reader)?; - Ok(Fq2::new(c0, c1)) -} - -fn deserialize_g1(reader: &mut R) -> IoResult { - let x = deserialize_field(reader)?; - let y = deserialize_field(reader)?; - let infinity = x.is_zero() && y.is_zero(); - if infinity { - Ok(G1Affine::identity()) - } else { - Ok(G1Affine::new_unchecked(x, y)) - } -} - -fn deserialize_g2(reader: &mut R) -> IoResult { - let f1 = deserialize_field2(reader)?; - let f2 = deserialize_field2(reader)?; - let infinity = f1.is_zero() && f2.is_zero(); - if infinity { - Ok(G2Affine::identity()) - } else { - Ok(G2Affine::new_unchecked(f1, f2)) - } -} - -fn deserialize_g1_vec(reader: &mut R, n_vars: u32) -> IoResult> { - (0..n_vars).map(|_| deserialize_g1(reader)).collect() -} - -fn deserialize_g2_vec(reader: &mut R, n_vars: u32) -> IoResult> { - (0..n_vars).map(|_| deserialize_g2(reader)).collect() -} \ No newline at end of file diff --git a/app/deployments/Groth16Verifier.json b/app/deployments/Groth16Verifier.json index 96d791602..066d6af23 100644 --- a/app/deployments/Groth16Verifier.json +++ b/app/deployments/Groth16Verifier.json @@ -38,8 +38,8 @@ "type": "function" } ], - "bytecode": "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", - "deployedBytecode": "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", + "bytecode": "0x608060405234801561001057600080fd5b506107df806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c8063f398789b14610030575b600080fd5b61004a6004803603810190610045919061070a565b610060565b604051610057919061078e565b60405180910390f35b600061061d565b7f30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd478110610098576000805260206000f35b50565b600060405183815284602082015285604082015260408160608360076107d05a03fa9150816100ce576000805260206000f35b825160408201526020830151606082015260408360808360066107d05a03fa9150816100fe576000805260206000f35b505050505050565b600060808601600087017f1973951e3206379f4b6cb9ed31fd07e9addd1ce68ab96ad19772c7d0158cba9c81527f2d6c822a71336962fd88a2bcfa2fae9728d345b1f8ac02ef42e6732363fb16fa60208201526101a960008801357f1c4ff48dd08344e7d8ec93176ac4b4a89c3007053fa3762c07c59db1e7c8224f7f0af2a778dd1b8e999ceedf5a3b70df4ca2b6b49b25ab2a7c9946ad6a9286b0d18461009b565b6101f960208801357f2df91f17d37221f3be246a89e8ffe13b9ccc0afdcf80d5fcd343a347ad34b6fa7f2382d5ad4ebe78eeacc64bfebf7ca7e04154e5d09f7dd947d1e96db07e844c4b8461009b565b61024960408801357f06a4be12318195066a5b96da729b895ffb35d15f0da863bc589ad87dc92a59b37f25c6c85b5e06226e16bf0ce04b41e24a9e70443959a839e140381ee36b4973498461009b565b61029960608801357f0898eec5cc579d3a7213b2b38afaaf269613f60f231f788ffa2499be402c23757f18eb6d35340d98950203d516789960e1cbebd23d7fcef9836185fedc73c607088461009b565b6102e960808801357f05c16a0090bf91c1f53f7bd71a0016b99fb8ece9f11b5413a8916a89efc903407f1acc863422c39f57de8944287a183732c41d986e2da7298415f5157351852aaf8461009b565b61033960a08801357f2332aaf5f84f1f039f292c20fa042012f30899bafa18afbaf85f96385cbe0e617f258b4482fa5d1c1267315e5f6bbc023dc6a8fc810ab8a419b787949efcc1a9868461009b565b833582527f30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd4760208501357f30644e72e131a029b85045b68181585d97816a916871ca8d3c208c16d87cfd4703066020830152843560408301526020850135606083015260408501356080830152606085013560a08301527f2d4d9aa7e302d9df41749d5507949d05dbea33fbb16c643b22f599a2be6df2e260c08301527f14bedd503c37ceb061d8ec60209fe345ce89830a19230301f076caff004d192660e08301527f0967032fcbf776d1afc985f88877f182d38480a653f2decaa9794cbc3bf3060c6101008301527f0e187847ad4c798374d0d6732bf501847dd68bc0e071241e0213bc7fc13db7ab6101208301527f304cfbd1e08a704a99f5e847d93f8c3caafddec46b7a0d379da69a4d112346a76101408301527f1739c1b1a457a8c7313123d24d2f9192f896b7c63eea05a9d57f06547ad0cec8610160830152600088015161018083015260206000018801516101a08301527f198e9393920d483a7260bfb731fb5d25f1aa493335a9e71297e485b7aef312c26101c08301527f1800deef121f1e76426a00665e5c4479674322d4f75edadd46debd5cd992f6ed6101e08301527f090689d0585ff075ec9e99ad690c3395bc4b313370b38ef355acdadcd122975b6102008301527f12c85ea5db8c6deb4aab71808dcb408fe3d1e7690c43d37b4ce6cc0166fa7daa610220830152853561024083015260208601356102608301527f13093cf285e0d3af1aeb57953666538e5ff8be9effe1b4ff9301356e36ef27ca6102808301527f1a575a2a1e4cb4f452b1c815184e71c51e5a3c44b11c691aed0b39de518b1aed6102a08301527f06f6b931a88f43f1964418344340a23d286ddd6232a87cb9dc48038c4d10fcc86102c08301527f04c9c9a1061ee327db8022d3dfaa997d65fb46266c4a11620664967c2c98ddb96102e08301526020826103008460086107d05a03fa82518116935050505095945050505050565b60405161038081016040526106356000840135610067565b6106426020840135610067565b61064f6040840135610067565b61065c6060840135610067565b6106696080840135610067565b61067660a0840135610067565b61068360c0840135610067565b610690818486888a610106565b8060005260206000f35b600080fd5b600080fd5b6000819050826020600202820111156106c0576106bf61069f565b5b92915050565b6000819050826040600202820111156106e2576106e161069f565b5b92915050565b6000819050826020600602820111156107045761070361069f565b5b92915050565b6000806000806101c085870312156107255761072461069a565b5b6000610733878288016106a4565b9450506040610744878288016106c6565b93505060c0610755878288016106a4565b925050610100610767878288016106e8565b91505092959194509250565b60008115159050919050565b61078881610773565b82525050565b60006020820190506107a3600083018461077f565b9291505056fea2646970667358221220f90502a2cdc1be3aae6482c9ad4fd05fbce27381eff1b8971a25df2c50f3a0bd64736f6c63430008120033", + "deployedBytecode": "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", "linkReferences": {}, "deployedLinkReferences": {} } diff --git a/app/deployments/ProofOfPassport.json b/app/deployments/ProofOfPassport.json index 67ceecb55..46968f597 100644 --- a/app/deployments/ProofOfPassport.json +++ b/app/deployments/ProofOfPassport.json @@ -640,8 +640,8 @@ "type": "function" } ], - "bytecode": "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", - "deployedBytecode": "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", + "bytecode": "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", + "deployedBytecode": "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", "linkReferences": {}, "deployedLinkReferences": {} } diff --git a/app/deployments/addresses.json b/app/deployments/addresses.json index 1640df45d..aaa67e40f 100644 --- a/app/deployments/addresses.json +++ b/app/deployments/addresses.json @@ -1 +1 @@ -{"ProofOfPassport":"0x24c919Dc3E5BA89c0898778D71435D566B05B4c5","Groth16Verifier":"0x6b3c6CF3e7bf2663E5EA30F2566433261fe64554"} \ No newline at end of file +{"ProofOfPassport":"0xe3e5738EBb14EFB2041aa41068D1bdd7c0DFD03A","Groth16Verifier":"0xD923a1AA54e5a1F6d288649C3a2b7aB5856514cf"} \ No newline at end of file diff --git a/app/scripts/build_android_module.sh b/app/scripts/build_android_module.sh index be0424414..b19e004f3 100755 --- a/app/scripts/build_android_module.sh +++ b/app/scripts/build_android_module.sh @@ -1,26 +1,76 @@ -mkdir -p ark-circom-passport/passport -cp ../circuits/build/proof_of_passport_final.zkey ark-circom-passport/passport/ -echo "copied proof_of_passport_final.zkey to ark-circom-passport" +#!/bin/bash -ARCHITECTURE="aarch64-linux-android" +# This is adapted from mopro -# Check for target support -check_target_support() { - rustup target list | grep installed | grep -q "$1" -} +DEVICE_TYPE="arm64" +BUILD_MODE="release" -# check target is installed -if ! check_target_support $ARCHITECTURE; then - rustup target add $ARCHITECTURE -else - echo "Target $ARCHITECTURE already installed, skipping." -fi +# Determine the architecture and folder based on device type +case $DEVICE_TYPE in + "x86_64") + ARCHITECTURE="x86_64-linux-android" + FOLDER="x86_64" + ;; + "x86") + ARCHITECTURE="i686-linux-android" + FOLDER="x86" + ;; + "arm") + ARCHITECTURE="armv7-linux-androideabi" + FOLDER="armeabi-v7a" + ;; + "arm64") + ARCHITECTURE="aarch64-linux-android" + FOLDER="arm64-v8a" + ;; + *) + echo -e "${RED}Error: Invalid device type specified in config: $DEVICE_TYPE${DEFAULT}" + exit 1 + ;; +esac -cd android -./gradlew clean -./gradlew cargoBuild -cd .. +# Determine the library directory and build command based on build mode +case $BUILD_MODE in + "debug") + LIB_DIR="debug" + COMMAND="" + ;; + "release") + LIB_DIR="release" + COMMAND="--release" + ;; + *) + echo -e "${RED}Error: Invalid build mode specified in config: $BUILD_MODE${DEFAULT}" + exit 1 + ;; +esac -mkdir -p android/react-native-passport-reader/android/src/main/jniLibs/arm64-v8a/ - cp ark-circom-passport/target/aarch64-linux-android/release/libark_circom_passport.so android/react-native-passport-reader/android/src/main/jniLibs/arm64-v8a/ - echo copied release version of android lib to android/ \ No newline at end of file +PROJECT_DIR=$(pwd) + +cd ${PROJECT_DIR}/mopro-ffi + +echo "[android] Install cargo-ndk" +cargo install cargo-ndk + +# Print appropriate message based on device type +echo "Using $ARCHITECTURE libmopro_ffi.a ($LIB_DIR) static library..." +print_warning "This only works on $FOLDER devices!" + +echo "[android] Build target in $BUILD_MODE mode" +cargo ndk -t ${ARCHITECTURE} build --lib ${COMMAND} + +echo "[android] Copy files in mopro-android/Example/jniLibs/" +for binary in ${PROJECT_DIR}/mopro-ffi/target/*/*/libmopro_ffi.so; do file $binary; done + +mkdir -p jniLibs/${FOLDER}/ && \ +cp ${PROJECT_DIR}/mopro-ffi/target/${ARCHITECTURE}/${LIB_DIR}/libmopro_ffi.so jniLibs/${FOLDER}/libuniffi_mopro.so + +echo "[android] Generating Kotlin bindings in $BUILD_MODE mode..." +cargo run --features=uniffi/cli ${COMMAND} \ +--bin uniffi-bindgen \ +generate src/mopro.udl \ +--language kotlin + +echo "[android] Copy Kotlin bindings to android app" +cp -r ${PROJECT_DIR}/mopro-ffi/jniLibs/ ${PROJECT_DIR}/android/app/src/main/jniLibs/ +cp -r ${PROJECT_DIR}/mopro-ffi/src/uniffi/ ${PROJECT_DIR}/android/app/src/main/java/uniffi/ \ No newline at end of file diff --git a/app/scripts/build_ios_module.sh b/app/scripts/build_ios_module.sh index d081ad0f4..cea6bc487 100755 --- a/app/scripts/build_ios_module.sh +++ b/app/scripts/build_ios_module.sh @@ -1,3 +1,6 @@ +#!/bin/bash + +# This is adapted from mopro ARCHITECTURE="aarch64-apple-ios" # or "x86_64-apple-ios" for "x86_64", "aarch64-apple-ios-sim" for simulator LIB_DIR="release" # or "debug" diff --git a/app/scripts/download_current_zkey.sh b/app/scripts/download_current_zkey.sh index d5170f223..58ecfa53c 100755 --- a/app/scripts/download_current_zkey.sh +++ b/app/scripts/download_current_zkey.sh @@ -1,3 +1,5 @@ +#!/bin/bash + mkdir -p ../circuits/build cd ../circuits/build if [ -f "proof_of_passport_final.zkey" ]; then diff --git a/app/src/screens/ProveScreen.tsx b/app/src/screens/ProveScreen.tsx index 2701069fb..b77cae9b0 100644 --- a/app/src/screens/ProveScreen.tsx +++ b/app/src/screens/ProveScreen.tsx @@ -52,7 +52,7 @@ const ProveScreen: React.FC = ({ ens, setEns }) => { - const [zkeyLoaded, setZkeyLoaded] = useState(false); + const [zkeyLoaded, setZkeyLoaded] = useState(true); const downloadZkey = async () => { // TODO: don't redownload if already in the file system at path, if downloaded from previous session diff --git a/circuits/test/inputs.json b/circuits/test/inputs.json new file mode 100644 index 000000000..4b2facb7e --- /dev/null +++ b/circuits/test/inputs.json @@ -0,0 +1,723 @@ +{ + "mrz": [ + "97", + "91", + "95", + "31", + "88", + "80", + "60", + "70", + "82", + "65", + "84", + "65", + "86", + "69", + "82", + "78", + "73", + "69", + "82", + "60", + "60", + "70", + "76", + "79", + "82", + "69", + "78", + "84", + "60", + "72", + "85", + "71", + "85", + "69", + "83", + "60", + "74", + "69", + "65", + "78", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "49", + "57", + "72", + "65", + "51", + "52", + "56", + "50", + "56", + "52", + "70", + "82", + "65", + "48", + "48", + "48", + "55", + "49", + "57", + "49", + "77", + "50", + "57", + "49", + "50", + "48", + "57", + "53", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "60", + "48", + "50" + ], + "reveal_bitmap": [ + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0" + ], + "dataHashes": [ + "48", + "130", + "1", + "37", + "2", + "1", + "0", + "48", + "11", + "6", + "9", + "96", + "134", + "72", + "1", + "101", + "3", + "4", + "2", + "1", + "48", + "130", + "1", + "17", + "48", + "37", + "2", + "1", + "1", + "4", + "32", + "99", + "19", + "179", + "205", + "55", + "104", + "45", + "214", + "133", + "101", + "233", + "177", + "130", + "1", + "37", + "89", + "125", + "229", + "139", + "34", + "132", + "146", + "28", + "116", + "248", + "186", + "63", + "195", + "96", + "151", + "26", + "215", + "48", + "37", + "2", + "1", + "2", + "4", + "32", + "63", + "234", + "106", + "78", + "31", + "16", + "114", + "137", + "237", + "17", + "92", + "71", + "134", + "47", + "62", + "78", + "189", + "233", + "201", + "213", + "53", + "4", + "47", + "189", + "201", + "133", + "6", + "121", + "34", + "131", + "64", + "142", + "48", + "37", + "2", + "1", + "3", + "4", + "32", + "136", + "155", + "87", + "144", + "121", + "15", + "152", + "127", + "85", + "25", + "154", + "80", + "20", + "58", + "51", + "75", + "193", + "116", + "234", + "0", + "60", + "30", + "29", + "30", + "183", + "141", + "72", + "247", + "255", + "203", + "100", + "124", + "48", + "37", + "2", + "1", + "11", + "4", + "32", + "0", + "194", + "104", + "108", + "237", + "246", + "97", + "230", + "116", + "198", + "69", + "110", + "26", + "87", + "17", + "89", + "110", + "199", + "108", + "250", + "36", + "21", + "39", + "87", + "110", + "102", + "250", + "213", + "174", + "131", + "171", + "174", + "48", + "37", + "2", + "1", + "12", + "4", + "32", + "190", + "82", + "180", + "235", + "222", + "33", + "79", + "50", + "152", + "136", + "142", + "35", + "116", + "224", + "6", + "242", + "156", + "141", + "128", + "247", + "10", + "61", + "98", + "86", + "248", + "45", + "207", + "210", + "90", + "232", + "175", + "38", + "48", + "37", + "2", + "1", + "13", + "4", + "32", + "91", + "222", + "210", + "193", + "63", + "222", + "104", + "82", + "36", + "41", + "138", + "253", + "70", + "15", + "148", + "208", + "156", + "45", + "105", + "171", + "241", + "195", + "185", + "43", + "217", + "162", + "146", + "201", + "222", + "89", + "238", + "38", + "48", + "37", + "2", + "1", + "14", + "4", + "32", + "76", + "123", + "216", + "13", + "52", + "227", + "72", + "245", + "59", + "193", + "238", + "166", + "103", + "49", + "24", + "164", + "171", + "188", + "194", + "197", + "156", + "187", + "249", + "28", + "198", + "95", + "69", + "15", + "182", + "56", + "54", + "38", + "128", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "0", + "9", + "72" + ], + "datahashes_padded_length": "320", + "eContentBytes": [ + "49", + "102", + "48", + "21", + "6", + "9", + "42", + "134", + "72", + "134", + "247", + "13", + "1", + "9", + "3", + "49", + "8", + "6", + "6", + "103", + "129", + "8", + "1", + "1", + "1", + "48", + "28", + "6", + "9", + "42", + "134", + "72", + "134", + "247", + "13", + "1", + "9", + "5", + "49", + "15", + "23", + "13", + "49", + "57", + "49", + "50", + "49", + "54", + "49", + "55", + "50", + "50", + "51", + "56", + "90", + "48", + "47", + "6", + "9", + "42", + "134", + "72", + "134", + "247", + "13", + "1", + "9", + "4", + "49", + "34", + "4", + "32", + "176", + "96", + "59", + "213", + "131", + "82", + "89", + "248", + "105", + "125", + "37", + "177", + "158", + "162", + "137", + "43", + "13", + "39", + "115", + "6", + "59", + "229", + "81", + "110", + "49", + "75", + "255", + "184", + "155", + "73", + "116", + "86" + ], + "signature": [ + "1004979219314799894", + "6361443755252600907", + "6439012883494616023", + "9400879716815088139", + "17551897985575934811", + "11779273958797828281", + "2536315921873401485", + "3748173260178203981", + "12475215309213288577", + "6281117468118442715", + "1336292932993922350", + "14238156234566069988", + "11985045093510507012", + "3585865343992378960", + "16170829868787473084", + "17039645001628184779", + "486540501180074772", + "5061439412388381188", + "12478821212163933993", + "7430448406248319432", + "746345521572597865", + "5002454658692185142", + "3715069341922830389", + "11010599232161942094", + "1577500614971981868", + "13656226284809645063", + "3918261659477120323", + "5578832687955645075", + "3416933977282345392", + "15829829506526117610", + "17465616637242519010", + "6519177967447716150" + ], + "signatureAlgorithm": "1", + "pubkey": [ + "9539992759301679521", + "1652651398804391575", + "7756096264856639170", + "15028348881266521487", + "13451582891670014060", + "11697656644529425980", + "14590137142310897374", + "1172377360308996086", + "6389592621616098288", + "6767780215543232436", + "11347756978427069433", + "2593119277386338350", + "18385617576997885505", + "14960211320702750252", + "8706817324429498800", + "15168543370367053559", + "8708916123725550363", + "18006178692029805686", + "6398208271038376723", + "15000821494077560096", + "17674982305626887153", + "2867958270953137726", + "9287774520059158342", + "9813100051910281130", + "13494313215150203208", + "7792741716144106392", + "6553490305289731807", + "32268224696386820", + "15737886769048580611", + "669518601007982974", + "11424760966478363403", + "16073833083611347461" + ], + "pathIndices": [ + "0", + "1", + "1", + "1", + "1", + "1", + "1", + "0", + "1", + "1", + "0", + "0", + "1", + "1", + "0", + "0" + ], + "siblings": [ + "20516282398390866580647417962347415258712802604212003365416596890852644939364", + "20547289806543281108128197867250295423223489766069952889766689677695750842294", + "17092860852967512812593771487649838995106203215624858397482169733546970246117", + "19141872343555753276227561835732941623954902346285308564941039231845690663515", + "2888260764701592030713638283446165050628606750519377550369633789586724212406", + "17037943129534065359096662792322618985598809624384219749636863003643326502177", + "21260541151470016589788332273091943678373855676584683193443363340566713593750", + "9681119423869145671286918102040570804786474221694907866875171055859965502010", + "3999714159260652982057321310481110903729446356195536109316994934664982988519", + "14359042263488593594514913785064471775842285148703143594475594381078274944550", + "10696856845043652409316424831381338144209147199074363427177722046972515079299", + "2796323689030312622891330190155708704921773618732461037692992858528069077360", + "1379184643939692456020535864077563679018059205165852146212742699309755722087", + "17834317267514482863629341626611816587254867008433493508231639322166589549456", + "1473918712602583605383280948484316645101117513102582419100942131704211814519", + "15819538789928229930262697811477882737253464456578333862691129291651619515538" + ], + "root": "4080578225172475068086778061870548445929343471785864518431540330127324371840", + "address": "0x70997970c51812dc3a010c7d01b50e0d17dc79c8" +} diff --git a/circuits/yarn.lock b/circuits/yarn.lock index 0b2e84175..b2dc55792 100644 --- a/circuits/yarn.lock +++ b/circuits/yarn.lock @@ -455,10 +455,6 @@ version "2.0.0-beta.1" resolved "https://gitpkg.now.sh/0xturboblitz/zk-kit/packages/imt?6d417675#38244ea6eef75dc1ad7fff3ff2a22dd5f1a2593a" -"@zk-kit/imt@https://gitpkg.now.sh/0xturboblitz/zk-kit/packages/imt?b6e7d542": - version "2.0.0-beta.1" - resolved "https://gitpkg.now.sh/0xturboblitz/zk-kit/packages/imt?b6e7d542#ade4ca8ba82e2a4d54889bcda143c81f82d61580" - addressparser@^1.0.1: version "1.0.1" resolved "https://registry.yarnpkg.com/addressparser/-/addressparser-1.0.1.tgz#47afbe1a2a9262191db6838e4fd1d39b40821746" diff --git a/common/src/utils/generateInputs.ts b/common/src/utils/generateInputs.ts index 72d47f868..9b1c3501c 100644 --- a/common/src/utils/generateInputs.ts +++ b/common/src/utils/generateInputs.ts @@ -39,18 +39,19 @@ export function generateCircuitInputs(passportData: PassportData, tree: IMT, rev MAX_DATAHASHES_LEN ); + // don't forget to wrap everything in arrays for mopro bindings return { mrz: formattedMrz.map(byte => String(byte)), reveal_bitmap: reveal_bitmap.map(byte => String(byte)), dataHashes: Array.from(messagePadded).map((x) => x.toString()), - datahashes_padded_length: messagePaddedLen.toString(), + datahashes_padded_length: [messagePaddedLen.toString()], eContentBytes: passportData.eContent.map(toUnsignedByte).map(byte => String(byte)), signature: splitToWords( BigInt(bytesToBigDecimal(passportData.encryptedDigest)), BigInt(64), BigInt(32) ), - signatureAlgorithm: SignatureAlgorithm[sigAlgFormatted].toString(), + signatureAlgorithm: [SignatureAlgorithm[sigAlgFormatted].toString()], pubkey: splitToWords( BigInt(passportData.pubKey.modulus as string), BigInt(64), @@ -58,7 +59,7 @@ export function generateCircuitInputs(passportData: PassportData, tree: IMT, rev ), pathIndices: proof.pathIndices.map(index => index.toString()), siblings: proof.siblings.flat().map(index => index.toString()), - root: tree.root.toString(), - address, + root: [tree.root.toString()], + address: [BigInt(address).toString()], } } \ No newline at end of file diff --git a/common/src/utils/pubkeyTree.ts b/common/src/utils/pubkeyTree.ts index 014deebd7..62fdc5a8e 100644 --- a/common/src/utils/pubkeyTree.ts +++ b/common/src/utils/pubkeyTree.ts @@ -32,8 +32,8 @@ export function buildPubkeyTree(pubkeys: any[]) { export function getLeaf(pubkey: any, i?: number): bigint { const sigAlgFormatted = formatSigAlg(pubkey.signatureAlgorithm, pubkey.exponent) - console.log('pubkey', pubkey) - console.log('sigAlgFormatted', sigAlgFormatted) + // console.log('pubkey', pubkey) + // console.log('sigAlgFormatted', sigAlgFormatted) if ( sigAlgFormatted === "sha256WithRSAEncryption_65537" || sigAlgFormatted === "sha256WithRSAEncryption_3" @@ -46,7 +46,7 @@ export function getLeaf(pubkey: any, i?: number): bigint { // This is because Poseidon circuit only supports an array of 16 elements, and field size is 254. const pubkeyChunked = bigIntToChunkedBytes(BigInt(pubkey.modulus), 192, 11); - console.log('pubkeyChunked', pubkeyChunked.length, pubkeyChunked) + // console.log('pubkeyChunked', pubkeyChunked.length, pubkeyChunked) try { // leaf is poseidon(signatureAlgorithm, ...pubkey) return poseidon12([SignatureAlgorithm[sigAlgFormatted], ...pubkeyChunked]) diff --git a/common/src/utils/utils.ts b/common/src/utils/utils.ts index 234d642a2..bd8f4f8d5 100644 --- a/common/src/utils/utils.ts +++ b/common/src/utils/utils.ts @@ -227,7 +227,7 @@ function setFirstBitOfLastByteToZero(bytes: number[]) { } // from reverse engineering ark-serialize. -export function formatProofIOS(proof: number[]) { +export function formatProof(proof: number[]) { const splittedProof = splitInto(proof, 32); splittedProof[1] = setFirstBitOfLastByteToZero(splittedProof[1]); splittedProof[5] = setFirstBitOfLastByteToZero(splittedProof[5]); // We might need to do the same for input 3 @@ -244,7 +244,7 @@ export function formatProofIOS(proof: number[]) { } } -export function formatInputsIOS(inputs: number[]) { +export function formatInputs(inputs: number[]) { const splitted = splitInto(inputs.slice(8), 32); return splitted.map(bytesToBigInt); } diff --git a/common/yarn.lock b/common/yarn.lock index 0b8a8ecf6..19a278468 100644 --- a/common/yarn.lock +++ b/common/yarn.lock @@ -27,10 +27,6 @@ version "2.0.0-beta.1" resolved "https://gitpkg.now.sh/0xturboblitz/zk-kit/packages/imt?6d417675#38244ea6eef75dc1ad7fff3ff2a22dd5f1a2593a" -"@zk-kit/imt@https://gitpkg.now.sh/0xturboblitz/zk-kit/packages/imt?b6e7d542": - version "2.0.0-beta.1" - resolved "https://gitpkg.now.sh/0xturboblitz/zk-kit/packages/imt?b6e7d542#ade4ca8ba82e2a4d54889bcda143c81f82d61580" - js-sha256@^0.10.1: version "0.10.1" resolved "https://registry.npmjs.org/js-sha256/-/js-sha256-0.10.1.tgz" diff --git a/contracts/contracts/ProofOfPassport.sol b/contracts/contracts/ProofOfPassport.sol index aa329803f..7dd5b5f4f 100644 --- a/contracts/contracts/ProofOfPassport.sol +++ b/contracts/contracts/ProofOfPassport.sol @@ -62,7 +62,7 @@ contract ProofOfPassport is ERC721Enumerable, Ownable { require(verifier.verifyProof(a, b, c, inputs), "Invalid Proof"); // check that the nullifier has not been used before - require(!nullifiers[inputs[3]], "Signature already nullified"); + // require(!nullifiers[inputs[3]], "Signature already nullified"); require(registry.checkRoot(bytes32(inputs[4])), "Invalid merkle root"); diff --git a/contracts/contracts/Verifier.sol b/contracts/contracts/Verifier.sol index 5c0836b89..389a397d9 100644 --- a/contracts/contracts/Verifier.sol +++ b/contracts/contracts/Verifier.sol @@ -37,10 +37,10 @@ contract Groth16Verifier { uint256 constant gammax2 = 10857046999023057135944570762232829481370756359578518086990519993285655852781; uint256 constant gammay1 = 4082367875863433681332203403145435568316851327593401208105741076214120093531; uint256 constant gammay2 = 8495653923123431417604973247489272438418190587263600148770280649306958101930; - uint256 constant deltax1 = 21881528432292977566019709592238441958035597439587625248811386927721538743387; - uint256 constant deltax2 = 20551268511319060106899593428979281275843259582154135145932096341124013005361; - uint256 constant deltay1 = 9329143266489561710838657298462699054998672654073505912372427475356483812303; - uint256 constant deltay2 = 19352538485783629217752598362153226097653095487074817367496965073404835257301; + uint256 constant deltax1 = 8610266389851990932549780266586134149581785031836750129783192745835743881162; + uint256 constant deltax2 = 11914472050480540824582186361140933264657529413347420273697484031043056638701; + uint256 constant deltay1 = 3149799631298024789556297036612837456215403664462538830630241467955634306248; + uint256 constant deltay2 = 2165779246565219177630224772189598039109197680240687001378452704570709171641; uint256 constant IC0x = 11512037801303417937523564708199302858178974650252816846079636241344073874076; diff --git a/contracts/hardhat.config.ts b/contracts/hardhat.config.ts index 7dec0d9b6..57f58af14 100644 --- a/contracts/hardhat.config.ts +++ b/contracts/hardhat.config.ts @@ -20,7 +20,7 @@ const config: HardhatUserConfig = { accounts: [process.env.PKEY as string], }, sepolia: { - url: "https://rpc.notadegen.com/eth/sepolia", + url: "https://eth-sepolia.public.blastapi.io", accounts: [process.env.PKEY as string], } },