探索 Mina 协议：zk 应用程序的实际用例

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

/**
 * private age verification contract
 * the contract will verify if the user's age is greater than or equal to the threshold age.
 * the contract uses zero-knowledge proofs to keep the user's 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(
      '\nSuccess! Age verification transaction sent.\n' +
        '\nYour smart contract state will be updated' +
        `\nas soon as the transaction is included in a block:` +
        `\n${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}`;
}