د مکلفیتونو ثبوت

یو امانتدار هر پیرودونکي ته یو بیلانس پوروړی دی. دا پروګرام ثابتوي چې د بیلانسونو مجموعه د هغې زېرمې له رقم څخه نه زیاتېږي چې امانتدار خپره کړې ده، پرته له دې چې یو بیلانس هم یا مجموعه خپره شي. هر پیرودونکی کولای شي د Python په څو کرښو او پرته له کومې ځانګړې وسیلې وګوري چې د هغه خپل بیلانس حساب شوی دی.

بېلګه پروګرامونه هغه چمتووالی لري چې څلور واړه بېلګه پاڼې یې سره شریکوي.

1. دا څه ثابتوي

امانتدار یوه Merkle د مجموعې ونه جوړوي. یوه پاڼه یو حساب دی: د پیرودونکي د پېژند او بیلانس هش، او بیلانس یې تر څنګ. یوه غوټه د هغې د دوو ماشومانو او د هغوی د مجموعو هش دی، او د دواړو مجموعو حاصل یې تر څنګ. له همدې امله رېښه د هغو ټولو بیلانسونو مجموعه لري چې لاندې یې دي.

ونه د پروګرام دننه جوړېږي، د حسابونو له خصوصي لېست څخه. غوښتنه دا ثابتوي:

1. هغه رېښه چې په رسید کې خپرېږي، د هغو حسابونو پر سر د مجموعې د ونې رېښه ده چې امانتدار وړاندې کړي؛
2. په هغې کې هره مجموعه د هغو دوو ریښتینې مجموعه ده چې لاندې یې دي، او هېڅ سرریزی نشته؛
3. په رېښه کې مجموعه د زېرمې له هغه رقم څخه زیاته نه ده چې د ګمارنې پر مهال ټاکل شوی.

دوهمه نقطه هغه څه دي چې د مجموعې یوه ونه چې بې ثبوته خپرېږي یې نشي ورکولای. پر لوڅې مجموعې ونې پېژندل شوی برید دا دی چې امانتدار د یوې مورنۍ غوټې مجموعه د هغې د ماشومانو له مجموعې کمه ولیکي، چې هېڅ پیرودونکی یې له یوې لارې نشي موندلای. دلته مجموعې پروګرام حسابوي، او د بل هر ډول حساب ثبوت شتون نه لري.

هغه څه چې ثبوت یې نه پوښي بشپړتیا ده: امانتدار ټاکي چې کوم حسابونه دننه شي. دا تشه پیرودونکي ډکوي. هر یو یې ګوري چې یوه پاڼه د هغه له پېژند او بیلانس سره د خپرې شوې رېښې لاندې شته (اووم برخه). هغه حساب چې پرېښودل شوی وي، د خپل څښتن له خوا موندل کېږي.

2. انٹرفېس

د زېرمې رقم په عامه برخه کې دی نه په وتو کې، او دا دوه لاملونه لري. ځای نشته: حالت، شمېر او یوه 160-بټه رېښه ټول ځایونه ډکوي. او دا ادعا مخکې له دې بیانوي چې ثبوت شتون ولري: د پروګرام ګمارل دا خپروي چې «د R زېرمې، لحظه‌يي انځور S»، او بیا غوښتنه یا ثابتوي چې بیلانسونه د R لاندې ځاییږي یا حالت 2 بېرته ورکوي.

هشونه، په دقیق ډول:

leaf  = SHA-256( be32(0) ‖ id (16 bytes) ‖ be64(balance) )                                  28 bytes
node  = SHA-256( be32(1) ‖ left hash ‖ be64(left sum) ‖ right hash ‖ be64(right sum) )      84 bytes
empty = leaf with id 0 and balance 0

ونه تل 32 پاڼې لري. حسابونه یې له کیڼ لوري ډکوي او تشې پاڼې پاتې برخه ډکوي. مخکښ 0 او 1 نه پرېږدي چې یوه پاڼه کله هم د غوټې په توګه ولوستل شي.

د بایټونو ترتیب. SHA-256 په ټوله کې big-endian دی، او د SHA256 syscall خپل 64-بایټه بلاک د شپاړسو big-endian کلمو په توګه اخلي. نو دا پروګرام پېژند د څلورو big-endian کلمو په توګه لولي او رېښه د big-endian کلمو په توګه خپروي: دوهم وتون چې په hex کې چاپ شي، د رېښې لومړۍ اته hex رقمونه دي. دا د Keccak پروګرام برعکس دود دی، ځکه دواړه هشونه پر مخالفو بایټ ترتیبونو تعریف شوي دي.

3. ګیسټ

my-guests/solvency/src/main.rs، بشپړ:

#![no_std]
#![no_main]

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

/// The tree always has 32 leaves. Accounts fill it from the left; the rest are empty leaves.
const LEAVES: usize = 32;

const SOLVENT: u32 = 1;
const INSOLVENT: u32 = 2;
const TOO_MANY: u32 = 3;
const OVERFLOW: u32 = 4;

const LEAF_TAG: u32 = 0;
const NODE_TAG: u32 = 1;

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

#[derive(Clone, Copy)]
struct Node {
    hash: [u32; 8],
    sum: u64,
}

/// SHA-256 of the 28 bytes `be32(0) ‖ id (16 bytes) ‖ be64(balance)`. The message, its `0x80`
/// terminator and its bit length fit one 64-byte block, so a leaf is one compression.
fn leaf(id: &[u32; 4], balance: u64) -> Node {
    let mut buf = [0u32; 24];
    buf[0] = LEAF_TAG;
    buf[1..5].copy_from_slice(id);
    buf[5] = (balance >> 32) as u32;
    buf[6] = balance as u32;
    buf[7] = 0x8000_0000;
    buf[15] = 28 * 8;
    buf[16..].copy_from_slice(&IV);
    sha256_compress(&mut buf);
    let mut hash = [0u32; 8];
    hash.copy_from_slice(&buf[16..]);
    Node { hash, sum: balance }
}

/// SHA-256 of the 84 bytes `be32(1) ‖ left hash ‖ be64(left sum) ‖ right hash ‖ be64(right sum)`:
/// two compressions. `None` when the two sums do not fit a u64.
fn parent(l: &Node, r: &Node) -> Option<Node> {
    let sum = l.sum.checked_add(r.sum)?;
    let mut buf = [0u32; 24];
    buf[16..].copy_from_slice(&IV);
    // Block 1: words 0..16 of the message.
    buf[0] = NODE_TAG;
    buf[1..9].copy_from_slice(&l.hash);
    buf[9] = (l.sum >> 32) as u32;
    buf[10] = l.sum as u32;
    buf[11..16].copy_from_slice(&r.hash[..5]);
    sha256_compress(&mut buf);
    // Block 2: the last five words, the terminator, zeros, the bit length.
    buf[..3].copy_from_slice(&r.hash[5..]);
    buf[3] = (r.sum >> 32) as u32;
    buf[4] = r.sum as u32;
    buf[5] = 0x8000_0000;
    buf[6..15].fill(0);
    buf[15] = 84 * 8;
    sha256_compress(&mut buf);
    let mut hash = [0u32; 8];
    hash.copy_from_slice(&buf[16..]);
    Some(Node { hash, sum })
}

/// Public segment, fixed at deploy: [reserves low word, reserves high word, snapshot label].
/// Private input: [n, then n accounts of (id: 4 words, balance low, balance high)].
/// Outputs: [status, n, root (first 5 words), 0].
#[no_mangle]
pub extern "C" fn main() -> ! {
    let reserves = read_public(0) as u64 | (read_public(1) as u64) << 32;

    let n = read_input(0) as usize;
    if n > LEAVES {
        write_output(0, TOO_MANY);
        halt();
    }

    let empty = leaf(&[0; 4], 0);
    let mut row = [empty; LEAVES];
    for (i, slot) in row.iter_mut().enumerate().take(n) {
        let at = 1 + 6 * i as u32;
        let id = [read_input(at), read_input(at + 1), read_input(at + 2), read_input(at + 3)];
        let balance = read_input(at + 4) as u64 | (read_input(at + 5) as u64) << 32;
        *slot = leaf(&id, balance);
    }

    // Fold the row in place, a level at a time, until one node is left.
    let mut width = LEAVES;
    while width > 1 {
        width /= 2;
        for i in 0..width {
            match parent(&row[2 * i], &row[2 * i + 1]) {
                Some(p) => row[i] = p,
                None => {
                    write_output(0, OVERFLOW);
                    halt();
                }
            }
        }
    }
    let root = row[0];

    write_output(0, if root.sum <= reserves { SOLVENT } else { INSOLVENT });
    write_output(1, n as u32);
    for k in 0..5 {
        write_output(2 + k as u32, root.hash[k]);
    }
    halt();
}

ډکونه په لاس لیکل شوې ده. guest_sdk::sha256 هر بایټ لړۍ اخلي او یو یو بایټ یې کاپي کوي. دلته هر پیغام د معلوم اوږدوالي بشپړې کلمې دي، نو پروګرام 16-کلمه‌يي بلاک په مستقیم ډول ډکوي: د پیغام کلمې، بیا 0x80000000، صفرونه، او په وروستۍ کلمه کې د بټونو اوږدوالی. یوه پاڼه یو کمپرېشن دی. د یوې غوټې 84 بایټه دوهم بلاک ته اوړي، نو یوه غوټه دوه کمپرېشنه ده.

بیلانسونه u64 دي او مجموعې کتل کېږي. یو بیلانس منفي کېدای نشي ځکه چې دا ډول منفي ارزښتونه نه لري، او دا د مجموعې د کمولو بله کلاسیکه لار له منځه وړي. checked_add سرریزی د راګرځېدلې مجموعې پر ځای په 4 حالت بدلوي.

د نه‌ادا وړتیا پایله هم پایله ده. حالت 2 یو عادي درېدل دی چې رېښه پکې خپرېږي. امانتدار نشي کولای د هغو بیلانسونو لپاره چې د زېرمې له رقم څخه زیات وي د 1 حالت رسید ترلاسه کړي، او د 2 حالت رسید په دقیق ډول د همدې ثبوت دی.

4. د کوربه اړخ

solvency.py یوازې د Python معیاري کتابتون کاروي:

solvency.py setup   <accounts.csv> <reserves> <snapshot label>   writes public.txt, prints the root
solvency.py witness <accounts.csv>                 prints the private words
solvency.py path    <accounts.csv> <row>           prints that account's inclusion proof (JSON)
solvency.py verify  <proof.json> <root prefix hex> checks a proof against a receipt's root

په دې کې دوه هشونه هغه ټول مشخصات دي چې یو پیرودونکی ورته اړتیا لري:

def leaf(ident: bytes, balance: int):
    return hashlib.sha256(struct.pack(">I", 0) + ident + struct.pack(">Q", balance)).digest(), balance

def parent(l, r):
    h = hashlib.sha256(struct.pack(">I", 1) + l[0] + struct.pack(">Q", l[1]) + r[0] + struct.pack(">Q", r[1]))
    return h.digest(), l[1] + r[1]

نندارې په demo-accounts.csv کې دولس حسابونه لري، په هره کرښه کې یو id,balance، او بیلانسونه د 10⁻⁸ په واحدونو کې دي (هغه دقت چې یو پل شوی توکن لکه zUSD یې کاروي). د دوی مجموعه 100,215.185678 ده. امانتدار د 101,000 زېرمې ادعا کوي:

$ python3 solvency.py setup demo-accounts.csv 10100000000000 20260930
root 46b78564d60f75bdc9552d8ad1c4aadf411354054be3ffb80337b8549471a82c
root prefix 46b78564d60f75bdc9552d8ad1c4aadf41135405
root words 1186432356 3591337405 3377802634 3519326943 1091785733
liabilities 10021518567800
wrote public.txt
$ cat public.txt
2531887104 2351 20260930

2351 × 2³² + 2531887104 برابر دی له 10,100,000,000,000 سره. د liabilities کرښه د امانتدار خپل لید دی. هېڅکله نه خپرېږي.

پېژندونه باید بې‌ساری او نه‌اټکلېدونکي وي. که دوو پیرودونکو ته چې یو شان بیلانس لري یوه پاڼه ورکړل شي، امانتدار کولای شي د دواړو لپاره یو مکلفیت حساب کړي. هغه پېژند چې یوازې خپل پیرودونکی یې د خپل په توګه پېژندلای شي، د دې مخه نیسي، او هغه پېژند چې اټکل نشي کېدای، هغه پیرودونکی ودروي چې د خپل څنګ ملګري هش ویني او د ګاونډي د بیلانس اټکلونه ازمويي. نندارې د یو هش لومړي 16 بایټه کاروي. یوه ریښتینې ګمارنه به پېژند د پیرودونکي له حساب او د هر لحظه‌يي انځور له nonce څخه را وباسي او پیرودونکي ته به یې وښيي.

5. جوړول او چلول

$ rand-guest build my-guests/solvency --max-words 65535
994 words against a cap of 65535 (fits); 0 ecall(s) with a non-static a7
OK
wrote my-guests/solvency/image.bin and its .sha256 (994 words, hc 5559791a05bd9269bf7fc4e893c05e8b21defe5ef966d831b49ea463fb4552d3, program id 697412b5db65647164c21b27e4b4feb0b5f0b9fce2381157cd0786bfecf1769f)
$ cd my-guests/solvency
$ python3 solvency.py witness demo-accounts.csv > witness.txt
$ rand-guest run image.bin --public $(cat public.txt) --input $(cat witness.txt) --tier 14
out[0] = 1
out[1] = 12
out[2] = 1186432356
out[3] = 3591337405
out[4] = 3377802634
out[5] = 3519326943
out[6] = 1091785733
out[7] = 0
cycles 7492
tier 14
tier 14: fits (cycles 7762 of 16383, Poseidon2 permutations 270 of 2048)

حالت 1، دولس حسابونه، او د رېښې هغه پنځه کلمې چې سکرېپټ چاپ کړې. شاهد 73 کلمې دی: شمېر او د هر حساب لپاره شپږ.

کله چې د زېرمې رقم 100 واحدونو ته ټیټ شي (--public 100 0 1)، همدا حسابونه out[0] = 2 ورکوي. د 33 شمېر out[0] = 3 ورکوي. دوه حسابونه چې د بیلانسونو مجموعه یې له 2⁶⁴ تېره شي، out[0] = 4 ورکوي.

6. بودیجه

د کمپرېشنونو شمېر له n پاڼو، یوې تشې پاڼې (چې یو ځل حسابېږي او کاپي کېږي)، او د 31 غوټو د هرې یوې لپاره له دوو څخه جوړ دی. یوه غوښتنه تر ټولو ډېر 128 کمپرېشنونه کارولای شي، او 14 پوړ تر ټولو لوړ پوړ دی چې یوه غوښتنه یې کارولای شي، نو 32 حسابونه په دې ډیزاین کې هغه اندازې ته نږدې دي چې یوه غوښتنه یې ثابتولای شي. یوه 64-پاڼې ونه 190 کمپرېشنونو ته اړتیا لري او نه ځاییږي.

دا د نندارې اندازه ده. له دې تېرېدل دا مانا لري چې ونه پر څو غوښتنو ووېشل شي او د هرې فرعي ونې د رېښې او مجموعې ژمنه یوې وروستۍ غوښتنې ته یوړل شي، هغه بېلګه چې پروګرام ولیکئ یې د بودیجې څخه د پورته هر کار لپاره بیانوي. دا بېلګه دا کار نه کوي.

له 18 زنځیر راهیسې یو کمپرېشن 64 ګاز لګښت لري، په داسې حال کې چې یو عادي سایکل 1. والټ د یوې چلونې دقیق ګاز او هغه حد چاپوي چې اعلانوي یې:

gas: 12489 (declaring 16384, tier 14)

هر قطار 1 ګاز لګښت لري او یو کمپرېشن 63 نور: 7,764 قطارونه جمع 75 × 63 برابر دي له 12,489 سره. له دریمې برخې ډېر ګاز هشینګ دی. (والټ له rand-guest run څخه دوه قطاره ډېر حسابوي، د هغې معاملې تړنې لپاره چې 18 زنځیر د یوې غوښتنې عامې برخې ته ورزیاتوي.)

7. د پیرودونکي کتنه

امانتدار هر پیرودونکي ته خپله لاره ورکوي: په هر یوه له پنځو کچو کې د څنګ ملګري هش او د څنګ ملګري مجموعه.

$ python3 solvency.py path demo-accounts.csv 6 > proof6.json
$ head -12 proof6.json
{
 "id": "f8f4e4a0c855aad0d0f9ae5bab108333",
 "balance": 1820025000000,
 "path": [
  {
   "hash": "e39eaaabec5cca1fe4c76ce656692be631a39e807876f93bdd7baf8b057d6997",
   "sum": 6600000000,
   "sibling_is_left": false
  },
  {
   "hash": "4732f069886c966e6429ee9063f73429bf153eb2575cf2a28f00f27b7d0d89c6",
   "sum": 31500000000,

پیرودونکی رېښه له خپل پېژند او بیلانس څخه بیا حسابوي او د هغې لومړي 20 بایټه د رسید له 2 تر 6 وتونو سره پرتله کوي:

$ python3 solvency.py verify proof6.json 46b78564d60f75bdc9552d8ad1c4aadf41135405
root prefix 46b78564d60f75bdc9552d8ad1c4aadf41135405 MATCH

د داسې بیلانس لاره چې په ونه کې له شته بیلانس څخه یو واحد لوړ وي، رېښې ته نه رسېږي:

$ python3 solvency.py verify tampered.json 46b78564d60f75bdc9552d8ad1c4aadf41135405
root prefix e9a1b4cbe49e412214b97afe73348fa7c555fa7a DOES NOT MATCH

ټوله کتنه پورته د leaf او parent دندې دي چې پنځه ځله پلي کېږي. هغه پیرودونکی چې نه غواړي د امانتدار سکرېپټ وچلوي، کولای شي دا پخپله ولیکي.

یوه لاره پیرودونکي ته د هغه د څنګ ملګرو مجموعې ښيي. د پورتنۍ لارې لومړی ګام څرګندوي چې ګاونډۍ پاڼه 6,600,000,000 واحده لري، او هر لوړ ګام د یوې فرعي ونې مجموعه څرګندوي. دا په ساده مجموعې ونه کې ذاتي دی. په هر لحظه‌يي انځور کې د پاڼو ګډوډول هغه څه محدودوي چې یو پیرودونکی یې د وخت په تېرېدو زده کولای شي، او د مجموعو بشپړ پټول د ساده شمېرو پر ځای ژمنو ته اړتیا لري، چې دا بېلګه یې نه کوي.

8. ګمارل

$ rand fee deploy 994 --public-words 3
0.1007 RAND
$ rand program deploy image.bin --public public.txt
program id: fce8474dfdf80b9733e04fb72d4d8d19c40ba5ab646b3d867322daf4b9b599c0 (994 words, hc 1a7959556992bd05e8c47fbf8b5ec0935efede2131d866f963a49eb4d35245fb, public input 3 words, digest 70d5ae8935d646f7a0dd426c30aaf68e9bc382534d8a6ced90e363e129403608)
proving the spend authorisation on this machine (tier 10; seconds)…
authorisation proved in 6.8s: tier 10, 1368908 bytes
proving the bundle (tier 14; about a minute and a half on a laptop)…
proved in 116.7s: tier 14, 1500710 bytes
submitted deploy 39e8f35e0bdc7bc105ce942dc492b52f7a5efbb682ab6ebecc17cb310a161ada
  0 RAND out, 59.8545 RAND change, fee 0.1007 RAND, anchored at height 97831, proved in 116.7s (bundle) + 6.8s (auth)

د پروګرام پېژند د زېرمې رقم او د لحظه‌يي انځور نښان له کوډ سره تړي. نوی لحظه‌يي انځور نوې ګمارنه ده، د RAND د لسمې برخې په شاوخوا لګښت، او پېژند یې د نوې ادعا عامه بیانیه ده.

9. غوښتنه

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

proving the call locally (73 inputs stay private, over the program's 3-word public input)…
gas: 12489 (declaring 16384, tier 14)
fee 0.007487437 RAND (incl. two price steps of headroom)
proved in 122.9s: tier 14, 1911152 bytes, outputs [1, 12, 1186432356, 3591337405, 3377802634, 3519326943, 1091785733, 0]
proving the spend authorisation on this machine (tier 10; seconds)…
authorisation proved in 6.8s: tier 10, 1375371 bytes
proving the bundle (tier 14; about a minute and a half on a laptop)…
proved in 111.9s: tier 14, 1500198 bytes
submitted call 5d276bf7cb65cfcd2244ffd05baceaf6cb8082aeed6129a5e87e8737b3374e17
  0 RAND out, 59.709221126 RAND change, fee 0.007487437 RAND, anchored at height 98336, proved in 111.9s (bundle) + 6.8s (auth)
{
  "h_in": "b151f38fbbefd08c9f36e65da89f016ba7fc0ccdb52bddda6544e3d86372d331",
  "h_pub": "70d5ae8935d646f7a0dd426c30aaf68e9bc382534d8a6ced90e363e129403608",
  "height": 98574,
  "index": 0,
  "outputs": [
    1,
    12,
    1186432356,
    3591337405,
    3377802634,
    3519326943,
    1091785733,
    0
  ],
  "program": "fce8474dfdf80b9733e04fb72d4d8d19c40ba5ab646b3d867322daf4b9b599c0",
  "tier": 14,
  "tx": "5d276bf7cb65cfcd2244ffd05baceaf6cb8082aeed6129a5e87e8737b3374e17"
}
input transcript published; open it with `rand open-call 5d276bf7cb65cfcd2244ffd05baceaf6cb8082aeed6129a5e87e8737b3374e17`

حالت 1، دولس حسابونه، او رېښه په hex کې 46b78564 d60f75bd c9552d8a d1c4aadf 41135405. په معامله کې هېڅ شی بیلانس یا مجموعه نه بیانوي.

دا د tier-14 غوښتنه ده، نو ورو برخه یې د غوښتنې ثبوت دی: 123 s، بیا 7 s د لګښت د اجازې لپاره او 112 s د بنډل لپاره، ټول پنځه دقیقې، او د حافظې لوړ حد یې 6.6 GB دی. ثبوت 1,911,152 بایټه دی. د SHA-256 جدول له دې څخه شاوخوا 0.4 MB نیسي.

10. پخپله یې وګورئ

1. ادعا. rand_getProgramPublic د پروګرام پر id د ذخیرې رقم او لیبل راګرځوي. دا چې امانتدار په رښتیا دا ذخیره لري که نه، د دې ثبوت له ساحې بهر ده: دا د زنځیر پر سر بیلانس، د پلټونکي لیک، او یا د bridge شوې شتمنۍ لپاره د هغه زنځیر په خپل rand_getTokenSupply ښودل کېږي.
2. کوډ. my-guests/solvency د circuits په همغه commit بیا جوړ کړئ او hc د پروګرام له code_hash سره پرتله کړئ.
3. رسید. حالت 1، slot 7 باید 3735928559 نه وي، او program باید له id سره برابر وي. له 2 تر 6 پورې وتنې هغه ريښه ده چې هر پیرودونکی خپل ځان ورسره پرتله کوي.
4. ستاسو خپله پاڼه، لکه څنګه چې په ۷مه برخه کې راغلي.

هر څوک کولی شي دا غوښتنه د ازمېښتي حسابونو سره تکرار کړي، یا یو بیلانس بدل کړي او د ريښې بدلون وګوري.

ثبوت تاسو ته څه نه درکوي

• پخپله ذخیرې. ثبوت د یوه رقم پر وړاندې د مکلفیتونو دی. دا رقم خپل جلا شواهد ته اړتیا لري.
• بشپړتیا د پیرودونکو له ګډون پرته. هغه حساب چې امانتدار پرېښی وي، یوازې د هغه خاوند پیرودونکی یې موندلی شي. څومره چې ډېر پیرودونکي وګوري، هومره د دې لپاره ځای کمېږي.
• داسې وخت چې د ذخیرو له وخت سره سمون ولري. امانتدار کولی شي د انځور اخیستو د ساعت لپاره پیسې په پور واخلي. په نااعلان شویو وختونو کې ډېر ځله انځورونه دا امکان کموي.
• پټ ګاونډیان. د پیرودونکي لار د څنګ غوټو مجموعې ښيي (۷مه برخه).
• په یوه غوښتنه کې له 32 څخه ډېر حسابونه. بودیجه وګورئ.