task2示例代码问题

[Einstellung]

来自mina-sz的示例代码

class VoteState extends Struct({
    teammates: Provable.Array(PublicKey, MEMBER_CNT),// 初始化时固定了队员个数为MEMBER_CNT
    voteFor: Field,
    voteAgainst: Field
}) {
    static applyVote(
        state0: VoteState,
        voteFor: Bool,
        privateKey: PrivateKey
    ) {
        state0.voteAgainst.add(state0.voteFor).assertLessThan(MEMBER_CNT);

        const publicKey = privateKey.toPublicKey();

        // 对于大团队的场景，应该优化：采用merkle tree做成员证明
        let isMember = Bool(false);
        for (let i = 0; i < MEMBER_CNT; i++) {
            isMember = isMember.or(Provable.if(state0.teammates[i].equals(publicKey), Bool(true), Bool(false)));
        }
        isMember.assertTrue();

        return new VoteState({
            teammates: state0.teammates,
            voteFor: state0.voteFor.add(Provable.if(voteFor, Field(1), Field(0))),
            voteAgainst: state0.voteAgainst.add(Provable.if(voteFor, Field(0), Field(1)))
        });
    }

    static assertInitialState(state: VoteState) {
        for (let i = 0; i < MEMBER_CNT; i++) {
            const e = state.teammates[i];
            e.equals(PublicKey.empty()).assertFalse();
        }
        state.voteFor.assertEquals(Field(0))
        state.voteAgainst.assertEquals(Field(0))
    }

    static checkEqual(state0: VoteState, state1: VoteState) {
        for (let i = 0; i < MEMBER_CNT; i++) {
            state0.teammates[i].assertEquals(state1.teammates[i]);
        }
        state0.voteFor.assertEquals(state1.voteFor)
        state0.voteAgainst.assertEquals(state1.voteAgainst)
    }
}

let VoteProgram = ZkProgram({
    name: 'example-with-vote',
    publicInput: VoteState,

    methods: {
        initVoteState: {
            privateInputs: [],
            async method(voteState: VoteState) {
                VoteState.assertInitialState(voteState);
            },
        },

        applyVote: {
            privateInputs: [SelfProof, Bool, PrivateKey],
            async method(appliedVoteState: VoteState, earlierProof: SelfProof<VoteState, void>, voteFor: Bool, privKey: PrivateKey) {
                Provable.log(`1) earlierProof.verify`);
                earlierProof.verify();

                Provable.log(`2) accumulate the vote`);
                const state1 = VoteState.applyVote(earlierProof.publicInput, voteFor, privKey);

                Provable.log(`3) check if the same team & total votes is <= team members`);
                VoteState.checkEqual(state1, appliedVoteState);

            },
        },
    },
});

let applyVoteAndProve = async (lastProof: Proof<VoteState, void>, voteFor: Bool, teammateKey: PrivateKey) => {
    // 电路外计算好并收集好需要送入电路的数据
    let lastVoteState = lastProof.publicInput;
    let voteState = new VoteState({
        teammates: lastVoteState.teammates,
        voteFor: Provable.if(voteFor, lastVoteState.voteFor.add(1), lastVoteState.voteFor),
        voteAgainst: Provable.if(voteFor, lastVoteState.voteAgainst, lastVoteState.voteAgainst.add(1)),
    });

    // 送入电路中生成证明
    let proof = await VoteProgram.applyVote(voteState, lastProof, voteFor, teammateKey);

    return proof;
}

我不明白为什么要有外部计算输入，我直接就用

Provable.log(`2) accumulate the vote`);
VoteState.applyVote(earlierProof.publicInput, voteFor, privKey);

随后结束，不要第三步了不行吗？是怕电路自己算的有问题？

[linghuccc]

你在 VSCode 里面看代码，没有错误么？

我打开代码，直接显示 5 个错误

[justice010]

我这边是没有错误的，可以执行

[coldstar1993]

原因有二：
其一：因为电路强调的是证明，所以我的示例的设计是特地遵循"电路外计算好，再送入电路内生成证明"的模式。
VoteProgram.applyVote(appliedVoteState: VoteState, earlierProof: SelfProof<VoteState, void>, voteFor: Bool, privKey: PrivateKey)中的第一个入参appliedVoteState， 是电路外计算好的值，其实已经是当前这轮投票的结果了的，可是我还需要送入电路中做对比以证明此值是等价于"基于earlierProof之上累积当前投票值的"。
其二是为了 统一zkProgram的入参和返回值模式：zkProgram中的所有method的第一个入参都必须相同的(i.e.都是publicInput: VoteState), 加之我设计的示例中的2个method都是没有返回值，即没有计算结果返回的，故我采用了第一个入参作为计算结果。

[Einstellung]

我明白了，类似halo2代码结构是吗像这样？

#[derive(Clone)]
struct MyCircuit<F: Field> {
    // 私有输入
    private_input: Value<F>,
    // 公开输入
    public_input: F,
    // 期望的输出
    expected_output: F,
}

impl<F: Field> Circuit<F> for MyCircuit<F> {
    fn synthesize(...) {
        // 在电路中进行计算
        let result = /* 电路计算逻辑 */;
        
        // 验证计算结果和期望输出一致
        cs.enforce_equal(result.cell(), expected_output.cell());
    }
}

可是我们一般写halo2的时候，在定义时就把public output声明了，但是这个示例代码没有这样的写，看起来十分晦涩，有一点误导性。这是o1js就是要这么写，还是我其实应该在声明的时候加上publicOuput，因为实际根据Method类型他是支持这么做的

Methods extends {
    [I in keyof Config['methods']]: Method<
        InferProvableOrUndefined<Get<Config, 'publicInput'>>,
        InferProvableOrVoid<Get<Config, 'publicOutput'>>,
        Config['methods'][I]
    >;
}

[coldstar1993]

对滴，你这种'publicOutput'写法也行。主要你的每个method的 publicInput 和 publicOutput 都保持一致就行了