Meneroka Protokol Mina: Kes Penggunaan Praktikal untuk Aplikasi zk

Zkapps (aplikasi sifar pengetahuan) ialah kontrak pintar protokol mina yang dikuasakan oleh bukti pengetahuan sifar, khususnya zk-Snarks [Argumen Pengetahuan Sifar Tidak Interaktif Ringkas].zkapps menggantikan snapps [Argumen Pengetahuan Bukan Interaktif Pintar Pintar. Aplikasi]. Kontrak pintar ZkApp ​​ditulis menggunakan o1js (pustaka TypeScript). zkApps menjalankan bahagian klien dalam penyemak imbas web pengguna, dan menerbitkan hanya bukti kesahihan kecil yang kemudiannya disahkan oleh nod Mina. Zkapp terdiri daripada kontrak pintar dan UI yang akan saya huraikan selanjutnya dalam bahagian seterusnya.

Permohonan

Saya mencipta zkapp berkenaan pengesahan umur yang mana umur pengguna disahkan tanpa campur tangan kepada data peribadi.

Saya meneruskan dengan memasang pakej zkapp-cli npm yang sebenarnya mencipta templat untuk meneruskan fungsi prover dan fungsi pengesah sebagai sebahagian daripada proses binaan bukti zk

Perlaksanaan

Di bawah ialah pelaksanaan menambah logik tersuai pengesahan. Ia mentakrifkan logik litar untuk zk-SNARK, yang digunakan semasa penjanaan bukti. Fungsi prover sebenar diuruskan oleh perpustakaan o1js dan digunakan apabila kaedah zkApp dilaksanakan di luar rantaian dengan input peribadi.

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);
  }
}

Skrip di bawah ialah suite ujian yang berinteraksi dengan AgeVerification zkApp. Ia menggunakan logik prover semasa txn.prove() dan mengesahkan kelakuan zkApp dengan menyemak keadaan kemas kininya.

Fungsi prover sebenar terletak pada kaedah asas zkApp (verifyAge), dan txn.prove() ialah mekanisme untuk menjana bukti semasa ujian.

Untuk menguji input saya telah mengedit skrip ujian seperti berikut.

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
  });
});

Di bawah ialah keputusan ujian

Saya telah menambah mekanisme prover dalam fail interact.ts yang pada asasnya menghasilkan bukti zk-SNARK dan menyerahkan bukti apabila ia digunakan untuk transaksi dalam blok mina. Walaupun skrip interact.ts menjana bukti, pengesahan dilakukan oleh blok blok Mina apabila transaksi diproses. Ini ialah aspek utama sistem zk-SNARK yang prover menjana bukti bahawa pengesah (rangkaian Mina) menyemak.

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}`;
}

Saya telah menggunakan input untuk umur dan ambang sebagai 25 dan 18.

Memandangkan ujian telah berjaya dilakukan dengan menjalankan ujian npm run. Saya meneruskan penggunaan pada devnet dengan menggunakan zk config

Di mana saya memberikan input berikut:

Sebarkan alias: ujian
Jenis rangkaian: testnet
URL: https://api.minascan.io/node/devnet/v1/graphql
Pembayar yuran: Kunci pembayar yuran baharu
Transaksi: 0.1

URL boleh diambil dari sini:

Kemudian setelah digunakan, saya mendapat respons berikut.

Kontrak digunakan di devnet berikut

Selepas penempatan saya meneruskan dengan UI di mana saya memilih html, css dan js mudah dengan memberikan URL RPC saya dan alamat kontrak yang digunakan dan ini adalah UI terakhir.

Ini menyimpulkan penciptaan zkapp selepas menyepadukan kontrak pintar dengan UI. Selepas membina antara muka pengguna (UI) untuk AgeVerification zkApp, penyepaduan bahagian hadapan dengan kontrak pintar membolehkan pengguna berinteraksi dengan lancar dengan sistem kalis pengetahuan sifar. UI memudahkan penyerahan data umur dan ambang pengguna kepada kontrak, sambil mengekalkan privasi melalui zk-SNARKs. Ini membolehkan pengguna mengesahkan umur mereka tanpa mendedahkan nilai sebenar, memelihara kerahsiaan. Bahagian belakang, menggunakan fungsi prover, menghasilkan bukti, dan blok blok Mina mengesahkannya dengan cekap. Penyelesaian hujung ke hujung ini memastikan pengalaman yang selamat dan mesra pengguna sambil memanfaatkan sepenuhnya ciri privasi dan kebolehskalaan yang ditawarkan oleh seni bina berasaskan zk-SNARK Mina.

Atas ialah kandungan terperinci Meneroka Protokol Mina: Kes Penggunaan Praktikal untuk Aplikasi zk. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!