தனியுரிமை காக்கும் கடன் முடிவு

ஒரு கடன் வழங்குநர் தனது மதிப்பீட்டு மாதிரியை வெளியிடுகிறார். விண்ணப்பதாரர் அதைத் தமது சொந்தத் தரவின் மீது இயக்கி, “ஒப்புதல்” அல்லது “நிராகரிப்பு” என்று கூறும் ஒரு ரசீதைக் கடன் வழங்குநரிடம் ஒப்படைக்கிறார். கடன் வழங்குநர் அந்தத் தரவைப் பார்ப்பதே இல்லை; விண்ணப்பதாரரால் மாதிரியை மாற்றவோ, புனைந்த தரவை அதற்கு உள்ளிடவோ முடியாது.

தனிப்பட்ட உள்ளீடுகளின் மீது பொது நிரலும் பொது அளவுருக்களும் கொண்ட ஒரு கணக்கீட்டை நிரூபிப்பதன் மிகச் சிறிய பயனுள்ள எடுத்துக்காட்டு இது. மாதிரி என்பது முழு எண் கணிதத்தில் அமைந்த இரண்டு அடுக்கு நரம்பியல் வலையமைப்பு. ஒழுங்குமுறையாளர் அல்லது எதிர்த்தரப்பு படிக்க விரும்பும் எந்த விதிக்கும் இதே வடிவம் பொருந்தும்: விலை நிர்ணயச் சூத்திரம், தகுதிச் சோதனை, இடர் வரம்பு.

நான்கு எடுத்துக்காட்டுப் பக்கங்களுக்கும் பொதுவான அமைப்பு எடுத்துக்காட்டு நிரல்கள் பக்கத்தில் உள்ளது.

1. இது எதை நிரூபிக்கிறது

மூன்று தரப்பினர்:

• கடன் வழங்குநர் மாதிரியைப் பொதுப் பகுதியாகக் கொண்டு நிரலை நிறுவுகிறார். நிரல் அடையாளம் அந்த மாதிரியைக் குறிக்கிறது. எவரும் சங்கிலியிலிருந்து எடைகளைத் திரும்பப் படிக்கலாம்.
• ஒரு சான்றளிப்பாளருக்கு (கடன் தகவல் நிறுவனம், வங்கி, பணி வழங்குநர்) விண்ணப்பதாரரின் தரவு தெரியும். அது விண்ணப்பதாரருக்கு அம்ச மதிப்புகளையும், சீரற்ற 16-பைட் சால்ட்டையும், உறுதிமொழி SHA-256(salt ‖ features) மீதான தனது கையொப்பத்தையும் வழங்குகிறது.
• விண்ணப்பதாரர் சால்ட்டையும் அம்சங்களையும் தனிப்பட்ட உள்ளீடாகக் கொண்டு நிரலை அழைக்கிறார்.

இந்த அழைப்பு நிரூபிப்பவை:

1. ஒவ்வொரு அம்சமும் மாதிரி அதற்கென அறிவிக்கும் வரம்புக்குள் உள்ளது;
2. அந்த அம்சங்களின் மீது மாதிரி கணக்கிடும் மதிப்பெண் வரம்பு மதிப்புக்குச் சமமாகவோ அதற்கு மேலாகவோ (நிலை 1) அல்லது அதற்குக் கீழாகவோ (நிலை 2) உள்ளது;
3. வெளியிடப்பட்ட உறுதிமொழி, சால்ட்டும் அதே அம்சங்களும் சேர்ந்ததன் SHA-256 ஆகும்.

கடன் வழங்குநர் ரசீதின் நிரல் அடையாளத்தையும், அதன் நிலையையும், உறுதிமொழி சான்றளிப்பாளர் கையொப்பமிட்ட ஒன்றுதானா என்பதையும் சரிபார்க்கிறார். விண்ணப்பதாரரைப் பற்றி அவர் அறிவது ஒரே ஒரு பிட் மட்டுமே.

தனிப்பட்ட உள்ளீடுகள் தாமாக உலகைப் பற்றி எதையும் நிரூபிப்பதில்லை. மூன்றாம் அம்சம் இல்லையெனில் விண்ணப்பதாரர் எந்த எண்களையும் தட்டச்சு செய்துவிடலாம். நிரூபணத்தில் உள்ள எண்களை, யாரோ ஒருவர் உத்தரவாதம் அளித்த எண்களுடன் இணைப்பது உறுதிமொழிதான். கையொப்பத்தையே கடன் வழங்குநர் சங்கிலிக்கு வெளியே சரிபார்க்கிறார்: Dilithium அல்லது ECDSA சரிபார்ப்பு ஓர் அழைப்பின் வரவுசெலவு வரம்புக்குள் அடங்காது; உறுதிமொழி பொதுவானது என்பதால் அது நிரூபணத்துக்குள் இருக்க வேண்டிய தேவையும் இல்லை.

2. இடைமுகம்

ஒவ்வொரு பொதுச் சொல்லும் ஒரு i32; அது தனது இரண்டின் நிரப்பு வடிவ u32 ஆகச் சேமிக்கப்படுகிறது.

நிலை 1 அல்லது 2 உடன் மட்டுமே உறுதிமொழி வெளியிடப்படுகிறது. வரம்புக்கு வெளியே உள்ள உள்ளீடு, எதுவும் ஹாஷ் செய்யப்படுவதற்கு முன்பே நிறுத்தப்படுகிறது.

3. கணிதம்

மாதிரி முழு எண்களை மட்டுமே பயன்படுத்துகிறது. இயந்திரத்தில் மிதவைப் புள்ளி இல்லை; மேலும் சரிபார்ப்பாளர் மதிப்பெண்ணைத் துல்லியமாக மீண்டும் கணக்கிட முடிய வேண்டும், மிதவைப் புள்ளியோ வெவ்வேறு இயந்திரங்களுக்கு இடையே அதற்கு உத்தரவாதம் தருவதில்லை.

hidden[j] = max( (b1[j] + Σ w1[j][i] · x[i]) >> s , 0 )      for each hidden unit j
score     = (b2 + Σ w2[j] · hidden[j]) >> s
approved  = score >= threshold

எடைகள் s பின்னப் பிட்களுடன் கூடிய நிலைப் புள்ளி எண்கள்: s = 8 எனில், 256 என்ற எடை 1.0 ஐக் குறிக்கும். கூட்டுத்தொகைகள் i64 ஆகும்; ஒவ்வொரு பெருக்கலும் கூட்டலும் சரிபார்க்கப்படுவதால், வழிந்தோடும் அளவுக்குப் பெரிய எடைகள் கொண்ட மாதிரி தவறான மதிப்பெண்ணுக்குப் பதிலாக நிலை 4 ஐத் தருகிறது. Rust இல் எதிர்ம i64 மீதான >> கழித்தல் முடிவிலியை நோக்கி முழுமையாக்குகிறது; Python இன் >> உம் அதையே செய்கிறது; அதனால்தான் பத்து வரி Python செயல்பாடு ஒன்றை மேற்கோள் செயலாக்கமாகக் கொள்ள முடிகிறது.

செயல்விளக்க மாதிரியில் எட்டு அம்சங்களும் நான்கு மறைநிலை அலகுகளும் உள்ளன. அதன் எடைகள் இந்தப் பக்கத்துக்காகக் கையால் எழுதப்பட்டவை. இது பயிற்றுவிக்கப்பட்ட மாதிரி அல்ல; கடன் பற்றி இது எதையும் கூறவில்லை.

{
  "shift": 8,
  "threshold": 600,
  "features": [
    {"name": "age_years", "min": 18, "max": 120},
    {"name": "income_thousands", "min": 0, "max": 100000},
    {"name": "debt_to_income_pct", "min": 0, "max": 1000},
    {"name": "on_time_payments_pct", "min": 0, "max": 100},
    {"name": "utilisation_pct", "min": 0, "max": 100},
    {"name": "history_years", "min": 0, "max": 100},
    {"name": "inquiries_12m", "min": 0, "max": 100},
    {"name": "delinquencies", "min": 0, "max": 100}
  ],
  "w1": [
    [  64,   96,  -512,  1536,  -640,  1024, -2048, -8192],
    [   0,  256, -1024,     0,     0,     0,     0,     0],
    [   0,    0,     0,  2560, -1280,     0, -4096, -16384],
    [ 128,    0,     0,     0,     0,  2048,     0,     0]
  ],
  "b1": [25600, 12800, -128000, 0],
  "w2": [160, 96, 224, 128],
  "b2": 76800
}

4. விருந்தினர் நிரல்

my-guests/score/src/main.rs, முழுமையாக:

#![no_std]
#![no_main]

use guest_sdk::{halt, read_input, read_public, sha256_compress, write_output};

const MAX_FEATURES: usize = 16;
const MAX_HIDDEN: usize = 16;

const APPROVED: u32 = 1;
const DECLINED: u32 = 2;
const OUT_OF_RANGE: u32 = 3;
const BAD_MODEL: u32 = 4;

/// SHA-256's initial state (FIPS 180-4 §5.3.3).
const IV: [u32; 8] = [
    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
];

/// SHA-256 of `words`, each word taken as four big-endian bytes. The message is whole words,
/// so the padding is whole words too: `0x80000000`, zeros, then the bit length in the last
/// word of a block (the length's high word is always zero here).
fn sha256_words(words: &[u32]) -> [u32; 8] {
    let mut buf = [0u32; 24];
    buf[16..].copy_from_slice(&IV);
    let mut fill = 0;
    for &w in words {
        buf[fill] = w;
        fill += 1;
        if fill == 16 {
            sha256_compress(&mut buf);
            fill = 0;
        }
    }
    buf[fill] = 0x8000_0000;
    fill += 1;
    if fill > 14 {
        buf[fill..16].fill(0);
        sha256_compress(&mut buf);
        fill = 0;
    }
    buf[fill..15].fill(0);
    buf[15] = 32 * words.len() as u32;
    sha256_compress(&mut buf);
    let mut out = [0u32; 8];
    out.copy_from_slice(&buf[16..]);
    out
}

/// `weight · x`, added to `acc`; `None` when it does not fit an i64.
fn mul_add(acc: i64, weight: u32, x: i64) -> Option<i64> {
    acc.checked_add((weight as i32 as i64).checked_mul(x)?)
}

/// Runs the model in the public segment over the private features.
fn score(features: &[i32], hidden: usize, shift: u32) -> Option<i64> {
    let n = features.len();
    // The public segment after the header and the feature ranges:
    // hidden × n first-layer weights, hidden biases, hidden second-layer weights, one bias.
    let w1 = 4 + 2 * n;
    let b1 = w1 + hidden * n;
    let w2 = b1 + hidden;
    let b2 = w2 + hidden;

    let mut out = read_public(b2 as u32) as i32 as i64;
    for j in 0..hidden {
        let mut acc = read_public((b1 + j) as u32) as i32 as i64;
        for (i, &x) in features.iter().enumerate() {
            acc = mul_add(acc, read_public((w1 + j * n + i) as u32), x as i64)?;
        }
        // Fixed point: drop the fractional bits, then ReLU.
        let h = (acc >> shift).max(0);
        out = mul_add(out, read_public((w2 + j) as u32), h)?;
    }
    Some(out >> shift)
}

/// Public segment, fixed at deploy (every value an i32):
///   [features n, hidden units, threshold, fractional bits,
///    n × (min, max), hidden × n weights, hidden biases, hidden weights, bias]
/// Private input: [salt (4 words), n features].
/// Outputs: [status, 0, commitment (first 5 words), 0], where
/// commitment = SHA-256(salt ‖ features), every word big-endian.
#[no_mangle]
pub extern "C" fn main() -> ! {
    let n = read_public(0) as usize;
    let hidden = read_public(1) as usize;
    let threshold = read_public(2) as i32 as i64;
    let shift = read_public(3);
    if n == 0 || n > MAX_FEATURES || hidden == 0 || hidden > MAX_HIDDEN || shift > 31 {
        write_output(0, BAD_MODEL);
        halt();
    }

    // The committed message: the salt, then the features, in input order.
    let mut message = [0u32; 4 + MAX_FEATURES];
    for (i, w) in message.iter_mut().enumerate().take(4 + n) {
        *w = read_input(i as u32);
    }
    let mut features = [0i32; MAX_FEATURES];
    let mut in_range = true;
    for i in 0..n {
        let x = message[4 + i] as i32;
        let min = read_public(4 + 2 * i as u32) as i32;
        let max = read_public(5 + 2 * i as u32) as i32;
        in_range &= min <= x && x <= max;
        features[i] = x;
    }
    if !in_range {
        write_output(0, OUT_OF_RANGE);
        halt();
    }

    let status = match score(&features[..n], hidden, shift) {
        Some(s) if s >= threshold => APPROVED,
        Some(_) => DECLINED,
        None => BAD_MODEL,
    };
    let commitment = sha256_words(&message[..4 + n]);

    write_output(0, status);
    for k in 0..5 {
        write_output(2 + k as u32, commitment[k]);
    }
    halt();
}

மாதிரி என்பது தரவு, நிரல் குறியீடு அல்ல. எடைகள் read_public மூலம் படிக்கப்படுவதால், நிறுவப்பட்ட ஒரே படிமம் 16 அம்சங்களும் 16 மறைநிலை அலகுகளும் வரை கொண்ட எந்த மாதிரிக்கும் சேவை செய்கிறது. மாதிரியை மாற்றுவது என்பது அதே குறியீட்டைப் புதிய பொதுப் பகுதியுடன் மீண்டும் நிறுவுவதாகும்; அதற்குப் புதிய நிரல் அடையாளம் கிடைக்கும். விண்ணப்பதாரருக்குத் தெரியாமல் கடன் வழங்குநர் எடைகளை மாற்ற முடியாது; விண்ணப்பதாரரும் தமக்குச் சாதகமான மாதிரியைத் தேர்ந்தெடுக்க முடியாது: ரசீது நிரல் அடையாளத்தைக் குறிப்பிடுகிறது, அந்த அடையாளம் எடைகளைப் பிணைக்கிறது.

வரம்புகள் மாதிரியின் ஒரு பகுதி. அவை இல்லாவிட்டாலும் விண்ணப்பதாரர் ஒரு மதிப்பைப் பற்றிப் பொய் சொல்ல முடியாது (உறுதிமொழி அதைத் தடுக்கிறது); ஆனால் சான்றளிப்பாளர் −5 வயது போன்ற பொருளற்ற மதிப்புக்குக் கையொப்பமிடக்கூடும், எதிர்ம எடை கொண்ட மாதிரி அதற்கு வெகுமதி அளிக்கும். இந்தச் சோதனை கணிதத்துக்கும் எல்லை வகுக்கிறது.

சால்ட் இரண்டு பணிகளைச் செய்கிறது. அது உறுதிமொழியை ஊகிக்க முடியாததாக்குகிறது: எட்டுச் சிறிய முழு எண்களில் என்ட்ரோபி குறைவு; சால்ட் இல்லையெனில் எவரும் சாத்தியமான விண்ணப்பதாரர்களை ஹாஷ் செய்து ஒப்பிட்டுவிடலாம். மேலும் அது 128 சீரற்ற பிட்களைக் கணக்கீட்டின் வழியே செலுத்துகிறது. கட்டுப்பாட்டுத் தொகுப்பு 7 நிரூபணத்தின் பஸ் கூட்டுத்தொகைகளை மறைப்பதற்கு முன்பு, சில சிறிய தனிப்பட்ட சொற்கள் மீதான அழைப்பை நிரூபணத்திலிருந்தே முரட்டு விசைத் தேடல் மூலம் கண்டறிய முடிந்தது; அத்தகைய நிரல்கள் சீரற்ற சொற்களைப் படிக்க வேண்டும் என்று fullnode இன் குறிப்புகள் அறிவுறுத்தின. சங்கிலி 18 கட்டுப்பாட்டுத் தொகுப்பு 8 ஐ இயக்குகிறது; அதில் இது சரிசெய்யப்பட்டுவிட்டது. ஆனாலும் சால்ட்டுக்கு ஆகும் செலவு நான்கு உள்ளீட்டுச் சொற்கள் மட்டுமே, அது இந்தக் கேள்வியையே நீக்கிவிடுகிறது.

5. புரவலர் பக்கம்

score.py Python இன் தரநிலை நூலகத்தை மட்டுமே பயன்படுத்துகிறது:

score.py setup   <model.json>                            writes public.txt
score.py witness <model.json> <salt: 32 hex> <x0> <x1> …  prints the private words;
                                                        stderr: the score, the decision, the commitment
score.py commit  <salt: 32 hex> <x0> <x1> …              prints the commitment alone

மேற்கோள் மதிப்பீட்டாளரும் உறுதிமொழியும், முழுமையாக:

def score(m, x):
    """The guest's arithmetic exactly: integers, a floor shift after each layer, ReLU between."""
    out = m["b2"]
    for row, b, w2 in zip(m["w1"], m["b1"], m["w2"]):
        h = max((b + sum(w * xi for w, xi in zip(row, x))) >> m["shift"], 0)
        out += w2 * h
    return out >> m["shift"]

def commitment(salt: bytes, x):
    return hashlib.sha256(salt + b"".join(struct.pack(">i", xi) for xi in x)).digest()

$ cd my-guests/score
$ python3 score.py setup model.json
wrote public.txt (61 words)
$ cat public.txt
8 4 600 8 18 120 0 100000 0 1000 0 100 0 100 0 100 0 100 0 100 64 96 4294966784 1536 4294966656 1024 4294965248 4294959104 0 256 4294966272 0 0 0 0 0 0 0 0 2560 4294966016 0 4294963200 4294950912 128 0 0 0 0 2048 0 0 25600 12800 4294839296 0 160 96 224 128 76800

பெரிய எண்கள் எதிர்ம எடைகளாகும்: 4294966784 என்பது −512.

விருந்தினர் நிரல் இந்த மேற்கோளுக்கு எதிராக 300 சீரற்ற விண்ணப்பதாரர்கள் மீது, முடிவையும் உறுதிமொழியின் ஐந்து சொற்களையும் ஒப்பிட்டுச் சோதிக்கப்பட்டது; 599, 600 மதிப்பெண்கள் பெறும் விண்ணப்பதாரர்கள் மீதும் சோதிக்கப்பட்டது. ஒவ்வொன்றிலும் இரண்டும் ஒத்துப்போகின்றன.

6. உருவாக்கமும் இயக்கமும்

$ rand-guest build my-guests/score --max-words 65535
462 words against a cap of 65535 (fits); 0 ecall(s) with a non-static a7
OK
wrote my-guests/score/image.bin and its .sha256 (462 words, hc c63d7b15a165a11d007ce48bc37563b71f77fcc4991ffe0182c8cf4c77b6e7b5, program id ce8d234faf737c24bdd2826933ac843973c140c53e76fbb2cccaef3073da9818)

41 வயது, 85 ஆயிரம் வருமானம், வருமானத்துக்கு 28% கடன், 97% கொடுப்பனவுகள் உரிய நேரத்தில், 22% பயன்பாடு, 12 ஆண்டு வரலாறு, ஒரு விசாரணை, நிலுவைத் தவறுகள் இல்லை என்ற விவரங்கள் கொண்ட விண்ணப்பதாரர்:

$ python3 score.py witness model.json 00112233445566778899aabbccddeeff 41 85 28 97 22 12 1 0 > witness.txt
score 1075 approved
commitment 9430c3818f5966f8dd33f78e05a7d079355191e6
$ cat witness.txt
1122867 1146447479 2291772091 3437096703 41 85 28 97 22 12 1 0
$ rand-guest run image.bin --public $(cat public.txt) --input $(cat witness.txt) --tier 14
out[0] = 1
out[1] = 0
out[2] = 2486223745
out[3] = 2405000952
out[4] = 3711170446
out[5] = 94883961
out[6] = 894538214
out[7] = 0
cycles 1810
tier 12
tier 14: fits (cycles 1946 of 16383, Poseidon2 permutations 136 of 2048)

2486223745 என்பது 0x9430c381, உறுதிமொழியின் முதல் நான்கு பைட்டுகள். மதிப்பெண் 1075 வெளியீடுகளில் எங்கும் தோன்றுவதில்லை.

இரண்டாவது விண்ணப்பதாரர் (23, 31, 55, 82, 91, 2, 6, 2, வேறொரு சால்ட்டுடன்) 417 மதிப்பெண் பெற்று, தமது சொந்த உறுதிமொழியுடன் out[0] = 2 ஐத் தருகிறார், அதே 1,810 சுழற்சிகளில். முதல் விண்ணப்பதாரரின் வயதை 17 ஆக மாற்றினால் out[0] = 3 கிடைக்கிறது, உறுதிமொழி எதுவும் இல்லை.

7. வரவுசெலவு

நான்கு நிரல்களில் இதுவே மிக மலிவானது. முன்னோக்கிய கடப்பில் 36 பெருக்கல்கள் உள்ளன. நிரலின் வரம்புகளில் உள்ள மாதிரி, அதாவது 16 அம்சங்களும் 16 மறைநிலை அலகுகளும், 272 பெருக்கல்களும் 325 சொல் பொதுப் பகுதியும் கொண்டது. எமுலேட்டரில் அது 7,900 சுழற்சிகள் என அளவிடப்படுகிறது, அடுக்கு 14 இன் ஏறத்தாழ பாதி.

இயக்கம் தரவைச் சார்ந்திருப்பதில்லை: ஒப்புதல் பெற்றவர், நிராகரிக்கப்பட்டவர் என்ற வேறுபாடின்றி, 200 சீரற்ற விண்ணப்பதாரர்கள் ஒவ்வொருவருக்கும் சரியாக 1,810 சுழற்சிகள் ஆயின. ஓர் அழைப்பு அறிவிக்கும் gas வரம்பு பொதுவானது, அது இயக்கத்தின் gas இலிருந்து முழுமையாக்கப்படுகிறது; எனவே சுழற்சி எண்ணிக்கை உள்ளீடுகளைப் பின்தொடரும் நிரல் அவற்றில் சிறிதளவைக் கசியவிடும். இந்த நிரலுக்கு அவ்வழியில் கசியவிட எதுவும் இல்லை.

சங்கிலி 18 முதல், வாலட் இயக்கத்தின் துல்லியமான gas ஐயும் அது அறிவிக்கும் வரம்பையும் அச்சிடுகிறது:

gas: 2011 (declaring 2048, tier 12)

ஒவ்வொன்றும் 1 gas வீதம் 1,948 வரிசைகள், கூடுதலாக ஒரு சுருக்கத்துக்கு 63.

8. நிறுவுதல்

மாதிரியின் 61 சொற்களுக்கும் குறியீட்டுச் சொற்களைப் போலவே கட்டணம் செலுத்தப்படுகிறது: 0.001 + 0.0001 × (462 + 61) = 0.0533 RAND.

$ rand fee deploy 462 --public-words 61
0.0533 RAND
$ rand program deploy image.bin --public public.txt
program id: 7bbec14289f4446231b3a9a5ac18cb0613a373ca8a14fe4f046f3fde7ae6c73c (462 words, hc 157b3dc61da165a18be47c00b76375c3c4fc771f01fe1f994ccfc882b5e7b677, public input 61 words, digest a08a7c691c45babeb39e953930d4d7174662b7b8adcc2d0f4e6c193d362d6668)
proving the spend authorisation on this machine (tier 10; seconds)…
authorisation proved in 7.4s: tier 10, 1364940 bytes
proving the bundle (tier 14; about a minute and a half on a laptop)…
proved in 123.5s: tier 14, 1497319 bytes
submitted deploy d47a9323ea53bfafc3faa36d004416d374bf3c2a48971d87e346be426b0caf14
  0 RAND out, 59.7229 RAND change, fee 0.0533 RAND, anchored at height 98062, proved in 123.5s (bundle) + 7.4s (auth)

9. அழைப்பு

$ rand call 7bbec14289f4446231b3a9a5ac18cb0613a373ca8a14fe4f046f3fde7ae6c73c \
    $(sed 's/[0-9][0-9]*/--input &/g' witness.txt)

proving the call locally (12 inputs stay private, over the program's 61-word public input)…
gas: 2011 (declaring 2048, tier 12)
fee 0.005673037 RAND (incl. two price steps of headroom)
proved in 30.6s: tier 12, 1838256 bytes, outputs [1, 0, 2486223745, 2405000952, 3711170446, 94883961, 894538214, 0]
proving the spend authorisation on this machine (tier 10; seconds)…
authorisation proved in 6.8s: tier 10, 1369611 bytes
proving the bundle (tier 14; about a minute and a half on a laptop)…
proved in 124.3s: tier 14, 1499112 bytes
submitted call 454c1b9eb1e159e682d4ff26b71f77d8a950b813533d91a89293dd432fdcf6f7
  0 RAND out, 59.696058627 RAND change, fee 0.005673037 RAND, anchored at height 98832, proved in 124.3s (bundle) + 6.8s (auth)
{
  "h_in": "ef80c744a8cdea62b56e334baaf7372e4a2e6c8282d37aa8ae96b4f039ec1a22",
  "h_pub": "a08a7c691c45babeb39e953930d4d7174662b7b8adcc2d0f4e6c193d362d6668",
  "height": 98993,
  "index": 0,
  "outputs": [
    1,
    0,
    2486223745,
    2405000952,
    3711170446,
    94883961,
    894538214,
    0
  ],
  "program": "7bbec14289f4446231b3a9a5ac18cb0613a373ca8a14fe4f046f3fde7ae6c73c",
  "tier": 12,
  "tx": "454c1b9eb1e159e682d4ff26b71f77d8a950b813533d91a89293dd432fdcf6f7"
}
input transcript published; open it with `rand open-call 454c1b9eb1e159e682d4ff26b71f77d8a950b813533d91a89293dd432fdcf6f7`

நிலை 1, உறுதிமொழி பதினறும எண்முறையில் 9430c381 8f5966f8 dd33f78e 05a7d079 355191e6. h_pub என்பது மாதிரியின் 61 சொற்களின் செரிமானம். அம்சங்கள், சால்ட், மதிப்பெண் எதுவும் பரிவர்த்தனையில் இல்லை.

Apple Silicon மடிக்கணினியில் அழைப்புக்கு மூன்று நிமிடங்களுக்குச் சற்று அதிகமாக ஆனது: அழைப்பு நிரூபணத்துக்கு 31 வி, செலவு அங்கீகாரத்துக்கு 7 வி, தொகுப்புக்கு 124 வி, உச்ச நினைவகம் 6.2 GB. நிரூபணம் 1,838,256 பைட்டுகள்.

10. நீங்களே சரிபார்க்கவும்

ரசீதும் சான்றளிப்பாளர் கையொப்பமிட்ட உறுதிமொழியும் மட்டுமே கொண்டு, கடன் வழங்குநர் தரப்பில்:

1. மாதிரி. நிரல் அடையாளத்தின் மீது rand_getProgramPublic 61 சொற்களைத் திருப்பித் தருகிறது. அவற்றை வெளியிடப்பட்ட model.json உடன் ஒப்பிடவும் (score.py setup அவற்றை மீண்டும் உருவாக்குகிறது).
2. குறியீடு. அதே circuits commit இல் my-guests/score ஐ மீண்டும் உருவாக்கி, hc ஐ நிரலின் code_hash உடன் ஒப்பிடவும்.
3. ரசீது. program என்பது மாதிரியின் அடையாளம், வெளியீடு 0 என்பது 1, இடம் 7 என்பது 3735928559 அல்ல.
4. உறுதிமொழி. பதினறும எண்முறையில் அச்சிடப்பட்ட வெளியீடுகள் 2 முதல் 6 வரை, சான்றளிப்பாளர் கையொப்பமிட்ட உறுதிமொழியின் முதல் 20 பைட்டுகள் ஆகும்:

$ python3 score.py commit 00112233445566778899aabbccddeeff 41 85 28 97 22 12 1 0
9430c3818f5966f8dd33f78e05a7d079355191e6

மறுப்பும் ஒரு ரசீதுதான். இரண்டாவது விண்ணப்பதாரரின் அழைப்பு, chain 18 இல் 119e7834…1b3b (chain 20 இல் c8a60183…9f73 ஆக மீண்டும் செய்யப்பட்டது, அதுவும் மறுக்கிறது), அதே முறையில் நிரூபிக்கப்பட்டு உறுதிப்படுத்தப்பட்டது:

$ python3 score.py witness model.json 0f1e2d3c4b5a69788796a5b4c3d2e1f0 23 31 55 82 91 2 6 2 > witness.txt
score 417 declined
commitment 0313ea462178574c49a10fe7ea1d84207652e1a3
$ rand call 7bbec14289f4446231b3a9a5ac18cb0613a373ca8a14fe4f046f3fde7ae6c73c \
    $(sed 's/[0-9][0-9]*/--input &/g' witness.txt)
…
gas: 2011 (declaring 2048, tier 12)
proved in 26.1s: tier 12, 1836624 bytes, outputs [2, 0, 51636806, 561534796, 1235292135, 3927802912, 1985143203, 0]
…
submitted call 119e7834033edd19bba8e10c1a764e8bdbc0b1c8415a42f041faa392c6411b3b

நிலை 2, மேலும் 51636806 என்பது 0x0313ea46. கேஸ், அறிவிக்கப்பட்ட வரம்பு, அடுக்கு ஆகியவை ஒப்புதல் பெற்ற அழைப்பினுடையவற்றைப் போலவே உள்ளன. எனவே சங்கிலியில் இவ்விரண்டும் நிலைச் சொல்லிலும் உறுதிப்பாட்டிலும் மட்டுமே வேறுபடுகின்றன, வேறு எங்கும் இல்லை. மறுப்பை வெளியிட விண்ணப்பதாரருக்கு எந்தக் காரணமும் இல்லை. ஆனால் எந்த முடிவாக இருந்தாலும் கடன் வழங்குநர் ரசீதைக் கேட்கலாம். மறுக்கப்பட்ட விண்ணப்பதாரரால் ஒப்புதல் பெற்ற ரசீதை உருவாக்க முடியாது.

நிரூபணம் உங்களுக்குத் தராதவை

• உண்மையான தரவு. உறுதிப்படுத்தப்பட்ட மதிப்புகளின் மீது மாதிரி இயங்கியது என்பதை நிரூபணம் காட்டுகிறது. அந்த மதிப்புகள் உண்மையா என்பது சான்றளிப்பவரின் கூற்று மட்டுமே. அதற்குக் கடன் வழங்குநர் சான்றளிப்பவரின் கையொப்பத்தை நம்ப வேண்டும்.
• இணைக்க முடியாத விண்ணப்பதாரர். உறுதிப்பாடு ஒரு நிலையான அடையாளங்காட்டி. சான்றளிப்பவர் அதை அடையாளம் காண முடியும். ஒரே உறுதிப்பாட்டைக் கொண்ட இரண்டு ரசீதுகள் ஒரே விண்ணப்பதாரரையும் ஒரே தரவையும் குறிக்கின்றன. ஒவ்வொரு விண்ணப்பத்துக்கும் சான்றளிப்பவர் வழங்கும் புதிய உப்பு மதிப்பு இரண்டாவது சிக்கலைத் தீர்க்கிறது, முதலாவதைத் தீர்ப்பதில்லை.
• இரகசியமான மாதிரி. எடைகள் பொதுவில் உள்ளன. மக்கள் படித்துப் புரிந்துகொள்ள வேண்டிய விதிக்கு இதுவே நோக்கம். ஆனால் தன் மாதிரியை வர்த்தக இரகசியமாகக் கருதும் கடன் வழங்குநருக்கு இது ஒரு குறைபாடு. தேர்ச்சி பெறக்கூடிய உள்ளீடுகளை விண்ணப்பதாரர் தேடவும் முடியும். ஆனால் அவற்றின் மீது சான்றளிப்பவரின் கையொப்பம் இல்லாமல் அவற்றைப் பயன்படுத்த முடியாது.
• நேர்மையற்ற சான்றளிப்பவரின் ஆய்வுத் தேடலிலிருந்து பாதுகாப்பு. அம்சங்களை அறிந்த எவரும் பொது மாதிரியைத் தாமே இயக்க முடியும். இங்குள்ள தனியுரிமை, கடன் வழங்குநருக்கும் பொதுமக்களுக்கும் எதிராக விண்ணப்பதாரருக்கு உரியது. தரவை வழங்கிய தரப்புக்கு எதிராக அல்ல.
• பெரிய மாதிரி. பதினாறு அம்சங்களும் பதினாறு மறைநிலை அலகுகளும் கொண்டது ஒரு மதிப்பெண் அட்டை, ஆழ் நரம்பியல் வலையமைப்பு அல்ல. ஓர் அழைப்பு அடுக்கு 14 இல், அதாவது சுமார் பதினாறாயிரம் சுழற்சிகளில், வரம்பிடப்பட்டுள்ளது.