mutourend

Polygon zkEVM Arithmetic状态机

1. 引言

前序博客有：

Polygon zkEVM PIL编译器——pilcom 代码解析
Polygon zkEVM zkASM编译器——zkasmcom

Polygon zkEVM中将某类特定的计算表示为状态机。
Arithmetic状态机为Polygon zkEVM的6个二级状态机之一，主要由2大部分组成：

1）Executor部分：有2个版本，Javascript版本和 C/C++版本。https://github.com/0xPolygonHermez/zkevm-proverjs/tree/main/src/sm/sm_arith。
2）验证规则集（a set of verification rules）程序部分：以PIL语言实现，见 https://github.com/0xPolygonHermez/zkevm-proverjs/blob/main/pil/arith.pil。

详细可参看审计培训视频Polygon zkEVM Training for Auditors - Arith state machine。

Polygon zkEVM的Arithmetic状态机主要是基于Secp256K1椭圆曲线E（ $y^2=x^3+7$ ，基域为 $p=2^{256}-2^{32}-2^9-2^8-2^7-2^6-2^4-1$ ）上的如下运算：【二进制表示为0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2fL，与pil实现中eq公式内的p[0]p[1]等常量值对应。】

1）域内加法和乘法等运算： $x_1\cdot y_1+x_2=y_2\cdot 2^{256}+y_3$ 。若 $y_1=0$ ，则表示的是field addition运算；若 $x_2=0$ ，则表示的是field multiplication运算。
2）椭圆曲线点加运算：椭圆曲线上2个不同点 $P=(x_1,y_1),Q=(x_2,y_2)$ ， $x_1\neq x_2$ , $P+Q=(x_3,y_3)$ 计算为：
$x_3=s^2-x_1-x_2,$
$y_3=s(x_1-x_3)-y_1$
其中 $s=\frac{y_2-y_1}{x_2-x_1}$ 。
3）椭圆曲线点倍加运算：椭圆曲线上点 $P=(x_1,y_1)$ ，, $2P=P+P=(x_3,y_3)$ 计算为：
$x_3=s^2-2x_1,$
$y_3=s(x_1-x_3)-y_1$
其中 $s=\frac{3x_1^2}{2y_1}$ 。

将以上运算以约束形式表示为：
$\begin{aligned} \text{EQ}_0 \colon \quad &x_1 \cdot y_1 + x_2 - y_2 \cdot 2^{256} - y_3 = 0, \\ \text{EQ}_1 \colon \quad &s \cdot x_2 - s \cdot x_1 -y_2 + y_1 + q_0 \cdot p = 0, \\ \text{EQ}_2 \colon \quad & 2 \cdot s \cdot y_1 - 3 \cdot x_1 \cdot x_1 + q_0 \cdot p = 0, \\ \text{EQ}_3 \colon \quad & s \cdot s - x_1 - x_2 - x_3 + q_1 \cdot p = 0, \\ \text{EQ}_4 \colon \quad & s \cdot x_1 - s \cdot x_3 - y_1 - y_3 + q_2 \cdot p = 0, \end{aligned}$
其中 $q_0,q_1,q_2 \in \mathbb{Z}$ 为整数，使得以上等式成立。这种表达可避免对 $p$ 做除法运算。
这些约束对应3个可能的计算场景：

若 $EQ_0$ 激活，则其它等式失效；
若 $EQ_1,EQ_3,EQ_4$ 激活，则 $EQ_0,EQ_2$ 等式失效；
若 $EQ_2,EQ_3,EQ_4$ 激活，则 $EQ_0,EQ_1$ 等式失效。

由于在以上任意场景下， $EQ_1$ 和 $EQ_2$ 最多只能激活一个，因此二者可“共享”相同的 $q_0$ 。

为实现以上运算，Arithmetic状态机内需包含以下寄存器：
$x_1,y_1,x_2,y_2,x_3,y_3,s,q_0,q_1,q_2$
这些寄存器均为256-bit field elements，实际构建时，将每个寄存器切分为16个子寄存器，每个子寄存器容量为16-bit（2个字节），为此，PIL中的定义为：

pol commit x1[16];
pol commit y1[16];
pol commit x2[16];
pol commit y2[16];
pol commit x3[16];
pol commit y3[16];

pol commit s[16];
pol commit q0[16];
pol commit q1[16];
pol commit q2[16];

2. arith.zkasm示例

以zkevm-proverjs/test/zkasm/counters/arith.zkasm为例：【$ npm run test:counters:arith】

start:

        STEP => A
        0 :ASSERT

        0 => A
        CNT_ARITH :ASSERT
        CNT_BINARY :ASSERT
        CNT_KECCAK_F: ASSERT
        CNT_MEM_ALIGN :ASSERT
        CNT_POSEIDON_G :ASSERT
        CNT_PADDING_PG :ASSERT

        0 => A,B,C,D    :ARITH #清零

        CNT_ARITH => A
        1               :ASSERT

        CNT_ARITH => A
        1               :ASSERT

        0x2000000000000000000000000000000000000000000000000000000000000001n => A
        0x100    => B
        0x73     => C
        0x20    => D
        0x173   :ARITH #赋值


        2 => A
        CNT_ARITH :ASSERT

        0 => A
        CNT_KECCAK_F: ASSERT
        CNT_MEM_ALIGN :ASSERT
        CNT_POSEIDON_G :ASSERT
        CNT_PADDING_PG :ASSERT

end:
       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR

finalWait:
        ${beforeLast()}  : JMPN(finalWait)

                         : JMP(start)
opINVALID:

经const rom = await zkasm.compile(path.join(__dirname, "zkasm", zkasmFile)); zkasmcom 编译后的结果为：

{
 "program": [
  {
   "inSTEP": "1",
   "setA": 1,
   "line": 3,
   "fileName": "arith.zkasm",
   "lineStr": "        STEP => A"
  },
  {
   "CONST": "0",
   "assert": 1,
   "line": 4,
   "fileName": "arith.zkasm",
   "lineStr": "        0 :ASSERT"
  },
  {
   "CONST": "0",
   "setA": 1,
   "line": 6,
   "fileName": "arith.zkasm",
   "lineStr": "        0 => A"
  },
  {
   "inCntArith": "1",
   "assert": 1,
   "line": 7,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_ARITH :ASSERT"
  },
  {
   "inCntBinary": "1",
   "assert": 1,
   "line": 8,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_BINARY :ASSERT"
  },
  {
   "inCntKeccakF": "1",
   "assert": 1,
   "line": 9,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_KECCAK_F: ASSERT"
  },
  {
   "inCntMemAlign": "1",
   "assert": 1,
   "line": 10,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_MEM_ALIGN :ASSERT"
  },
  {
   "inCntPoseidonG": "1",
   "assert": 1,
   "line": 11,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_POSEIDON_G :ASSERT"
  },
  {
   "inCntPaddingPG": "1",
   "assert": 1,
   "line": 12,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_PADDING_PG :ASSERT"
  },
  {
   "CONST": "0",
   "setA": 1,
   "setB": 1,
   "setC": 1,
   "setD": 1,
   "arith": 1,
   "arithEq0": 1,
   "line": 14,
   "fileName": "arith.zkasm",
   "lineStr": "        0 => A,B,C,D    :ARITH"
  },
  {
   "inCntArith": "1",
   "setA": 1,
   "line": 16,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_ARITH => A"
  },
  {
   "CONST": "1",
   "assert": 1,
   "line": 17,
   "fileName": "arith.zkasm",
   "lineStr": "        1               :ASSERT"
  },
  {
   "inCntArith": "1",
   "setA": 1,
   "line": 19,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_ARITH => A"
  },
  {
   "CONST": "1",
   "assert": 1,
   "line": 20,
   "fileName": "arith.zkasm",
   "lineStr": "        1               :ASSERT"
  },
  {
   "CONSTL": "14474011154664524427946373126085988481658748083205070504932198000989141204993",
   "setA": 1,
   "line": 22,
   "fileName": "arith.zkasm",
   "lineStr": "        0x2000000000000000000000000000000000000000000000000000000000000001n => A"
  },
  {
   "CONST": "256",
   "setB": 1,
   "line": 23,
   "fileName": "arith.zkasm",
   "lineStr": "        0x100    => B"
  },
  {
   "CONST": "115",
   "setC": 1,
   "line": 24,
   "fileName": "arith.zkasm",
   "lineStr": "        0x73     => C"
  },
  {
   "CONST": "32",
   "setD": 1,
   "line": 25,
   "fileName": "arith.zkasm",
   "lineStr": "        0x20    => D"
  },
  {
   "CONST": "371",
   "arith": 1,
   "arithEq0": 1,
   "line": 26,
   "fileName": "arith.zkasm",
   "lineStr": "        0x173   :ARITH"
  },
  {
   "CONST": "2",
   "setA": 1,
   "line": 29,
   "fileName": "arith.zkasm",
   "lineStr": "        2 => A"
  },
  {
   "inCntArith": "1",
   "assert": 1,
   "line": 30,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_ARITH :ASSERT"
  },
  {
   "CONST": "0",
   "setA": 1,
   "line": 32,
   "fileName": "arith.zkasm",
   "lineStr": "        0 => A"
  },
  {
   "inCntKeccakF": "1",
   "assert": 1,
   "line": 33,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_KECCAK_F: ASSERT"
  },
  {
   "inCntMemAlign": "1",
   "assert": 1,
   "line": 34,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_MEM_ALIGN :ASSERT"
  },
  {
   "inCntPoseidonG": "1",
   "assert": 1,
   "line": 35,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_POSEIDON_G :ASSERT"
  },
  {
   "inCntPaddingPG": "1",
   "assert": 1,
   "line": 36,
   "fileName": "arith.zkasm",
   "lineStr": "        CNT_PADDING_PG :ASSERT"
  },
  {
   "CONST": "0",
   "setA": 1,
   "setB": 1,
   "setC": 1,
   "setD": 1,
   "setE": 1,
   "setCTX": 1,
   "setSP": 1,
   "setPC": 1,
   "setGAS": 1,
   "setMAXMEM": 1,
   "setSR": 1,
   "line": 39,
   "fileName": "arith.zkasm",
   "lineStr": "       0 => A,B,C,D,E,CTX, SP, PC, GAS, MAXMEM, SR"
  },
  {
   "freeInTag": {
    "op": "functionCall",
    "funcName": "beforeLast",
    "params": []
   },
   "inFREE": "1",
   "JMPC": 0,
   "JMPN": 1,
   "offset": 27,
   "line": 42,
   "offsetLabel": "finalWait",
   "fileName": "arith.zkasm",
   "lineStr": "        ${beforeLast()}  : JMPN(finalWait)"
  },
  {
   "JMP": 1,
   "JMPC": 0,
   "JMPN": 0,
   "offset": 0,
   "line": 44,
   "offsetLabel": "start",
   "fileName": "arith.zkasm",
   "lineStr": "                         : JMP(start)"
  }
 ],
 "labels": {
  "start": 0,
  "end": 26,
  "finalWait": 27,
  "opINVALID": 29
 }
}

【Executor本质上是一种名为zkASM的汇编语言解释器。
使用zkASM语言来构建名为zkROM的程序，Executor运行zkROM程序来提供合适的execution trace。
在zkROM程序中，每个EVM opcode都以一组zkASM指令集来实现。
每个zkASM指令利用了execution trace矩阵中的一行，又名zkEVM的一个“step”。】即意味着const rom = await zkasm.compile(path.join(__dirname, "zkasm", zkasmFile)); zkasm编译的结果，会作为rom.pil的输入：

await smRom.buildConstants(constPols.Rom, rom);：给rom.pil的常量多项式赋值。【实际上，Rom中全是常量多项式，为只读模式】
const requiredMain = await smMain.execute(cmPols.Main, input, rom);：根据zkasm编译的.rom.json文件和input（如../tools/build-genesis/input-executor.json），获得main.pil的execution trace。

以zkevm-proverjs中的 "test:counters:arith": "mocha -max-old-space-size=51200 test/counters/arith.js",为例：

describe("Test Arith Counter", async function () {
    this.timeout(10000000);

    it("Verify Arith Zkasm Test", async () => {
        await verifyZkasm("../zkasm/counters/arith.zkasm", true,
                { defines: {N: 2 ** 21},
                  namespaces: ['Global', 'Main', 'Rom', 'Byte4', 'Arith'], //只对这些namespace操作。
                  verbose: true,
                  color: true,
                  disableUnusedError: true});
    });
});

基本流程为：

1）对main.pil编译，结果为main.pil.json。
2）对arith.zkasm编译，结果为arith.rom.json。
3）依次对上面定义的namespace（‘Global’, ‘Main’, ‘Rom’, ‘Byte4’, ‘Arith’）常量多项式赋值，其中’Rom’中的所有常量多项式赋值取决于arith.rom.json。而其它namespace中的常量多项式赋值是固定不变的。
4）对’Main’中的隐私多项式赋值，取决于具体的input和arith.rom.json。
```
const requiredMain = await smMain.execute(cmPols.Main, input, rom);
```
5）根据requiredMain.Byte4，对’Byte4‘中的隐私多项式赋值。
```
await smByte4.execute(cmPols.Byte4, requiredMain.Byte4);
```
6）根据requiredMain.Arith || []，对’Arith’中的隐私多项式赋值。
```
await smBinary.execute(cmPols.Binary, requiredMain.Binary || []);
```

接下来重点关注以上4）5）6）步骤的execution trace赋值细节。
其中的input为../tools/build-genesis/input-executor.json：

{
  "oldStateRoot": "0x2dc4db4293af236cb329700be43f08ace740a05088f8c7654736871709687e90",
  "db": {
    "0x2dc4db4293af236cb329700be43f08ace740a05088f8c7654736871709687e90": [
      "0000000000000000",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000",
      "0d1f0da5a7b620c8",
      "43fd1e18e59fd724",
      "d428d25da0cb1888",
      "e31f5542ac227c06",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000"
    ],
    "0xe31f5542ac227c06d428d25da0cb188843fd1e18e59fd7240d1f0da5a7b620c8": [
      "ed22ec7734d89ff2",
      "b2e639153607b7c5",
      "42b2bd6ec2788851",
      "b781932941084783",
      "3e63658ee0db910d",
      "0b3e34316e81aa10",
      "e0dc203d93f4e3e5",
      "e10053d0ebc64602",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000"
    ],
    "0xb78193294108478342b2bd6ec2788851b2e639153607b7c5ed22ec7734d89ff2": [
      "16dde42596b907f0",
      "49015d7e991a1528",
      "94dd9dadd060910b",
      "60b4d5e9af514018",
      "b69b044f5e694795",
      "f57d81efba5d4445",
      "339438195426ad0a",
      "3efad1dd58c2259d",
      "0000000000000001",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000"
    ],
    "0x3efad1dd58c2259d339438195426ad0af57d81efba5d4445b69b044f5e694795": [
      "00000000dea00000",
      "0000000035c9adc5",
      "0000000000000036",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000"
    ],
    "0xe10053d0ebc64602e0dc203d93f4e3e50b3e34316e81aa103e63658ee0db910d": [
      "66ee2be0687eea76",
      "6926f8ca8796c78a",
      "4c2f3e938869b82d",
      "649e63bfe1247ba4",
      "b69b044f5e694795",
      "f57d81efba5d4445",
      "339438195426ad0a",
      "3efad1dd58c2259d",
      "0000000000000001",
      "0000000000000000",
      "0000000000000000",
      "0000000000000000"
    ]
  },
  "sequencerAddr": "0x617b3a3528F9cDd6630fd3301B9c8911F7Bf063D",
  "batchL2Data": "0xee80843b9aca00830186a0944d5cf5032b2a844602278b01199ed191a86c93ff88016345785d8a0000808203e880801cee7e01dc62f69a12c3510c6d64de04ee6346d84b6a017f3e786c7d87f963e75d8cc91fa983cd6d9cf55fff80d73bd26cd333b0f098acc1e58edb1fd484ad731b",
  "newStateRoot": "0xbff23fc2c168c033aaac77503ce18f958e9689d5cdaebb88c5524ce5c0319de3",
  "oldLocalExitRoot": "0x17c04c3760510b48c6012742c540a81aba4bca2f78b9d14bfd2f123e2e53ea3e",
  "newLocalExitRoot": "0x0000000000000000000000000000000000000000000000000000000000000000",
  "globalExitRoot": "0x090bcaf734c4f06c93954a827b45a6e8c67b8e0fd1e0a35a1c5982d6961828f9",
  "numBatch": 1,
  "timestamp": 1944498031,
  "contractsBytecode": {}
}

2.1 Main.pil隐私多项式赋值

基于input-executor.json和arith.rom.json，对main.pil中的隐私多项式赋值：

const requiredMain = await smMain.execute(cmPols.Main, input, rom);

smMain.execute的核心流程为：

1）从input.db中加载数据库信息，并基于数据库信息构建sparse merkle树：
```
const db = new MemDB(Fr, input.db);
const smt = new SMT(db, poseidon, Fr);
```
2）对main.pil中的部分隐私多项式（A0-A7\B0-B7\C0-C7\D0-D7\E0-E7\SR0-SR7\CTX\SP\PC\MAXMEM\HASHPOS\GAS\RR\zkPC\cntArith\cntBinary\cntKeccakF\cntMemAlign\cntPaddingPG\cntPoseidonG）的第0个值初始化为0：
```
initState(Fr, pols);
```
3）交易预处理preprocessTxs，取input-executor.json中的sequencerAddr、batchL2Data、newStateRoot、oldLocalExitRoot、newLocalExitRoot、globalExitRoot、numBatch、timestamp、oldStateRoot信息：
- 3.1）根据batchL2Data、globalExitRoot和sequencerAddr，计算batchHashData：【本质是调用ethers.utils.solidityKeccak256进行哈希运算】
```
ctx.input.batchHashData = calculateBatchHashData(
    ctx.input.batchL2Data,
    globalExitRoot,
    sequencerAddr
);
```
- 3.2）根据oldStateRoot、oldLocalExitRoot、newStateRoot、newLocalExitRoot、numBatch、timestamp，计算STARK input：【本质也是调用ethers.utils.solidityKeccak256进行哈希运算】
```
ctx.globalHash = calculateStarkInput(
        oldStateRoot,
        oldLocalExitRoot,
        newStateRoot,
        newLocalExitRoot,
        ctx.input.batchHashData,
        numBatch,
        timestamp
);
```
- 3.3）对touchedAddress和touchedStorageSlots赋值为[]。

4）逐个处理arith.rom.json文件中program的各元素：【i为相应的序号】

4.0）arith.rom.json中program第0个元素

l

：

{
"inSTEP": "1",
"setA": 1,
"line": 3,
"fileName": "arith.zkasm",
"lineStr": "        STEP => A"
},

inSTEP：若非空，设置op0=op0+inSTEP*i，且inSTEP[i]=l.inSTEP；否则，inSTEP[i]=0。
setA：若非空，则setA[i]=1,A0’=op0,A1’=op1,A2’=op2,A3’=op3,A4’=op4,A5’=op5,A6’=op6,A7’=op7；否则setA[i]=0, A0’=A0,A1’=A1,A2’=A2,A3’=A3,A4’=A4,A5’=A5,A6’=A6,A7’=A7。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	isNeg	zkPC	JMP	JMPN	JMPC
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0
1			op0	op1	op2	op3	op4	op5	op6	op7		1

4.1）arith.rom.json中program第1个元素

l

：

{
"CONST": "0",
"assert": 1,
"line": 4,
"fileName": "arith.zkasm",
"lineStr": "        0 :ASSERT"
}

CONST：若设置，则CONST0[i]=l.CONST，op0=op0+l.CONST，CONST1[i]=0,CONST2[i]=0,CONST3[i]=0,CONST4[i]=0,CONST5[i]=0,CONST6[i]=0,CONST7[i]=0；否则若亦未设置CONSTL，则CONST0/1/2/3/4/5/6/7[i]=0。
assert：若设置，则assert[i]=1；否则，assert[i]=0。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	isNeg	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	0	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0
2			op0(同上一行)	op1	op2	op3	op4	op5	op6	op7		2

4.2）arith.rom.json中program第2个元素

l

：

{
"CONST": "0",
"setA": 1,
"line": 6,
"fileName": "arith.zkasm",
"lineStr": "        0 => A"
}

CONST：若设置，则CONST0[i]=l.CONST，op0=op0+l.CONST，CONST1[i]=0,CONST2[i]=0,CONST3[i]=0,CONST4[i]=0,CONST5[i]=0,CONST6[i]=0,CONST7[i]=0；否则若亦未设置CONSTL，则CONST0/1/2/3/4/5/6/7[i]=0。
setA：若非空，则setA[i]=1,A0’=op0,A1’=op1,A2’=op2,A3’=op3,A4’=op4,A5’=op5,A6’=op6,A7’=op7；否则setA[i]=0, A0’=A0,A1’=A1,A2’=A2,A3’=A3,A4’=A4,A5’=A5,A6’=A6,A7’=A7。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	isNeg	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	0	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0
2	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7		2	0	0	0	0	l.CONST	0	0	0	0	0	0	0
3			op0	op1	op2	op3	op4	op5	op6	op7		3

4.3）arith.rom.json中program第3个元素

l

：

{
"inCntArith": "1",
"assert": 1,
"line": 7,
"fileName": "arith.zkasm",
"lineStr": "        CNT_ARITH :ASSERT"
}

inCntArith：若设置，则op0=op0+l.inCntArith*cntArith[i]，inCntArith[i]=l.inCntArith；否则inCntArith[i]=0。
assert：若设置，则assert[i]=1；否则，assert[i]=0。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	isNeg	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7	inCntArith	cntArith
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	0	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0	0	0
2	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7		2	0	0	0	0	l.CONST	0	0	0	0	0	0	0	0	0
3	0	0	op0	op1	op2	op3	op4	op5	op6	op7		3	0	0	0	1	0	0	0	0	0	0	0	0	l.inCntArith	0
4			op0(同上一行)	op1	op2	op3	op4	op5	op6	op7		4

4.4）arith.rom.json中program第4个元素

l

：

{
"inCntBinary": "1",
"assert": 1,
"line": 8,
"fileName": "arith.zkasm",
"lineStr": "        CNT_BINARY :ASSERT"
}

inCntBinary：若设置，则op0=op0+l.inCntBinary*cntBinary[i]，inCntBinary[i]=l.inCntBinary；否则inCntBinary[i]=0。
assert：若设置，则assert[i]=1；否则，assert[i]=0。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	isNeg	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7	inCntArith	cntArith	inCntBinary	cntBinary
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	0	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0	0	0	0	0
2	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7		2	0	0	0	0	l.CONST	0	0	0	0	0	0	0	0	0	0	0
3	0	0	op0	op1	op2	op3	op4	op5	op6	op7		3	0	0	0	1	0	0	0	0	0	0	0	0	l.inCntArith	0	0	0
4	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7		4	0	0	0	1	0	0	0	0	0	0	0	0	0	0	inCntBinary	0
5			op0(同上一行)	op1	op2	op3	op4	op5	op6	op7		5

4.5）arith.rom.json中program第5个元素

l

：

{
"inCntKeccakF": "1",
"assert": 1,
"line": 9,
"fileName": "arith.zkasm",
"lineStr": "        CNT_KECCAK_F: ASSERT"
}

inCntKeccakF：若设置，则op0=op0+l.inCntKeccakF*cntKeccakF[i]，inCntKeccakF[i]=l.inCntKeccakF；否则inCntKeccakF[i]=0。
assert：若设置，则assert[i]=1；否则，assert[i]=0。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7	inCntArith	cntArith	inCntBinary	cntBinary	inCntKeccakF	cntKeccakF
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	2	0	0	0	0	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0
3	0	0	op0	op1	op2	op3	op4	op5	op6	op7	3	0	0	0	1	0	0	0	0	0	0	0	0	l.inCntArith	0	0	0	0	0
4	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	4	0	0	0	1	0	0	0	0	0	0	0	0	0	0	inCntBinary	0	0	0
5	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	5	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntKeccakF	0
6			op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	6

4.6）arith.rom.json中program第6个元素

l

：

{
"inCntMemAlign": "1",
"assert": 1,
"line": 10,
"fileName": "arith.zkasm",
"lineStr": "        CNT_MEM_ALIGN :ASSERT"
},

inCntMemAlign：若设置，则op0=op0+l.inCntMemAlign*cntMemAlign[i]，inCntMemAlign[i]=l.inCntMemAlign；否则inCntMemAlign[i]=0。
assert：若设置，则assert[i]=1；否则，assert[i]=0。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7	inCntArith	cntArith	inCntBinary	cntBinary	inCntKeccakF	cntKeccakF	inCntMemAlign	cntMemAlign
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	2	0	0	0	0	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
3	0	0	op0	op1	op2	op3	op4	op5	op6	op7	3	0	0	0	1	0	0	0	0	0	0	0	0	l.inCntArith	0	0	0	0	0	0	0
4	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	4	0	0	0	1	0	0	0	0	0	0	0	0	0	0	inCntBinary	0	0	0	0	0
5	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	5	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntKeccakF	0	0	0
6	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	6	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntMemAlign	0
7			op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	7

4.7）arith.rom.json中program第7个元素

l

：

{
"inCntPoseidonG": "1",
"assert": 1,
"line": 11,
"fileName": "arith.zkasm",
"lineStr": "        CNT_POSEIDON_G :ASSERT"
},

inCntPoseidonG：若设置，则op0=op0+l.inCntPoseidonG*cntPoseidonG[i]，inCntPoseidonG[i]=l.inCntPoseidonG；否则inCntPoseidonG[i]=0。
assert：若设置，则assert[i]=1；否则，assert[i]=0。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7	inCntArith	cntArith	inCntBinary	cntBinary	inCntKeccakF	cntKeccakF	inCntMemAlign	cntMemAlign	inCntPoseidonG	cntPoseidonG
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	2	0	0	0	0	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
3	0	0	op0	op1	op2	op3	op4	op5	op6	op7	3	0	0	0	1	0	0	0	0	0	0	0	0	l.inCntArith	0	0	0	0	0	0	0	0	0
4	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	4	0	0	0	1	0	0	0	0	0	0	0	0	0	0	inCntBinary	0	0	0	0	0	0	0
5	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	5	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntKeccakF	0	0	0	0	0
6	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	6	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntMemAlign	0	0	0
7	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	7	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0l.inCntPoseidonG	0
8			op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	8

4.8）arith.rom.json中program第8个元素

l

：

{
"inCntPaddingPG": "1",
"assert": 1,
"line": 12,
"fileName": "arith.zkasm",
"lineStr": "        CNT_PADDING_PG :ASSERT"
}

inCntPaddingPG：若设置，则op0=op0+l.inCntPaddingPG*cntPaddingPG[i]，inCntPaddingPG[i]=l.inCntPaddingPG；否则inCntPaddingPG[i]=0。
assert：若设置，则assert[i]=1；否则，assert[i]=0。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7	inCntArith	cntArith	inCntBinary	cntBinary	inCntKeccakF	cntKeccakF	inCntMemAlign	cntMemAlign	inCntPoseidonG	cntPoseidonG	inCntPaddingPG	cntPaddingPG
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	2	0	0	0	0	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
3	0	0	op0	op1	op2	op3	op4	op5	op6	op7	3	0	0	0	1	0	0	0	0	0	0	0	0	l.inCntArith	0	0	0	0	0	0	0	0	0	0	0
4	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	4	0	0	0	1	0	0	0	0	0	0	0	0	0	0	inCntBinary	0	0	0	0	0	0	0	0	0
5	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	5	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntKeccakF	0	0	0	0	0	0	0
6	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	6	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntMemAlign	0	0	0	0	0
7	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	7	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0l.inCntPoseidonG	0	0	0
8	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	8	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntPaddingPG	0
9			op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	9

4.9）arith.rom.json中program第9个元素

l

：

{
"CONST": "0",
"setA": 1,
"setB": 1,
"setC": 1,
"setD": 1,
"arith": 1,
"arithEq0": 1,
"line": 14,
"fileName": "arith.zkasm",
"lineStr": "        0 => A,B,C,D    :ARITH"
},

CONST：若设置，则CONST0[i]=l.CONST，op0=op0+l.CONST，CONST1[i]=0,CONST2[i]=0,CONST3[i]=0,CONST4[i]=0,CONST5[i]=0,CONST6[i]=0,CONST7[i]=0；否则若亦未设置CONSTL，则CONST0/1/2/3/4/5/6/7[i]=0。
setA：若非空，则setA[i]=1,A0’=op0,A1’=op1,A2’=op2,A3’=op3,A4’=op4,A5’=op5,A6’=op6,A7’=op7；否则setA[i]=0, A0’=A0,A1’=A1,A2’=A2,A3’=A3,A4’=A4,A5’=A5,A6’=A6,A7’=A7。
不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。
arith：若非空，则cntArith’=cntArith+1；否则，cntArith’=cntArith。

arithEq0：即计算上面的EQ0，若非空，则arith[i]=1，arithEq0[i]=1；否则视具体的计算设定。同时会在required.Arith中存入required.Arith.push({x1: A, y1: B, x2: C, y2: D, x3: Fr.zero, y3: op, selEq0: 1, selEq1: 0, selEq2: 0, selEq3: 0});。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7	inCntArith	cntArith	inCntBinary	cntBinary	inCntKeccakF	cntKeccakF	inCntMemAlign	cntMemAlign	inCntPoseidonG	cntPoseidonG	inCntPaddingPG	cntPaddingPG	arith	arithEq0	setB	B0-B7	setC	C0-C7	setD	D0-D7
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	2	0	0	0	0	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
3	0	0	op0	op1	op2	op3	op4	op5	op6	op7	3	0	0	0	1	0	0	0	0	0	0	0	0	l.inCntArith	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
4	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	4	0	0	0	1	0	0	0	0	0	0	0	0	0	0	inCntBinary	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
5	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	5	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntKeccakF	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
6	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	6	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntMemAlign	0	0	0	0	0	0	0	0	0	0	0	0	0
7	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	7	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0l.inCntPoseidonG	0	0	0	0	0	0	0	0	0	0	0
8	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	8	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntPaddingPG	0	0	0	0	0	0	0	0	0
9	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	9	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	1	1	1	0	1	0	1	0
10			op0	op1	op2	op3	op4	op5	op6	op7	10														1														op0-op7		op0-op7		op0-op7

4.10）arith.rom.json中program第10个元素

l

：

{
"inCntArith": "1",
"setA": 1,
"line": 16,
"fileName": "arith.zkasm",
"lineStr": "        CNT_ARITH => A"
}

inCntArith：若设置，则op0=op0+l.inCntArith*cntArith[i]，inCntArith[i]=l.inCntArith；否则inCntArith[i]=0。
setA：若非空，则setA[i]=1,A0’=op0,A1’=op1,A2’=op2,A3’=op3,A4’=op4,A5’=op5,A6’=op6,A7’=op7；否则setA[i]=0, A0’=A0,A1’=A1,A2’=A2,A3’=A3,A4’=A4,A5’=A5,A6’=A6,A7’=A7。

不包含JMP/JMPC/JMPN：isNeg[i]=0，zkPC’=zkPC+1，JMP[i]=0，JMPN[i]=0，JMPC[i]=0。

i	inSTEP	setA	A0	A1	A2	A3	A4	A5	A6	A7	zkPC	JMP	JMPN	JMPC	assert	CONST0	CONST1	CONST2	CONST3	CONST4	CONST5	CONST6	CONST7	inCntArith	cntArith	inCntBinary	cntBinary	inCntKeccakF	cntKeccakF	inCntMemAlign	cntMemAlign	inCntPoseidonG	cntPoseidonG	inCntPaddingPG	cntPaddingPG	arith	arithEq0	setB	B0-B7	setC	C0-C7	setD	D0-D7
0	l.inSTEP	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
1	0	0	op0	op1	op2	op3	op4	op5	op6	op7	1	0	0	0	1	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
2	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	2	0	0	0	0	l.CONST	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
3	0	0	op0	op1	op2	op3	op4	op5	op6	op7	3	0	0	0	1	0	0	0	0	0	0	0	0	l.inCntArith	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
4	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	4	0	0	0	1	0	0	0	0	0	0	0	0	0	0	inCntBinary	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
5	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	5	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntKeccakF	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0
6	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	6	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntMemAlign	0	0	0	0	0	0	0	0	0	0	0	0	0
7	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	7	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0l.inCntPoseidonG	0	0	0	0	0	0	0	0	0	0	0
8	0	0	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	8	0	0	0	1	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntPaddingPG	0	0	0	0	0	0	0	0	0
9	0	1	op0(同上一行)	op1	op2	op3	op4	op5	op6	op7	9	0	0	0	0	0	0	0	0	0	0	0	0	0	1	0	0	0	0	0	0	0	0	0	0	1	1	1	0	1	0	1	0
10	0	1	op0	op1	op2	op3	op4	op5	op6	op7	10	0	0	0	0	0	0	0	0	0	0	0	0	l.inCntArith	1	0	0	0	0	0	0	0	0	0	0	0	0	0	op0-op7	0	op0-op7	0	op0-op7
11			op0	op1	op2	op3	op4	op5	op6	op7	11														1														op0-op7(同上一行)		op0-op7(同上一行)		op0-op7(同上一行)

。。。。。
以此类推，给各个二级状态机的input信息见required内容：

	const required = {
        Byte4: {},
        Arith: [],
        Binary: [],
        PaddingKK: [],
        PaddingPG: [],
        PoseidonG: [],
        Mem: [],
        MemAlign: [],
        Storage: []
    };

如本例中：

1）给Byte4的input为：
```
{
 "0": true,
 "4294967295": true
}
```

2）给Arith的input为：

required.Arith.push({x1: A, y1: B, x2: C, y2: D, x3: Fr.zero, y3: op, selEq0: 1, selEq1: 0, selEq2: 0, selEq3: 0});

2.2 Byte4.pil隐私多项式赋值

smByte4.execute(cmPols.Byte4, requiredMain.Byte4);

如本例中，给Byte4的input为：【 $4294967295=2^{32}-1$ 】

{
	"0": true,
	"4294967295": true
}

byte4 execution trace执行逻辑为：

module.exports.execute = async function (pols, input) {

    const N = pols.freeIN.length;

    let p=0;
    let last = 0;
    Object.keys(input).forEach( (n) => {
        const num = Number(n);
        pols.freeIN[p] = BigInt(num >>> 16);//存储num的高16位
        pols.out[p] = BigInt(last);//存储上一num值
        p++;
        pols.freeIN[p] = BigInt(num & 0xFFFF); //存储num的低16位
        pols.out[p] = BigInt(num >>> 16);//存储num的高16位，即等于freeIN[p-1]
        p++;
        last = num;
    });
    pols.freeIN[p] = 0n;
    pols.out[p] = BigInt(last);//存储上一num值
    p++;
    pols.freeIN[p] = 0n;
    pols.out[p] = 0n;
    p++;

    if (p >= N) {
        throw new Error("Too many byte4");
    }

    while (p<N) {
        pols.freeIN[p] = 0n;
        pols.out[p] = 0n;
        p++;
    }
}

byte4常量多项式逻辑为：

module.exports.buildConstants = async function (pols) {
    const N = pols.SET.length;

    for ( let i=0; i<N; i++) pols.SET[i] = (i % 2 == 0) ? 1n : 0n;
}

即本例实际赋值情况为：

index	SET	pols.freeIN	pols.out
0	1	0	0
1	0	0	0
2	1	65535	0
4	0	65535	65535
5	1	0	4294967295
6	0	0	0
7	1	0	0
$\vdots$	$\vdots$	$\vdots$

根据byte4.pil可知，相应的约束逻辑为：

/*
This state machine is able to builds any number of 4 bytes (32 bits)


Example for building numbers: 0x00030007, 0x12345678, 0x00050009 and 0
        SET     freeIN  out        out'
w^0     1       3       0          3
w^1     0       7       3          0x00030007
w^2     1       0x1234  0x00030007 0x1234
w^3     0       0x5678  0x1234     0x12345678
w^4     1       5       0x12345678 5
w^5     0       9       5          0x50009
w^6     1       0       0x50009    0
w^7     0       0       0          0

*/

include "global.pil";

namespace Byte4(%N);
    /// Constant Polynomials
    pol constant SET;    // 1, 0, 1, 0, 1, 0 ......

    /// State Polynomials
    pol commit freeIN;
    pol commit out;

    freeIN in Global.BYTE2;  // 0, 1, 2,       , 65535

    out' = SET*freeIN +
           (1-SET)*(out * 2**16 + freeIN);

2.3 Arith.pil隐私多项式赋值

给Arith的input为：

required.Arith.push({x1: A, y1: B, x2: C, y2: D, x3: Fr.zero, y3: op, selEq0: 1, selEq1: 0, selEq2: 0, selEq3: 0});

本例中具体值为：

A: 14474011154664524427946373126085988481658748083205070504932198000989141204993 (0x2000000000000000000000000000000000000000000000000000000000000001)
B: 256 (0x100)
C: 115 (0x73)
D: 32 (0x20)
op: 371 (0x173)

满足的EQ0关系为： $A*B+C=D*2^{256}+op$ 。

arith.pil中的常量多项式赋值见：Polygon zkEVM中的常量多项式中“7. arith.pil中的常量多项式”。

仍然以EQ0为例， $\begin{aligned} \text{EQ}_0 \colon \quad &x_1 \cdot y_1 + x_2 - y_2 \cdot 2^{256} - y_3 = 0\end{aligned}$ ，将每个寄存器以16个16bit寄存器表示，并借助school multiplication算法：

从而有：

第0步： $\mathbf{eq}_0 = (x_1[0] \cdot y_1[0]) + x_2[0] - y_3[0]$ .
第1步： $\mathbf{eq}_1 = (x_1[0] \cdot y_1[1]) + (x_1[1] \cdot y_1[0]) + x_2[1] - y_3[1]$ .
第2步： $\mathbf{eq}_2 = (x_1[0] \cdot y_1[2]) + (x_1[1] \cdot y_1[1]) + (x_1[2] \cdot y_1[0]) + x_2[2] - y_3[2]$ .
第15步： $\mathbf{eq}_{15} = (x_1[0] \cdot y_1[15]) + (x_1[1] \cdot y_1[14]) + \dots + x_2[15] - y_3[15]$ .
第16步，此时才会引入 $y_2$ ，且 $x_2,y_3$ 已处理完毕： $\mathbf{eq}_{16} = (x_1[1] \cdot y_1[15]) + (x_1[2] \cdot y_1[14]) + \dots - y_2[0]$
第17步： $\mathbf{eq}_{17} = (x_1[2] \cdot y_1[15]) + (x_1[3] \cdot y_1[14]) + \dots - y_2[1]$
$\cdots$
第31步： $\mathbf{eq}_{31}=-y_2[15]$ 。

相应的计算见：sm_arith_eq0.js。
不过，以上计算中未考虑进位（carry）的情况。需引入临时变量let carry = [0n, 0n, 0n];来存储进位信息（ $\mathbf{eq}+\text{carry}=\text{carry}'\cdot 2^{16}$ ），并将每一步累计的进位信息分别存储在carryL和carryH两个寄存器中： $\text{carry} = \text{carry}_L + \text{carry}_H \cdot 2^{18}$ 。

 		let carry = [0n, 0n, 0n];
        const eqIndexToCarryIndex = [0, 0, 0, 1, 2];
		for (let step = 0; step < 32; ++step) {
            eqIndexes.forEach((eqIndex) => {
                let carryIndex = eqIndexToCarryIndex[eqIndex];
                eq[eqIndex] = eqCalculates[eqIndex](pols, step, offset); //调用sm_arith_eq0.js
                pols.carryL[carryIndex][offset + step] = Fr.e((carry[carryIndex]) % (2n**18n));
                pols.carryH[carryIndex][offset + step] = Fr.e((carry[carryIndex]) / (2n**18n));
                carry[carryIndex] = (eq[eqIndex] + carry[carryIndex]) / (2n ** 16n);
            });
        }

arith.pil中包含的约束有：

1）使用CLK[31]寄存器，对x1,y1,x2,y2,x3,y3,s,q0,q1,q2,selEq[0-3]进行锁存。

2）限定x1,y1,x2,y2,x3,y3,s,q0,q1,q2（为16个16-bit寄存器）中每个寄存器的取值范围为

0,2^{16}-1]

，使用plookup约束。如：

x1[0]*CLK[0] + x1[1]*CLK[1] + x1[2]*CLK[2] + x1[3]*CLK[3] + x1[4]*CLK[4] + x1[5]*CLK[5] + x1[6]*CLK[6] + x1[7]*CLK[7]
   + x1[8]*CLK[8] + x1[9]*CLK[9] + x1[10]*CLK[10] + x1[11]*CLK[11] + x1[12]*CLK[12] + x1[13]*CLK[13] + x1[14]*CLK[14] + x1[15]*CLK[15]
   + y1[0]*CLK[16] + y1[1]*CLK[17] + y1[2]*CLK[18] + y1[3]*CLK[19] + y1[4]*CLK[20] + y1[5]*CLK[21] + y1[6]*CLK[22] + y1[7]*CLK[23]
   + y1[8]*CLK[24] + y1[9]*CLK[25] + y1[10]*CLK[26] + y1[11]*CLK[27] + y1[12]*CLK[28] + y1[13]*CLK[29] + y1[14]*CLK[30] + y1[15]*CLK[31] in Global.BYTE2;

3）以eq0为例，按以上0~31步计算：EQ0: A(x1) * B(y1) + C(x2) = D (y2) * 2 ** 256 + op (y3)

4）将每一步的eq0_i求和：

pol eq0 = eq0_0*CLK[0] + eq0_1*CLK[1] + eq0_2*CLK[2] + eq0_3*CLK[3] + eq0_4*CLK[4] + eq0_5*CLK[5] + eq0_6*CLK[6] + eq0_7*CLK[7]
   + eq0_8*CLK[8] + eq0_9*CLK[9] + eq0_10*CLK[10] + eq0_11*CLK[11] + eq0_12*CLK[12] + eq0_13*CLK[13] + eq0_14*CLK[14] + eq0_15*CLK[15]
   + eq0_16*CLK[16] + eq0_17*CLK[17] + eq0_18*CLK[18] + eq0_19*CLK[19] + eq0_20*CLK[20] + eq0_21*CLK[21] + eq0_22*CLK[22] + eq0_23*CLK[23]
   + eq0_24*CLK[24] + eq0_25*CLK[25] + eq0_26*CLK[26] + eq0_27*CLK[27] + eq0_28*CLK[28] + eq0_29*CLK[29] + eq0_30*CLK[30] + eq0_31*CLK[31];

5）限定selEq[0]、selEq[1]、selEq[2]、selEq[3]的取值只能为0或1：

selEq[0] * (1-selEq[0]) = 0;
selEq[1] * (1-selEq[1]) = 0;
selEq[2] * (1-selEq[2]) = 0;
selEq[3] * (1-selEq[3]) = 0;

6）使用CLK[0]寄存器，对carryL[0-2]以及carryH[0-2]进行锁存。与CLK[31]的锁存逻辑相反。
7）限定carryL[0-2]的取值范围为 $0,2^{18}-1]$ ，使用plookup约束。
```
carryL[0] in GL_SIGNED_18BITS;
carryL[1] in GL_SIGNED_18BITS;
carryL[2] in GL_SIGNED_18BITS;
```

8）限定carryH[0]、carryH[1]、carryH[2]的取值，使用plookup约束：

{carryH[0], carryH[1], carryH[2]} in {GL_SIGNED_4BITS_C0, GL_SIGNED_4BITS_C1, GL_SIGNED_4BITS_C2}; // 3 * (4+1) = 15 bits

9）对各步中的进位进行约束：

// eq + carry = carry' * 2**16
// carry = cl + ch * 2**18
// eq + cl + ch * 2**18 = cl 2**16 + ch * 2**34

selEq[0] * (eq0 + carryL[0] + 2**18 * carryH[0]) = selEq[0] * (carryL[0]' * 2**16 + carryH[0]' * 2**34);

参考资料

[1] The Arithmetic State Machine

附录：Polygon Hermez 2.0 zkEVM系列博客

ZK-Rollups工作原理
Polygon zkEVM——Hermez 2.0简介
Polygon zkEVM网络节点
Polygon zkEVM 基本概念
Polygon zkEVM Prover
Polygon zkEVM工具——PIL和CIRCOM
Polygon zkEVM节点代码解析
Polygon zkEVM的pil-stark Fibonacci状态机初体验
Polygon zkEVM的pil-stark Fibonacci状态机代码解析
Polygon zkEVM PIL编译器——pilcom 代码解析

你可能感兴趣的:(zkVM,零知识证明)

零知识证明-公钥分发方案DH(（六） yunteng521 区块链零知识证明算法区块链密钥分发 DH
前言椭圆曲线配对，是各种加密构造方法(包括确定性阀值签名、zk-SNARKs以及相似的零知识证明)的关键元素之一。椭圆曲线配对(也叫“双线性映射”)有了30年的应用历史，然而最近这些年才把它应用在密码学领域。配对带来了一种“加密乘法”的形式，这很大的拓展了椭圆曲线协议的应用范围。本文的目的是详细介绍椭圆曲线配对，并大致解释它的内部原理先了解DH协议Diffie-Hellman协议简称DH，是一种公
零知识证明：哈希函数-Poseidon2代码解析与benchmark HIT夜枭零知识证明零知识证明哈希算法区块链
1、哈希函数(HashFunction)与Poseidon在密码学中，哈希函数是一种将任意大小的数据映射到固定大小的输出的函数。哈希函数的输出称为哈希值或哈希码。哈希函数具有单向性和抗碰撞性。一些常见的哈希函数包括MD5、SHA-1、SHA-256和SHA-3。例如，假设您要验证一个文件的完整性。您可以使用哈希函数来计算该文件的哈希值。然后，您可以将该哈希值与文件的预期哈希值进行比较。如果两个哈希
零知识证明框架：gnark 孙绿如叶～零知识证明(ZKP)密码学
一.zkSNARKs的一般构造流程首先将一个NP问题拍平（Flatten）构成电路（若干个乘法门/加法门构成），在电路的基础上构造约束，也就是R1CS，有了约束就可以把NP问题抽象成QAP问题。有了QAP问题的描述，就可以在QAP上构建zkSNARKs。二.gnarkgnark是consenSys开发的一个zkSARNK实现，采用Go语言，目前支持groth16，github地址：https://
实践指南：构建一个零知识证明 DApp [译] 扣3039046426 区块链
实践指南：构建一个零知识证明DApp[译]零知识证明DAppcircomsnarkjs本文将构建一个zk-dApp（零知识证明DApp），以证明用户是否属于某个特定组，而无需透露用户具体是谁。阅读本文前，最好先对以下内容有所了解：public-keycryptographycircom及snarkjs使用truffle使用ethers连接合约前言在过去的几个月中，我在以太坊eth上利用了零知识证明
Zcash-草稿歌白梨
Zcash，也叫大零币，从zerocoin发展而来，是使用零知识证明机制的区块链系统，通过完全匿名交易特性在区块链的生态中独树一帜。现在，Zcash市值是41.10亿。2016年10月28日，ZEC从比特币代码库0.11上分叉，所以他可以算比特币的一个克隆体，与比特币一样，Zcash（ZEC）的总量是2100万，采用PoW共识机制。与比特币不同的是，为了防止矿霸的产生，ZEC的加密不是通过SHA2
SP1：基于Plonky3构建的zkVM mutourend zkVM zkVM
1.引言SP1为SuccictLab开源的，基于Plonky3构建的zkVM。开源代码见：https://github.com/succinctlabs/sp1（Rust）当前暂未实现onchain-verifier，但会采用标准的STARK->SNARKverifier。SP1zkVM基于的指令集为：riscv32im（与RISCZero的指令集一样）在SP1zkVM中运行某程序之前，需将该程序
金融科技力 nightluo 基础学习金融科技
金融科技区块链二级目录三级目录区块链区块链安全：保密性、完整性、可用性最重要的点：保密性零知识证明：1、完整性（真的假不了）2、可靠性（假的真不了）3、零知识性（知道真的，但是不需要知道内容）共识算法安全：抗崩溃性与容错性确定性终结与概率终结FLP不可能性：在完全异步消息系统中如果单个节点发生故障，则不可能达成共识安全性与活性CAP定理：只能得到三个中的两个去中心化、可扩展性和安全三角“参数永远是
如何在JavaScript项目中使用 zk-SNARK chinadefi javascript rust 开发语言
如何在JavaScript项目中使用zk-SNARK[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-4fQgcXkV-1675312908395)(https://tva1.sinaimg.cn/large/e6c9d24ely1gzmazs79m1g20tr04ojug.gif)]MariaCappelli在Unsplash上上传的照片零知识证明技术，尤其是zk-S
链化未来技术系列分享(1) - 零知识证明区块奇点
11月29日，链化未来在杭州举办主题为“区块链硬核技术揭密——零知识证明及跨链深度解读”线下活动内容分享。本文为零知识证明篇相关PPT内容。目录>什么是零知识证明>链化未来零知识证明组件>实践,跨链,资产交易摘要内容本次活动，密码学家王虎森介绍了链化未来零知识证明组件在技术上相对以太坊的优势，以及在具体业务如跨链、资产转移、个人数据隐私保护方面的应用。相比以太坊，链化未来的零知识证明组件在成本、可
OSDI 2023: LVMT: An Efficient Authenticated Storage for Blockchain 结构化文摘区块链分层架构共识存储结构
我们使用以下6个分类标准对本文的研究选题进行分析：1.研究方向:区块链可扩展性:提高交易吞吐量和减少确认时间的研究，例如零知识证明、分片和状态通道。密码学技术:开发或改进用于区块链应用的新密码原语，例如椭圆曲线、承诺方案和累加器。区块链存储和效率:优化区块链上的数据存储和检索，例如认证存储、Patricia树和数据压缩。共识机制:设计新的共识协议，例如拜占庭容错算法，用于更快速、更安全的区块验证。
什么是零知识证明？慎思知行 BlockChain 零知识证明区块链
Web3的核心原则之一——透明度，也可能是其最大的缺点之一。没有人希望他们的所有在线活动（从金融交易到个人身份数据）都可供任何人公开查看。为了使区块链能够扩展并变得更容易访问，隐私必须成为首要任务。零知识证明能够改变我们保护、管理和共享个人数据的方式。它们允许人们在不泄露信息本身的情况下证明陈述的真实性，从而为涉及敏感、机密信息的交易带来了新的隐私级别。什么是零知识证明？零知识证明（通常缩写为“Z
探析零知识证明高能发展路径：走向更安全、私密且可扩展的 Web3 新时代 TinTin Land Web3 前沿零知识证明安全 web3
原文：https://www.coinbase.com/blog/understanding-the-zero-knowledge-landscape作者：JonathanKing｜CoinbaseVentures编译：TinTinLand本文核心观点2023年，零知识技术吸引了逾4亿美元的投资，主要关注以太坊L1/L2协议层的可扩展性，以及新兴的基础设施和开发者工具。零知识证明（Zero-Kno
解读ALEO-继FIL后又一个由A16Z和软银领投过亿美元的隐私公链项目米斯特鞏软银 FIL 隐私保护 rust 哈希算法 p2p 网络协议
自从今年2月份ALEO融资了由软银领投，三星、老虎环球基金等众多机构跟投的2亿美元后，市场逐渐开始关注ALEO，目前从官方的公开资料看没有太多华丽的介绍，基本都是较专业的内容，今天我从几个方面综合概述一下ALEO的特性，从中也能发现ALEO的真正价值：1、模块化区块链：可组合性，可扩展性2、隐私：zkp零知识证明技术主要解决隐私和可扩展性问题3、兼容以太坊：生态兼容性好4、posw共识机制：基于比
Aleo项目详细介绍-一个兼顾隐私和可编程性的隐私公链慎思知行区块链
Aleo上线在即，整理一篇项目的详细介绍，喜欢的收藏。有计划做aleo节点的可交流。一、项目简介Aleo最初是在2016年构思的，旨在研究可编程零知识。公司由HowardWu、MichaelBeller、CollinChin和RaymondChu于2019年正式成立。Aleo是第一个采用零知识证明（ZKP）技术，提供私有、开源的Layer1区块链。Aleo开发了一个默认交易隐私的应用程序构建平台，
区块链精进手册 | 021 | 大师的投资思想（2）马烈视界
1.一种通证：ZECZEC是Zcash区块链网络中的通证，中文常备成为“零币”。ZEC发行总量恒定，为2100万枚，现已发行433余万枚，总市值达6.66亿，排行第21位。由于比特币的非匿名性，但实际货币有着匿名性需求，Zerocoin团队在比特币0.11.2的版本上修改了代码，添加了“零知识证明”技术，想让比特币更具匿名性。比特币团队拒绝在原链上升级，原开发者团队成立了ZerocoinElect
NuLink介绍二晨酱
4.NuLink主要使用技术4.1确保密文形式的数据的可用性。这里使用的加密技术主要是零知识证明。4.2隐私保护的数据共享。使用到的基本方法是对数据进行加密，让数据所有者控制对它的访问。这些技术包括去中心化加密存储、代理重加密、基于身份的加密和基于属性的加密等。4.3隐私保护数据的计算，这部分会将某些隐私计算能力集成到智能合约中。使用的技术包括多方安全计算(multi-partysecurecom
零知识证明学习 Ameame- 学习
文档，测试claimPK.zokimport"hashes/sha256/512bitPadded.zok"assha256;import"utils/pack/u32/nonStrictUnpack256.zok"asunpack256;import"utils/pack/u32/unpack128.zok"asunpack128;import"utils/pack/u32/pack128.zo
零知识证明的最新发展和应用 PrimiHub 零知识证明区块链密码学可信计算技术同态加密 github
PrimiHub一款由密码学专家团队打造的开源隐私计算平台，专注于分享数据安全、密码学、联邦学习、同态加密等隐私计算领域的技术和内容。当企业收集大量客户数据去审查、改进产品和服务以及将数据资产货币化时，他们容易受到网络攻击威胁，造成数据泄露。数据泄露的损失每年都在上升，每次泄露平均造成损失420万美元，如下图所示，它们严重损害了企业的声誉和可信度。数据泄露的成本零知识证明(ZKPs)等隐私增强技术
2022-02-05 Aaron阿酷
NuLink介绍（四）7.解决方案详细说明 7.1数据可用性作为一个专注于数据隐私的平台，我们首先需要解决的就是数据可用性问题。这个问题往往分为两部分:第一是消费者在购买前如何确定卖家是否有自己需要的数据，第二是如何验证在密文状态下的数据是否真实。在NuLink网络中，这两个问题可以通过零知识证明技术来解决:数据所有者需要在数据授权前提供零知识证明。事实上，密文状态下的证明方法与明文状态下的证
Web3.0会带来哪些机遇？ Aix17
NuLink的零知识证明介绍作者简介：作为NuLinkTechnology的研究员，Rookie是一位激情的创新者，他专注于密码学和区块链技术。翻译：Reversing作为NuLink项目的高级研究员，我一直致力于密码学和隐私保护的研究。多年来，这个领域一直有一个有趣的话题，那就是ZKP（ZeroKnowledgeProof，零知识证明）。最近它在社区中引起了很多关注，因为有很多有趣的场景可以讨论
零知识证明（zk-SNARK）- groth16（一） Amire0x 密码学-隐私计算零知识证明区块链
全称为Zero-KnowledgeSuccinctNon-InteractiveArgumentofKnowledge，简洁非交互式零知识证明，简洁性使得运行该协议时，即便statement非常大，它的proof大小也仅有几百个bytes，并且验证一个proof的时间可以达到毫秒级别。这是一个通用的零知识证明协议，可以用作各种证明，如范围证明。核心方法是通过R1CS，QAP等方法将计算难题变为多项
RISC Zero zkVM Host & Guest 101 mutourend zkVM zkVM
1.引言在RISCZerozkVM应用程序中，host为运行RISCZerozkVM的机器（或系统）。host为不可信agent，负责设置zkVM环境和处理执行过程中的输入输出。host程序（代码），是指：zkVM应用中的host-native、不可信的部分。负责加载guest程序，并为guest程序提供必要的输入。若基于Bonsai构建，则无需编写host代码。zkVM应用中，host负责构建并
2023海内外零知识证明学习资料汇总（一）（故事中的零知识证明篇）滕王阁配黑马打火机零知识证明区块链 web3 学习
工欲善其事,必先利其器Web3开发中，各种工具、教程、社区、语言框架.。。。种类繁多，是否有一个包罗万象的工具专注与Web3开发和相关资讯能毕其功于一役？参见另一篇博文2024最全面且有知识深度的web3开发工具、web3学习项目资源平台本文收集了关于零知识证明的一些学习资料（包括科普文章，论文，开源仓库及相关学习网站等），并对这些资源进行了整理分析，希望能对大家有所帮助。本文收集了关于零知识证明
2023海内外零知识证明学习资料汇总（二）（深入理解零知识证明篇）滕王阁配黑马打火机零知识证明区块链 web3 学习
工欲善其事,必先利其器Web3开发中，各种工具、教程、社区、语言框架.。。。种类繁多，是否有一个包罗万象的工具专注与Web3开发和相关资讯能毕其功于一役？参见另一篇博文2024最全面且有知识深度的web3开发工具、web3学习项目资源平台本文收集了关于零知识证明的一些学习资料（包括科普文章，论文，开源仓库及相关学习网站等），并对这些资源进行了整理分析，希望能对大家有所帮助。书接上篇，器欲尽其能,必
2022-02-24 Aaron阿酷
通过集成一流的技术，我们正在建立强大的技术基础。1.保证密文形式数据的可用性。这里使用的加密技术主要包括零知识证明。2.隐私保护数据共享。一般的方法是对数据进行加密，让数据所有者控制对它的访问。技术包括去中心化加密存储、代理重加密、基于身份的加密和基于属性的加密等。3.隐私数据计算，涉及将某些隐私计算能力集成到智能合约中。使用的技术包括多方安全计算、同态加密等。这三种技术方案可以在很多应用领域提供
区块链在未来企业中将会是什么样的角色？徽纯正
如今区块链的技术引发太多的讨论。区块链在企业中的角色是什么?越来越多的公司正在测试区块链的力量，通过分布式记账技术来做交易和追踪资产。以下是区块链今后的趋势预测:图片发自App1区块链将从试点转移到生产。区块链在世界各地都出现了试点项目。随着这些试点和概念验证的成熟，它们将被抛弃，然后将会向生产系统前进。这一过程将成为一个必要的调整。2零知识证明的使用将会提高。区块链将成为企业间交易的平台。这个平
dalek-cryptography/zkp——基于merlin的Schnorr零知识证明 mutourend
zkp为使用merlin的Schnorr零知识证明工具包，基于ristrettogroup做的实例化。【ristretto为对cofactor>1曲线的抽象，ristretto对外表现为将non-prime-order的曲线抽象为aprime-ordergroup。具体的细节可参见博客1ristretto对cofactor>1的椭圆曲线(如Curve25519等)的兼容（含Curve25519co
NuLink介绍一晨酱
1.NuLink介绍NuLink网络是一种为开发隐私保护APP的技术人员们提供最佳操作方案的去中心化解决方案，且是同类型中最优质的安全和隐私保护方案。NuLink平台提供端点加密和密码访问控制，任何敏感数据都可以从其他用户平台非常安全地共享到云端或者去中心化的储存设备，并根据代理重加密和属性加密协议，自动授权对云端或设备中敏感数据的访问。另一方面，零知识证明可以帮助验证数据的来源。在更多的高级隐私
密码极客分享：4个被知名机构投资的项目 CryptoGeek 区块链区块链比特币 CODA MakerDAO Coinbase
1CodaCoda是第一个具有简洁区块链的加密货币协议，是一种将区块链数据通过零知识证明压缩到固定字节大小的新型数字货币。当前的加密货币（如比特币和以太坊）存储数百GB的数据，随着时间的流逝，其区块链的大小只会增加。但是，对于Coda，无论使用量增长多少，区块链始终保持相同的大小-约20KB（几条推文的大小）。这意味着无论执行多少交易，验证区块链仍然很便捷，并且每个人都可以访问，更可以将加密货币无
ZK*FM：RISC Zero zkVM的形式化验证 mutourend zkVM zkVM
1.引言开源代码见：https://github.com/risc0/risc0-lean4（Lean和Rust）ZK*FM为RISCZerozkVM的形式化验证：ZK：Thecomputerrantherightprogram。FM：Theprogramdidtherightthing。ZK*FM：Thecomputerdidtherightthing。可使用FM来证明RISCZero的ZKto
js动画html标签（持续更新中） 843977358 html js 动画 media opacity
1.jQuery 效果 - animate() 方法改变 "div" 元素的高度： $(".btn1").click(function(){ $("#box").animate({height:"300px
springMVC学习笔记 caoyong springMVC
1、搭建开发环境 a>、添加jar文件，在ioc所需jar包的基础上添加spring-web.jar,spring-webmvc.jar b>、在web.xml中配置前端控制器 <servlet> &nbs
POI中设置Excel单元格格式 107x poi style 列宽合并单元格自动换行
引用：http://apps.hi.baidu.com/share/detail/17249059 POI中可能会用到一些需要设置EXCEL单元格格式的操作小结：先获取工作薄对象: HSSFWorkbook wb = new HSSFWorkbook(); HSSFSheet sheet = wb.createSheet(); HSSFCellStyle setBorder = wb.
jquery 获取A href 触发js方法的this参数无效的情况一炮送你回车库 jquery
html如下： <td class=\"bord-r-n bord-l-n c-333\"> <a class=\"table-icon edit\" onclick=\"editTrValues(this);\">修改</a> </td>" j
md5 3213213333332132 MD5
import java.security.MessageDigest; import java.security.NoSuchAlgorithmException; public class MDFive { public static void main(String[] args) { String md5Str = "cq
完全卸载干净Oracle11g sophia天雪 orale数据库卸载干净清理注册表
完全卸载干净Oracle11g A、存在OUI卸载工具的情况下：第一步：停用所有Oracle相关的已启动的服务；第二步：找到OUI卸载工具：在“开始”菜单中找到“oracle_OraDb11g_home”文件夹中 &
apache 的access.log 日志文件太大如何解决 darkranger apache
CustomLog logs/access.log common 此写法导致日志数据一致自增变大。直接注释上面的语法 #CustomLog logs/access.log common 增加： CustomLog "|bin/rotatelogs.exe -l logs/access-%Y-%m-d.log
Hadoop单机模式环境搭建关键步骤 aijuans 分布式
Hadoop环境需要sshd服务一直开启，故，在服务器上需要按照ssh服务，以Ubuntu Linux为例，按照ssh服务如下： sudo apt-get install ssh sudo apt-get install rsync 编辑HADOOP_HOME/conf/hadoop-env.sh文件，将JAVA_HOME设置为Java
PL/SQL DEVELOPER 使用的一些技巧 atongyeye java sql
1 记住密码这是个有争议的功能，因为记住密码会给带来数据安全的问题。但假如是开发用的库，密码甚至可以和用户名相同，每次输入密码实在没什么意义，可以考虑让PLSQL Developer记住密码。位置：Tools菜单－－Preferences－－Oracle－－Logon HIstory－－Store with password 2 特殊Copy 在SQL Window
PHP：在对象上动态添加一个新的方法 bardo 方法动态添加闭包
有关在一个对象上动态添加方法，如果你来自Ruby语言或您熟悉这门语言，你已经知道它是什么...... Ruby提供给你一种方式来获得一个instancied对象，并给这个对象添加一个额外的方法。好！不说Ruby了，让我们来谈谈PHP PHP未提供一个“标准的方式”做这样的事情，这也是没有核心的一部分... 但无论如何，它并没有说我们不能做这样
ThreadLocal与线程安全 bijian1013 java java多线程 threadLocal
首先来看一下线程安全问题产生的两个前提条件： 1.数据共享，多个线程访问同样的数据。 2.共享数据是可变的，多个线程对访问的共享数据作出了修改。实例：定义一个共享数据： public static int a = 0;
Tomcat 架包冲突解决征客丶 tomcat Web
环境： Tomcat 7.0.6 win7 x64 错误表象：【我的冲突的架包是：catalina.jar 与 tomcat-catalina-7.0.61.jar 冲突，不知道其他架包冲突时是不是也报这个错误】严重: End event threw exception java.lang.NoSuchMethodException: org.apache.catalina.dep
【Scala三】分析Spark源代码总结的Scala语法一 bit1129 scala
Scala语法 1. classOf运算符 Scala中的classOf[T]是一个class对象，等价于Java的T.class,比如classOf[TextInputFormat]等价于TextInputFormat.class 2. 方法默认值 defaultMinPartitions就是一个默认值，类似C++的方法默认值
java 线程池管理机制 BlueSkator java线程池管理机制
编辑 Add Tools jdk线程池一、引言第一：降低资源消耗。通过重复利用已创建的线程降低线程创建和销毁造成的消耗。第二：提高响应速度。当任务到达时，任务可以不需要等到线程创建就能立即执行。第三：提高线程的可管理性。线程是稀缺资源，如果无限制的创建，不仅会消耗系统资源，还会降低系统的稳定性，使用线程池可以进行统一的分配，调优和监控。
关于hql中使用本地sql函数的问题（问-答） BreakingBad HQL 存储函数
转自于：http://www.iteye.com/problems/23775 问：我在开发过程中，使用hql进行查询（mysql5）使用到了mysql自带的函数find_in_set()这个函数作为匹配字符串的来讲效率非常好，但是我直接把它写在hql语句里面（from ForumMemberInfo fm,ForumArea fa where find_in_set(fm.userId,f
读《研磨设计模式》-代码笔记-迭代器模式-Iterator bylijinnan java 设计模式
声明：本文只为方便我个人查阅和理解，详细的分析以及源代码请移步原作者的博客http://chjavach.iteye.com/ import java.util.Arrays; import java.util.List; /** * Iterator模式提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象内部表示 * * 个人觉得，为了不暴露该
常用SQL chenjunt3 oracle sql C++c C#
--NC建库 CREATE TABLESPACE NNC_DATA01 DATAFILE 'E:\oracle\product\10.2.0\oradata\orcl\nnc_data01.dbf' SIZE 500M AUTOEXTEND ON NEXT 50M EXTENT MANAGEMENT LOCAL UNIFORM SIZE 256K ; CREATE TABLESPA
数学是科学技术的语言 comsci 工作活动领域模型
从小学到大学都在学习数学，从小学开始了解数字的概念和背诵九九表到大学学习复变函数和离散数学，看起来好像掌握了这些数学知识，但是在工作中却很少真正用到这些知识，为什么？最近在研究一种开源软件-CARROT2的源代码的时候，又一次感觉到数学在计算机技术中的不可动摇的基础作用，CARROT2是一种用于自动语言分类（聚类）的工具性软件，用JAVA语言编写，它
Linux系统手动安装rzsz 软件包 daizj linux sz rz
1、下载软件 rzsz-3.34.tar.gz。登录linux，用命令 wget http://freeware.sgi.com/source/rzsz/rzsz-3.48.tar.gz下载。 2、解压 tar zxvf rzsz-3.34.tar.gz 3、安装 cd rzsz-3.34 ; make posix 。注意：这个软件安装与常规的GNU软件不
读源码之:ArrayBlockingQueue dieslrae java
ArrayBlockingQueue是concurrent包提供的一个线程安全的队列,由一个数组来保存队列元素.通过 takeIndex和 putIndex来分别记录出队列和入队列的下标,以保证在出队列时不进行元素移动. //在出队列或者入队列的时候对takeIndex或者putIndex进行累加,如果已经到了数组末尾就又从0开始,保证数
C语言学习九枚举的定义和应用 dcj3sjt126com c
枚举的定义 # include <stdio.h> enum WeekDay { MonDay, TuesDay, WednesDay, ThursDay, FriDay, SaturDay, SunDay }; int main(void) { //int day; //day定义成int类型不合适 enum WeekDay day = Wedne
Vagrant 三种网络配置详解 dcj3sjt126com vagrant
Forwarded port Private network Public network Vagrant 中一共有三种网络配置，下面我们将会详解三种网络配置各自优缺点。端口映射(Forwarded port)，顾名思义是指把宿主计算机的端口映射到虚拟机的某一个端口上，访问宿主计算机端口时，请求实际是被转发到虚拟机上指定端口的。Vagrantfile中设定语法为： c
16.性能优化-完结 frank1234 性能优化
性能调优是一个宏大的工程，需要从宏观架构(比如拆分，冗余，读写分离，集群，缓存等)，软件设计（比如多线程并行化，选择合适的数据结构），数据库设计层面（合理的表设计，汇总表，索引，分区，拆分，冗余等）以及微观（软件的配置，SQL语句的编写，操作系统配置等）根据软件的应用场景做综合的考虑和权衡，并经验实际测试验证才能达到最优。性能水很深，笔者经验尚浅，赶脚也就了解了点皮毛而已，我觉得
Word Search hcx2013 search
Given a 2D board and a word, find if the word exists in the grid. The word can be constructed from letters of sequentially adjacent cell, where "adjacent" cells are those horizontally or ve
Spring4新特性——Web开发的增强 jinnianshilongnian spring spring mvc spring4
Spring4新特性——泛型限定式依赖注入 Spring4新特性——核心容器的其他改进 Spring4新特性——Web开发的增强 Spring4新特性——集成Bean Validation 1.1(JSR-349)到SpringMVC Spring4新特性——Groovy Bean定义DSL Spring4新特性——更好的Java泛型操作API Spring4新
CentOS安装配置tengine并设置开机启动 liuxingguome centos
yum install gcc-c++ yum install pcre pcre-devel yum install zlib zlib-devel yum install openssl openssl-devel Ubuntu上可以这样安装 sudo aptitude install libdmalloc-dev libcurl4-opens
第14章工具函数（上） onestopweb 函数
index.html <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/
Xelsius 2008 and SAP BW at a glance blueoxygen BO Xelsius
Xelsius提供了丰富多样的数据连接方式，其中为SAP BW专属提供的是BICS。那么Xelsius的各种连接的优缺点比较以及Xelsius是如何直接连接到BEx Query的呢？以下Wiki文章应该提供了全面的概览。 http://wiki.sdn.sap.com/wiki/display/BOBJ/Xcelsius+2008+and+SAP+NetWeaver+BW+Co
oracle表空间相关 tongsh6 oracle
在oracle数据库中，一个用户对应一个表空间，当表空间不足时，可以采用增加表空间的数据文件容量，也可以增加数据文件，方法有如下几种： 1.给表空间增加数据文件 ALTER TABLESPACE "表空间的名字" ADD DATAFILE '表空间的数据文件路径' SIZE 50M; &nb
.Net framework4.0安装失败 yangjuanjava .net windows
上午的.net framework 4.0，各种失败，查了好多答案，各种不靠谱，最后终于找到答案了和Windows Update有关系，给目录名重命名一下再次安装，即安装成功了！下载地址：http://www.microsoft.com/en-us/download/details.aspx?id=17113 方法： 1.运行cmd，输入net stop WuAuServ 2.点击开