Smart Contract accepts any proof as long as types match

[emlautarom1]

According to the docs, we can use proofs created in the browser as parameters for a method in a Smart Contract which will get verified by the contract as follows:

@method foo(proof: Proof) {
  proof.verify().assertTrue();
  /* ... the rest of our method
   * For example using the total value as the fee for some other transaction. */
}

First of all, the previous code does not compile due to:

• Proof being a generic type (Proof<I, O>)
• Not being able to use Proof directly (we need to subclass it).
• assertTrue() is not available due to verify() returning void.

I followed the code in the examples repository (https://github.com/o1-labs/docs2/blob/main/examples/zkapps/09-recursion/src/rollup.ts) and I ended up with the following example:

import { AccountUpdate, Bool, Experimental, Mina, PrivateKey, PublicKey, SmartContract, State, UInt64, method, state } from 'o1js';

export const RealProof = Experimental.ZkProgram({
  methods: {
    make: {
      privateInputs: [UInt64],

      method(value: UInt64) {
        let expected = UInt64.from(34);
        value.assertEquals(expected);
      },
    },
  },
});

export const FakeProof = Experimental.ZkProgram({
  methods: {
    make: {
      privateInputs: [UInt64],

      method(value: UInt64) {
        Bool(true).assertTrue();
      },
    },
  },
});

class BrokenProof extends Experimental.ZkProgram.Proof(RealProof) { }
class Broken extends SmartContract {
  @state(Bool) isValid = State<Bool>();

  init() {
    super.init();
    this.isValid.set(Bool(false));
  }

  @method setValid(proof: BrokenProof) {
    proof.verify();
    this.isValid.set(Bool(true));
  }
}

describe('Broken', () => {
  let deployerAccount: PublicKey;
  let deployerKey: PrivateKey;
  let senderAccount: PublicKey;
  let senderKey: PrivateKey;
  let zkAppAddress: PublicKey;
  let zkAppPrivateKey: PrivateKey;
  let zkApp: Broken;

  beforeAll(async () => {
    await RealProof.compile();
    await FakeProof.compile();
    await Broken.compile();
  });

  beforeEach(() => {
    const Local = Mina.LocalBlockchain({ proofsEnabled: true });
    Mina.setActiveInstance(Local);
    ({ privateKey: deployerKey, publicKey: deployerAccount } = Local.testAccounts[0]);
    ({ privateKey: senderKey, publicKey: senderAccount } = Local.testAccounts[1]);
    zkAppPrivateKey = PrivateKey.random();
    zkAppAddress = zkAppPrivateKey.toPublicKey();
    zkApp = new Broken(zkAppAddress);
  });

  async function localDeploy() {
    const txn = await Mina.transaction(deployerAccount, () => {
      AccountUpdate.fundNewAccount(deployerAccount);
      zkApp.deploy();
    });
    await txn.prove();
    await txn.sign([deployerKey, zkAppPrivateKey]).send();
  }

  it('accepts a fake proof', async () => {
    await localDeploy();

    const value = UInt64.from(99999);
    const fakeProof = await FakeProof.make(value);

    const txn = await Mina.transaction(senderAccount, () => {
      zkApp.setValid(fakeProof);
    });
    await txn.prove();
    await txn.sign([senderKey]).send();

    const isValid = zkApp.isValid.get();
    expect(isValid).toEqual(Bool(true));
  });
});

Note how we're able to use FakeProof despite expecting a RealProof. Either the code above is incorrect (should be written differently), or this is a bug.