import { field, smartcontract, state, state, method } from o1js;

/**

* private age verification contract

* the contract will verify if the users age is greater than or equal to the threshold age.

* the contract uses zero-knowledge proofs to keep the users age private.

*/

export class ageverification extends smartcontract {

// state variable to store the verification result (valid or invalid)

@state(field) valid = state<field>();

// method to initialize the state

init() {

super.init();

this.valid.set(field(0)); // default is invalid

}

// method to verify the age

@method async verifyage(age: field, threshold: field) {

// compute age - threshold

const difference = age.sub(threshold);

// use circuit-compatible logic to check if the difference is non-negative

const isvalid = difference.equals(field(0)).or(difference.greaterthanorequal(field(0)))

? field(1)

: field(0);

// set the validity of the verification result

this.valid.set(isvalid);

}

}

登录后复制

import { accountupdate, field, mina, privatekey, publickey } from o1js;

import { ageverification } from ./ageverification; // import the correct contract

let proofsenabled = false;

describe(ageverification, () => {

let deployeraccount: mina.testpublickey,

deployerkey: privatekey,

senderaccount: mina.testpublickey,

senderkey: privatekey,

zkappaddress: publickey,

zkappprivatekey: privatekey,

zkapp: ageverification; // update to use ageverification instead of add

beforeall(async () => {

if (proofsenabled) await ageverification.compile(); // update compile for ageverification

});

beforeeach(async () => {

const local = await mina.localblockchain({ proofsenabled });

mina.setactiveinstance(local);

[deployeraccount, senderaccount] = local.testaccounts;

let feepayer = local.testaccounts[0].key;

deployerkey = deployeraccount.key;

senderkey = senderaccount.key;

zkappprivatekey = privatekey.random();

zkappaddress = zkappprivatekey.topublickey();

zkapp = new ageverification(zkappaddress); // instantiate ageverification contract

});

async function localdeploy() {

const txn = await mina.transaction(deployeraccount, async () => {

accountupdate.fundnewaccount(deployeraccount);

await zkapp.deploy();

});

await txn.prove();

// this tx needs .sign(), because `deploy()` adds an account update that requires signature authorization

await txn.sign([deployerkey, zkappprivatekey]).send();

}

it(generates and deploys the `ageverification` smart contract, async () => {

await localdeploy();

const valid = zkapp.valid.get(); // access the valid state variable

expect(valid).toequal(field(0)); // initially, the contract should set valid to field(0)

});

it(correctly verifies the age in the `ageverification` smart contract, async () => {

await localdeploy();

const age = field(25); // example age value

const threshold = field(18); // example threshold value

// call the verifyage method

const txn = await mina.transaction(senderaccount, async () => {

await zkapp.verifyage(age, threshold); // use the verifyage method

});

await txn.prove();

await txn.sign([senderkey]).send();

const valid = zkapp.valid.get(); // check the validity state after verification

expect(valid).toequal(field(1)); // expected to be valid if age >= threshold

});

});

登录后复制

import fs from fs/promises;

import { Mina, NetworkId, PrivateKey, Field } from o1js;

import { AgeVerification } from ./AgeVerification;

// check command line arg

let deployAlias = process.argv[2];

if (!deployAlias)

throw Error(`Missing <deployAlias> argument.

Usage:

node build/src/interact.js <deployAlias>

`);

Error.stackTraceLimit = 1000;

const DEFAULT_NETWORK_ID = testnet;

// parse config and private key from file

type Config = {

deployAliases: Record<

string,

{

networkId?: string;

url: string;

keyPath: string;

fee: string;

feepayerKeyPath: string;

feepayerAlias: string;

}

>;

};

let configJson: Config = JSON.parse(await fs.readFile(config.json, utf8));

let config = configJson.deployAliases[deployAlias];

let feepayerKeysBase58: { privateKey: string; publicKey: string } = JSON.parse(

await fs.readFile(config.feepayerKeyPath, utf8)

);

let zkAppKeysBase58: { privateKey: string; publicKey: string } = JSON.parse(

await fs.readFile(config.keyPath, utf8)

);

let feepayerKey = PrivateKey.fromBase58(feepayerKeysBase58.privateKey);

let zkAppKey = PrivateKey.fromBase58(zkAppKeysBase58.privateKey);

// set up Mina instance and contract we interact with

const Network = Mina.Network({

// We need to default to the testnet networkId if none is specified for this deploy alias in config.json

// This is to ensure the backward compatibility.

networkId: (config.networkId ?? DEFAULT_NETWORK_ID) as NetworkId,

mina: config.url,

});

const fee = Number(config.fee) * 1e9; // in nanomina (1 billion = 1.0 mina)

Mina.setActiveInstance(Network);

let feepayerAddress = feepayerKey.toPublicKey();

let zkAppAddress = zkAppKey.toPublicKey();

let zkApp = new AgeVerification(zkAppAddress);

let age = Field(25); // Example age

let threshold = Field(18); // Example threshold age

// compile the contract to create prover keys

console.log(compile the contract...);

await AgeVerification.compile();

try {

// call verifyAge() and send transaction

console.log(build transaction and create proof...);

let tx = await Mina.transaction(

{ sender: feepayerAddress, fee },

async () => {

await zkApp.verifyAge(age, threshold); // Replacing update() with verifyAge

}

);

await tx.prove();

console.log(send transaction...);

const sentTx = await tx.sign([feepayerKey]).send();

if (sentTx.status === pending) {

console.log(

Success! Age verification transaction sent.

+

Your smart contract state will be updated +

`

as soon as the transaction is included in a block:` +

`

${getTxnUrl(config.url, sentTx.hash)}`

);

}

} catch (err) {

console.log(err);

}

function getTxnUrl(graphQlUrl: string, txnHash: string | undefined) {

const hostName = new URL(graphQlUrl).hostname;

const txnBroadcastServiceName = hostName

.split(.)

.filter((item) => item === minascan)?.[0];

const networkName = graphQlUrl

.split(/)

.filter((item) => item === mainnet || item === devnet)?.[0];

if (txnBroadcastServiceName && networkName) {

return `https://minascan.io/${networkName}/tx/${txnHash}?type=zk-tx`;

}

return `Transaction hash: ${txnHash}`;

}

登录后复制