Precondition RFC

If users want to add preconditions on the account or protocol state, these will most often relate to the current on-chain state of these fields. A very intuitive model is to let users just "use" the current state -- for example, let them access the "current account balance". The mental model is that this balance is a variable (not a constant!) that depends on the current chain. It can be implemented by fetching the current balance from the chain, using it in the prover as the value for the variable, and adding a precondition which fixes the balance to exactly this value. If we wouldn't add the precondition, then the balance would be unconstrained, which would be against the intuition that we prove a computation which uses the current balance as input.

Therefore, I think a good default is to just let users access the balance (and other fields) as the property of some object, and behind the scenes add the necessary precondition. We propose the following API to achieve that:

// inside method
let balance = this.currentAccount.balance; // automagically adds a precondition
balance.assertLte(100e9); // this method can only be called if current balance <= 100 MINA

Note that to use this API intuitively, one doesn't need to understand the concept of a precondition at all. It's enough to be aware of the this.currentAccount property. The returned balance is a plain UInt64 variable; the added precondition stays completely hidden. Similarly, we propose to have a this.currentProtocolState property which exposes protocol state preconditions. On other parties, we would have corresponding party.currentX properties.

However, advanced users may want to declare arbitrary preconditions. For example, in the above example, it makes sense to actually not use the current balance, but just to add a precondition directly. We propose the following API:

Party.assertBetween(this.accountPrecondition.balance, 0, 100e9);

This works for any party, not just the this party. It mutates this.accountPrecondition.balance, which is the precondition (represented as an object {lower: UInt64, upper: UInt64}.

The last example achieves the same as the first one -- it constrains the balance to be less than 100 MINA -- but without the fragility that the current balance needs to stay unchanged until the transaction is accepted. However, to use an API like this, you do have to understand the concept of a precondition. That's why it's OK to use more jargon ("precondition"), and make this a bit less discoverable (have to use Party), and let it not do any magic. Similar to this.accountPrecondition, we propose to expose this.protocolStatePrecondition, which would just be shortcuts to access party.body.accountPrecondition and party.body.protocolStatePrecondition.

In addition to Party.assertBetween, there is also Party.assertEquals (already implemented), and we could likewise add Party.assertBelow and Party.assertAbove.

Finally, you may want to reference the current state when declaring an arbitrary precondition. For example, possibly you want to restrict the nonce to an interval of the form [currentNonce, currentNonce + tolerance]. Or you may want to restrict it to be exactly currentNonce + 2, because you already know that there'll be 2 earlier transactions which increment the same nonce. For this final use case, we propose the following API:

Party.assertEquals(this.accountPrecondition.nonce, this.currentAccount.nonce.add(2));

This is the precisely same API as before, just making use of this.currentAccount. The logic would be that any explicitly set precondition would override any magically inserted precondition. So, in this case, nonce == currentNonce would be overriden to nonce == currentNonce + 2.

TODO list

• [ ] Implement the this.current* API and, for other parties, party.current*.
• [ ] Implement this.*Precondition and party.*Precondition.
• [x] Implement Party.assertBetween, Party.assertEquals
• [ ] Fetch all account preconditions from chain
• [ ] Fetch all protocol state preconditions from chain
• [ ] Create unit-tests which confirm that
  • setting/fetching all preconditions is possible
  • set preconditions show up in the JSON transaction

It would be convenient to have strings native in snapps. Snapp state could point to a URL with more information about the snapp itself. A username could be included in a circuit, etc...

I have an implementation I have been working on, but I'm wondering what the spec should be if it were to become a PR into the library.

The way my version works is I defined a UInt8 CircuitValue and implemented a StringCircuitValue as an array of UInt8. The primary interface with a snapp is in the fromBits and toBits functions which allow a user to initialize a field as bits, and convert back to a string. e.g.

  it('can serialize and deserialize from Field', () => {
    const input = 'Input String 123'
    const ztring = new StringCircuitValue(input);
    const field = Field.ofBits(ztring.toBits());
    expect(StringCircuitValue.fromBits(ztring.toBits()).toString()).to.eq(input);
    expect(StringCircuitValue.fromBits(field.toBits()).toString().replace(/\0/g, '')).to.eq(input);
  });

I have not thought out edge cases like trying to pack in more than 256 bits of data, nor thought about performance or security. Just worked on the happy path until now. If there's interest in merging something like this into snarky, I would be happy to clean it up. Ideally there would be a spec of what o1 thinks a string ought to behave like, but if not, I'd like to get some feedback regarding concerns or holes I may not have considered. If this implementation doesn't work, then maybe it will spark some discussion to find one that does.

To view my implementation, see these relevant files:

String.ts: https://github.com/qcomps/cachebox/blob/2369e41e55d3b78285cad2cfa9a2d0ef545d4f41/src/lib/snarkyUtils/String.ts

UInt8.ts (other than the relevant parts, this is a lazy port of UInt64, which may not actually work for math): https://github.com/qcomps/cachebox/blob/2369e41e55d3b78285cad2cfa9a2d0ef545d4f41/src/lib/snarkyUtils/UInt8.ts

String.test.ts: https://github.com/qcomps/cachebox/blob/2369e41e55d3b78285cad2cfa9a2d0ef545d4f41/test/snarkyUtils/String.test.ts

UInt8.test.ts: https://github.com/qcomps/cachebox/blob/2369e41e55d3b78285cad2cfa9a2d0ef545d4f41/test/snarkyUtils/UInt8.test.ts

zkApp composability RFC

"zkApp composability" refers to the ability to call zkApp methods from other zkApp methods. Technically, it uses the callData field on the zkApp party to connect the result of the called zkApp to the circuit/proof of the caller zkApp.

An initial spec by @mrmr1993 laying out the ideas for how to use callData can be found here: https://o1-labs.github.io/snapps-txns-reference-impl/target/doc/snapps_txn_reference_impl/call_data/index.html

We propose the following API for snarkyjs:

API

@method myMethod() {
  let calledContract = new CalledContract(address);
  let result = calledContract.calledMethod(arg);
  // .. do anything with result
}

That is, we can just call another method inside a smart contract method. That's the API 😃

NEW: To enable returning a result to another zkApp, the result type must be annotated with a TS type:

class CalledContract extends SmartContract {
  @method calledMethod(arg: UInt64): Bool { // <-- HERE
     // ...
  }
}

The return type annotation is captured by the decorator (like the argument types), and supports all circuit values.

Since it is easy to miss adding this, we take care to catch the case that

• a method is called by another method, and returns something else than undefined
• BUT no return type annotation exists

In this case, the following error is thrown:

Error: To return a result from calledMethod() inside another zkApp, you need to declare the return type.
This can be done by annotating the type at the end of the function signature. For example:

@method calledMethod(): Field {
  // ...
}

Note: Only types built out of `Field` are valid return types. This includes snarkyjs primitive types and custom CircuitValues.

zkApp calls can be arbitrarily nested! So, the calledMethod above could itself call another method. (In theory, a method could even call itself! But we would need logical branching to make that work -- right now, it can't conditionally call itself, so calling itself would cause infinite recursion.)

How it works under the hood

At a high level, calling a zkApp does not mean that the called method is executed inside the caller's circuit. Instead, the callee should have its own party, with its own execution proof for the method that was called. This means that we have to be all the more careful to constrain the callee party in the caller's circuit, in a way that we fully prove the intended statement: "I called this method, on this zkApp, with these inputs, and got this result".

To make the caller prove that, we do the following:

• In the callee circuit, we compute the following hash, and store the result in the callee's callData:

this.body.callData = Poseidon.hash([...inputs, ...outputs, methodIndex, blindingValue]);

--> inputs are the arguments of the method call, represented as an array of field elements --> outputs is the return value of the method call, represented as an array of field elements --> methodIndex identifies the method that is called, by an index starting with 0, among all the methods available on the called smart contract (the index is represented as a full Field) --> blindingValue is a random Field that is made accessible to both the caller and callee circuits at proving time (it has the same value in both proofs!). In the circuit, blindingValue is represented as a witness with no further constraints.

• In the caller circuit, we witness the party of the callee, plus the result of hashing the callee's own children (= the calls field of the callee's public input), plus the return value of the called method. Then, in the caller circuit we perform the same hash as before and compare it to the callee's callData:

// ... witness `callee` and `outputs` ...
let callData = Poseidon.hash([...inputs, ...outputs, methodIndex, blindingValue]);
callee.body.callData.assertEquals(callData);

--> this check proves that we called a method with a particular index, with particular inputs and output. To also prove that we call a particular zkApp, we have to add more checks (see next bullet point) --> the blindingValue is needed to keep the inputs and outputs private. Note that the callData is sent to the network as part of the transaction, so it is public. If it would contain a hash of just the inputs and outputs, those could potentially be guessed and the guess checked against the hash, ruining user privacy. Since guessing the blindingValue is not possible, our approach keeps user inputs private.

• In the caller's circuit, we also assert that the publicKey and tokenId on the callee are the ones provided by the user:

callee.body.publicKey.assertEquals(calleeInstance.self.body.publicKey);
callee.body.tokenId.assertEquals(calleeInstance.self.body.tokenId);

--> these checks make sure that the child party in the transaction, which belongs to the callee, has to refer to the same account which is defined by publicKey and tokenId. Thus, we're proving that we're calling a particular zkApp.

And that's all we do under the hood when you call another zkApp!

An important thing to note is that we add stuff to the callee circuit, although the called method didn't specify that it can be called. To make that work, we in fact add that stuff to every zkApp method. In particular, the callData field will always be populated, regardless of whether a zkApp is called or not.

Making all zkApps callable is a deliberate design decision. The alternative would be to add a special annotation, for example @callableMethod instead of @method, to tell snarkyjs that this method should add the callData computation to its circuit. That way, we would save a few constraints in methods that aren't callable. However, many zkApp developers would probably not consider the requirement of a special annotation at first, or overestimate the performance impact of adding it (it is really small, just 20-odd constraints for the extra Poseidon hash). To make the zkApp callable later, it would have to be re-deployed later. Also, we would have to ensure that a non-callable zkApp aren't called by accident, because that would leave the call inputs and output completely unconstrained, making the caller's proof spoof-able.

In my opinion, it's much better to spend a few constraints to make composability the default!

EDIT: Another decision I made is to not expose the callee's child parties to the caller's circuit. Instead, I just witness the relevant hash, leaving it up to the callee to do any checks on its children. The rough idea is that when you do a function call, you usually don't want to / shouldn't have to "look inside" that function and inspect inputs and outputs of nested function calls. I'm curious if there are considerations that I missed!

Description

Before implementing token functionality in SnarkyJS, it is important that we align on what we intended to expose and how it works. Some pre-homework to this task is to do a quick survey of existing token implementations in other chains. Following that, this issue has been broken into 3 steps.

1. Examine protocol code to see what functionalities are exposed with tokens
2. Interview a select number of protocol and product engineers to agree on interfaces that should be exposed in SnarkyJS

• [x] - Brandon
• [x] - Gregor
• [x] - Matthew
• [x] - Izaak

3. Finalize RFC

Problem

A ZKapp might want to manipulate "string"-like data or make assertions about a string other than its complete equality with another string. Bijective encoding is an existing string to field representation, but it cannot fulfill every task that we might want from a string. A canonical use case could be asserting that the string Today's date: 05/12/2022 contains the string 05/12/2022.

Solution

Adding a string type which can be manipulated char by char, which is just a wrapper of an array of fields.

Drawbacks

For now, each character takes up a whole field of storage. This implementation includes a lot of looping and comparison at the per-character level which can't be super fast.

Fixes https://github.com/o1-labs/snarkyjs/issues/92

The web version of snarkyjs is reported to go into an infinite loop when compiling, cc @maht0rz @jackryanservia

one difference to node is that for web, there's some manually written "table" of functions that are run from workers. if that table got out of date, we had the web version break sometimes here: https://github.com/o1-labs/snarkyjs/blob/main/src/chrome_bindings/worker_run.js

The following code can be verified normally, but if I comment out this line of code await MyProgram.compile();, it will report an error：

import { SelfProof, Field, ZkProgram, verify, isReady, shutdown } from 'snarkyjs';

await isReady;
let MyProgram = ZkProgram({
  publicInput: Field,

  methods: {
    baseCase: {
      privateInputs: [],

      method(publicInput: Field) {
        publicInput.assertEquals(Field.zero);
      },
    },

    inductiveCase: {
      privateInputs: [SelfProof],

      method(publicInput: Field, earlierProof: SelfProof<Field>) {
        earlierProof.verify();
        earlierProof.publicInput.add(1).assertEquals(publicInput);
      },
    },
  },
});

let MyProof = ZkProgram.Proof(MyProgram);

console.log('program digest', MyProgram.digest());

// console.log('compiling MyProgram...');
await (async () => {
  // If you comment this line, `verify` return false
  await MyProgram.compile();
})()


const verificationKey = `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`

let proof: any = {
  publicInput: [
    "0"
  ],
  maxProofsVerified: 1,
  proof: "((statement((proof_state((deferred_values((plonk((alpha((inner(da3818a569ea2261 f187462ca34aac13))))(beta(fc8263efb874aff6 da7b9e0694048812))(gamma(0083118ea36103b4 8e617634f9f73189))(zeta((inner(7a45ee3f19c545e6 e5374a5c60a72cd2))))(joint_combiner())))(combined_inner_product(Shifted_value 0x2C037E18875C0F4C8D3DA5EBB80F61F256A64589261979EEE8497569C962740D))(b(Shifted_value 0x005003AFE22B7D57AC21B95109AA411FB52C30D8647A9A6713EEE11A289081E5))(xi((inner(a6c6f1d71a2513d7 71a36b85f9be0807))))(bulletproof_challenges(((prechallenge((inner(fe48312e72b6e940 e53349d4d1ad1511)))))((prechallenge((inner(64954ca792397fe0 6d430a3c3883c160)))))((prechallenge((inner(458fa7c58f8a14e8 8e0ed123f3c9aa1b)))))((prechallenge((inner(1581b15e15e35356 afd22eedc00c936e)))))((prechallenge((inner(e5fd739b152333b2 7486efad669346f7)))))((prechallenge((inner(707fbe7df89e951e 6621e91e7d05df16)))))((prechallenge((inner(154caf417353cbd7 cb5fbdc632e143fd)))))((prechallenge((inner(77e53bb112fa8242 3cd7e11d8b9dc421)))))((prechallenge((inner(584115246214dd6b 51993ea0fd543dbd)))))((prechallenge((inner(bc3235ffe9d6ea19 728eeeae089de5fa)))))((prechallenge((inner(86636af540ca6db9 622683114c6f3a04)))))((prechallenge((inner(e27726c6fc07c7a9 85da121e327c4967)))))((prechallenge((inner(981d6660399d75f2 d44229abb1938dec)))))((prechallenge((inner(4c3e936247a09ef2 66b7c679238e1456)))))((prechallenge((inner(c9ebd99ecb875eb8 19dfe70536bf3f05)))))((prechallenge((inner(6343db28f9fd2404 37d9ef61900e9def)))))))(branch_data((proofs_verified N0)(domain_log2"\n")))))(sponge_digest_before_evaluations(13c74f7845341f54 690efe8cb882703e d1733ccbbcbb0f84 34548c8279cd0363))(messages_for_next_wrap_proof((challenge_polynomial_commitment(0x1B4DADCC5E06DB4C8B2D93F6527EE6D8EFAF8533E2520EBC72DA2E8237AF7A1C 0x39A66B1F02111E714D55AE390D0118D91A2E4C15FF765E723D58231C8A7F7BCF))(old_bulletproof_challenges((((prechallenge((inner(3382b3c9ace6bf6f 79974358f9761863)))))((prechallenge((inner(dd3a2b06e9888797 dd7ae6402944a1c7)))))((prechallenge((inner(c6e8e530f49c9fcb 07ddbb65cda09cdd)))))((prechallenge((inner(532c59a287691a13 a921bcb02a656f7b)))))((prechallenge((inner(e29c77b18f10078b f85c5f00df6b0cee)))))((prechallenge((inner(1dbda72d07b09c87 4d1b97e2e95f26a0)))))((prechallenge((inner(9c75747c56805f11 a1fe6369facef1e8)))))((prechallenge((inner(5c2b8adfdbe9604d 5a8c718cf210f79b)))))((prechallenge((inner(22c0b35c51e06b48 a6888b7340a96ded)))))((prechallenge((inner(9007d7b55e76646e c1c68b39db4e8e12)))))((prechallenge((inner(4445e35e373f2bc9 9d40c715fc8ccde5)))))((prechallenge((inner(429882844bbcaa4e 97a927d7d0afb7bc)))))((prechallenge((inner(99ca3d5bfffd6e77 efe66a55155c4294)))))((prechallenge((inner(4b7db27121979954 951fa2e06193c840)))))((prechallenge((inner(2cd1ccbeb20747b3 5bd1de3cf264021d))))))))))))(messages_for_next_step_proof((app_state())(challenge_polynomial_commitments())(old_bulletproof_challenges())))))(prev_evals((evals((public_input(0x205821C0A5854378AAD439A743E48127F454CB597D37CD5CE96B29DAE819B9F0 0x306A92026852F9BBF12CFE5DAA6B73F4F25771627E05ACF1521EE0402D1F464E))(evals((w(((0x264DEF927CD5D4797B8DB5F318A1C5EC167065C10CA194B811B767E557C98AF3)(0x0307805EEB0611BD90BE0D47AF782B1055505847352EB1C7B1D2FB5F929730FF))((0x11EFE413775D9616030973D2B4D2CA1589C8B595D21C90A804EFB9FD01F978FD)(0x3101BB5F0213DE56417372338D1AAF6BCFAEC3048DF376F64F8900B6D2C3BA33))((0x0832AC89AC888E2B3CFB27A02D52B79E333918BDB3111415C865A0AAF1882D30)(0x341F4209F2F7F58CCDF47AC68E9789666B5F29C4A4DA0A53DEEA600D91358251))((0x39F9BAA87A56D141A10D25B02D2D0557AED52B19606241B8446844C37510FED2)(0x0630BC045E7C6289B02E90E6BCD3911D7D0E87EC804973E889482B62C0E4EE60))((0x34D56C6D51E44D408B9709E160BDD2DAF26D9EC9B6C0CB5D5CBA5B31FA4C54E4)(0x30E1EF42274A705B9D9F58786FFA42AADFD70EB0B603C7C608577DAE32EA6CAF))((0x2DAA80261BBC33FD6F57859A736B68CCA715386C2F88641B9151879BD76389A9)(0x162BE059061819510C6BF8C4D33F735A65D6AC15926C5030BFD3E1909FBF1278))((0x22FC152524DC0D4FA7D44E6777D10C342CAA60373F8A9DF79B8F0756B52ABD9F)(0x1E6A989C7022CB8FA9CCDF5E45E1F20D0F8004A6CDD5918B23E40DE2E1DA3828))((0x3ED5EBBB19AD59E121E4E440863083AA6C33664FD837FDEF3D2DA45DE394B587)(0x3F4B4CBB8991C455F6FC8CAF07EB30469E5C3BE4B20B6442F75CBD6B33F7267D))((0x1F140D5C76C0D7D16615E72B12705E227D1F571A53E7784B4519EAD0B99D4575)(0x142582CC1691C591FD89A8D3365656EA9ED1BFEB7F6F48B235E054655EDDE83E))((0x2776B264497C459AECD804A66715C9E6D3FB2AD4D79B1822C3229CAC1CB71780)(0x0A2274238AECC9642DAF9845CA86C2CCCA5863AEC24D6DFF619D47D9A63B0477))((0x0F94B0B15A864F14534B666A4C6F9352B1AFAE0358F48CAB377D73B8452C0C32)(0x2B4750FF125E61B085CE722F2D0351EAA119FE8739FE2359797E36FAE704D921))((0x11CA6EBE23C8D976812DB8D76774A5CFF39B025970FB6107B9E705C9F3E0F3D9)(0x2BF27A40B975E800EE4580E2D62A8CC931BE014D406AB50A33303100A16C0102))((0x1C67700A3F2619AC80204832FFE8DA848BE0A4CCA24BBE50329F1C066268279C)(0x3794636FEF22DEB0737EEAB6FB800B9E2310106C03004A6962C0178EF3BA41F5))((0x20E20466779CDB7EFED6C0A25A1E922EF7F3B029B04F220094FAC9133BD413EB)(0x091E921310F75A01C364C3095BD92BA2829C98ABD51645B005F40B07F4B2BADE))((0x0CB25B95727BEC6BB279A34060AD627C356756A3680B39AC99CB353B75658113)(0x2D7E64AFD821B9E578162B5951C55FCB011BEAF2CA923EA1E34598F02E43CAA3))))(z((0x25E5B8498BA8ABAC51B5AEF254464E97304AEDE2F2D70353E6652CACC6111E21)(0x33741B0B3DFDABF7A322EC0AC52A06E34A641691035626C449DDBD3CD16AF431)))(s(((0x05361D37B169E644DEDA11427E1EFE1564B07069B325FA03B8EC20810CEEE584)(0x3C3EF62CACD327E144D589ABFA221ED43FD92C3251E07522C78B9FAAD1578213))((0x178D435679BDE0A6D3779408ECF19F2D9526AF2AE46E871F06D37E79A47D1157)(0x05A183C5615885F67DC43D056D05AA6925B6B90576780A5FB02F3FA011D7ADF6))((0x2052E851CB7A55510FC11B8283BA6A025429444EF2AB525FF7935B1341EC6336)(0x27B98C19737789E6A4112AC652982FDE5E0D3AC980E8E236E5A2373CE6775877))((0x17B5C679F9B905B498BC08E56D84E02A069A737F879D7149C389DCB4BB5D0CAD)(0x23BEF1CCD1DD1EEDC2900D61929D06913DF15EE30819ECE71C22F06C1566B666))((0x1472DE4E44ADB233599D643E1DFA9EF05D8F116B3B261ACD91A54182B67C2B0F)(0x1A5F484037E9B957780AC893755B71CDB028B1549B7D39F93E135C6F8D7316CC))((0x0CED829E0D6C268AE455C9DA29DB11C5830020F583E55988B2E03660B6E36A13)(0x3B53344D6D55193D4C39099040E98C429FDE47D3B569E277898212C69FE9FCE4))))(generic_selector((0x0370EDEE98323FA8345ADC1BDD413929AA19F92043D032B312B20FC22C4838FE)(0x3833029C2653823E7F2DA9DA2B572BFB5D1BC8122644E137BC8ABC55B32CFF44)))(poseidon_selector((0x0E739D6CD26954C797254BCCDDBD8A28028BD4083B51EE6789824C60D7BA8213)(0x3354B25B6DAE17D3B23EFDD936936D9DE1F76FEA085C2583B49CFB9D98920486)))(lookup())))))(ft_eval1 0x02A2EE593BCF5153AEBC677CB5B69D44660594D1EDE1B60543291F677C30569B)))(proof((messages((w_comm(((0x2CBCFFA67C09B387B69CE5BA4F5A9076A629F4F42E00B70867B60E59FBD50472 0x37AA5F019A4144B929E749B322D52F925284D932674467CE523AE74E3D51FE3A))((0x19308C2AF7B7D94F2FA76195E8DEF1009749AF5558814529C5252AD863281887 0x392BB5CD24942B2334436C06B22C4E933282504CDB57C344BC3DA43E49ED5064))((0x1C0CFF4BAB39EE1FF2E58EA262B3DEB239D802BDD3566DC2E6E8CB079C05E668 0x2B31A1CBD0A6B7C94A4D0ED4AF017F157B6EDD206C3F3B93B9D0394E43F1BFA6))((0x0EA93C449B6DC8AF4AE61B2940A896089ADD1684F7442D3EE22DCA966E81F642 0x2C0DC88567FE0FAD41068F2CCC1D84A31524CC4B3873DDABB31ABFBE335016EC))((0x0F0CF2F7425DAA23B8A63C35FF0BF2581C433CE46C7CB5E714C1E3D3EF7F54F5 0x0F57BF0339474130493A2E04D08C15C7FCAC2A8D872CA1A9D124A94F149E1FA2))((0x1A551BE73552B4D136C89DEA53B8D23671E479BF7F3F236FD64D0F16B69D65E0 0x277167159A8BBF711F5221853F876BE6AF4BF87396C767FED28A3B10837E0A51))((0x0E5DD248ACB10866BA01E98A30F1B6455650B57F9B8F5D32A337299B32BDCB80 0x2914FA603AE43916AAD5B834BFFB349370F452F41FAC7321AF384B58C5B26994))((0x3D1D4C780E59B21DD061F3B3B29A34AC59035E21681F08370EB749494B0D1AEB 0x14292C20C3B0FC95D57EAF9060CFA125852C9A6BEBA235D0AC3CF466E1BD85FC))((0x1E646EAC9EF56DA3B1FE78BBA194196D32125CB9865758F0DF4BEFE3C91E8F1E 0x32FD729871DBCE45513E986628BB340AF5D498309FA9AED52F8BD1939F9EF9B0))((0x2FF1F23376C1971445DF31F6ACF787204D656666E71685E2CF2180F85EFBCA19 0x18994EFE67FEBC2240B4555A401A0B55EA9BBF76C85351EAE37985294B4C9B2B))((0x3116A55E658B3E019B7378E20AF2DAC8B4EC8EE64F57E2E24273A8109048A373 0x28872D47DC7E4B18F52B96C963C75FBF99663951DE75BB924B6A2C0C51654EEC))((0x2E22A1D0F2E84FA122A880DA96C5CCA3EB41D86E96946F8DD14275D95182A034 0x1DF506F7CC905EAF8466427025873623C3156C7EF2DDE52FF15E810F495C5592))((0x2E40E8F7774B125D2E89C2B82E7214DF8507DE3EDE24DF3EE5585595BBF88094 0x24B4CA6B8DE829368740964D2E920AAFA3427BA746B3E2306A0F27E84005A542))((0x34DCF9F385FD046E887862E8D11E9E44FC76FA7718F28B833DAEE43B28E29F79 0x373B70BA095A3E0FC891628B9DC1FFD7254E7982655141F7EEDD42341F2366D9))((0x34E6F5D4DCEF4115D18F7B1D1E9AF33CC8E382E74A6A9DA6E4414B9DC7895650 0x224DDB6689D6B6B6124252D60568957A326403875FFFC1E73B271B1E5D843E37))))(z_comm((0x270F12F6B5BB7A6952F2472468683CABB8933582178EC8F2BBFF9F432FE7C499 0x3162CE9DD3B60F1C5E01127BD52754491C76DFC0883693A2E2957396D49D5CA3)))(t_comm((0x36117E9DF7A24235CD3941D5D77BFC2E28CA7C0549D49E75B574D897ED4F704F 0x3D2DE7AB709CEF6A716162048553E1547277512B567534FA8B0C6F3240E9A3F2)(0x0444965D345470A9FE727833F8B0F4899FBCC1F11A8112A0E7E8A0A15B304D0D 0x21779AA1E69B7A992C0E5E48234AC3879A52EA5A4D2855C7D2F838CE5FCC6151)(0x23C40F19B0F3D40D9B5749DD3877DADA2115B5F19F02FEF8AF2AE798134CEC5E 0x2F40803576711C502692281EF16B139C13C5D8B1125D4AA346C7A5C61D7E9DBE)(0x2DBCB3B249BFE9D1C728C4F755DA1D11EDA9D0014B24A645851A4FB72C39F33D 0x1492684AB7CA95F17FEE9CA0A419A1746CB0476022A80E920444AB1342CADD84)(0x1B9C45DF64E0FEDA12745C0C47EF70615E78D43F7A42BD3B57AA535213D4B5D3 0x1ADBDB9416BCB959EBFB219AD9B9D266D1DE6AC2EB427EF9601BB6D685496A70)(0x2AF6C274C3F832D800050B619981A5118FB95821C52B6982EA6812A6288784D6 0x13F44D4923FEA2EA1AFD3BBEEBD1190DDFB5FF948B2C9E2401BB6A51A97A518C)(0x3D7292E215080F4DEB2AC1BEC982D37B2AB3A9F12DE29DEA1B417091FF684303 0x0D19CA0E191404764D0B5458D2BA950A0258DCE9A846843F3145B51B81D48896)))(lookup())))(openings((proof((lr(((0x2E5EBC240A033CA9FADD519389F84F5CF2AED2BAAC761ADFA83B084CA52AE689 0x095356ADE54F0C16EBC170303CA86B0E23C49F88DD0E71096709A07AFC52B66D)(0x1285C0E15F37F8DA3D352D0DB7EF5485BC84808C512B98E5CD8887A97D8C15E8 0x09AB2B15439BC977AE44901C3439F7023C50AE55BF46B06B4051CC1E816F3BF3))((0x11D4D0EB92B260C9AF49645DF3B9BA404C1F63579D2226E74A2EA39E612A0174 0x0FB28BB1D85BFF6FD7ABDB8340A2392028B5F3FB1111CE917C1878087708D823)(0x194849668081B775456DD96BECE25B61EC78E48949EF0E4830B39A224AA71A75 0x1245BB6337C4EC783092931A1519CBCCBC3E86099669D59D682C912E1E99265F))((0x0BB6CE3EDE0EBB2D674D287A55C997329918E80A266CDD0F8DA42F06C8B0375A 0x104E5A27686D6B04D495A92D3F62A3C1663E33C39FA4086E1C21E64049F741D5)(0x2E37DCE9B0F50FE4A37B2348BF2119B79714C10401194335DEE2E120C4BC3B5F 0x102D800360C3D8C67C7A586EE888D66050314D6162F6CCF57936508271C64971))((0x146F50F9164828A7D117CA88E4547DF3A312B1C1FAB7AB4ADC4AF197475F7B87 0x15AED957A0A878C034B6DC2E1880C01A65435883A31B42D9055618AECE18D034)(0x34CB893EA26C5F59C3F2BE81BA04C0DADAE38D1476E61F4655A170A3BE72A39E 0x214B45A7395ADE13B9B4EF221AC4051EAABC7C6459578CDE92F0BECA51D97F23))((0x065A0E2DB4C6985C399EBB6FA966E79039D175CB6539B5DC4E1D018458B84EF9 0x0F28589B154DB6F66BB26E15F3C8E8AEF1C41AF512B55C95F19BA4A5896CE03E)(0x0B5663CD6B3C5316DCBB397449E0A48C29F3C82881EC43B15FADF16B1A0B5802 0x1E4DCC073F90622B6E45EAE0D5BCAA0D47D6F937276FC255D5BAC9E5D6D62E58))((0x0232390044593ACF01D5FE517D72DDCF2CB011064BA422498A75EFAAB0ECEAD8 0x1C5917037FEEED3F15D8B87CC41F240F5AB2D6BA07D79B333198A46067217023)(0x2A656ECE42A01544D1F6D0D7BF5760565A533EDF791F377A7FAF60C13DD39158 0x084766F758EFDDF977D55476A87A8B5964A8EA84CAC0C3F3BDFF27C2F4BC2B17))((0x1C5AD053493F4662EDA1BF1E77DCE10CB48C541D8EEEF3D5506C37987B2E7DDA 0x30E14AE795150F3B7D35852257C1E017FCF181B4F0833BE5FF7276C709BF1C8F)(0x0C5745B9FC922034AD5A3BF2ADAFE63C29C4A06F5CF3D06E7C1486A033FB1D59 0x2D5DAEBAFC1B0D75479D2FEB4BD05912A4659D5FD1A1CCEA6E6C267C0685E9F1))((0x208E4A559C115E0CFA855F1B1154BCB42F12B9EDACDF5DC9D45E0A28A71297DB 0x30B1A56974F2AD3F8D490D4B63C9E7CBEA58B52AA7C22B497C3D9296E3C4F2C9)(0x03B281CB9D0D507A8507722A4CBC9BBB8E4C3AF5E2EF79053AC5C4D7DBB69CBB 0x3324A3B9648C1F9ACF220B3D32EBE3FB26D4DAE7761018C8AA7FF776BFE67FB7))((0x2CDF8BB65961025BCCE6FE92D480C5BA800DD74B1BD6BC512E22EF1A7E8BE219 0x272743FB854A39FEADD5DCDE6BC053EC79AC0D5FD7A8DE43969C0A18F3511857)(0x14E407A9A048F6E3D3401CBDF09B198A651F7AA91432C064B0406DDE079FA14A 0x2D90498C006235294D7E46D19D61FB2EA722DB9F6BA25110A0DD2338FBB37DB5))((0x298670716662979929DEF4ABB8A14218E7050571342889C62F9963E302F68117 0x0FF569F6981D274A0528DF9B4720525220195125961BDAD734BE32838299BA1F)(0x3FB75A5F953B5F3FDD7BB35E232905212D5A5FE0305A282947FED36C9828B19A 0x3CAC15109CC5B439897321F6A1BEFF91CD186EF2480F26EBDDB5D046CE045EF8))((0x204FC241556E16E64636064EBF47C77A53639093C4FF5126CD1BEF61210D89F4 0x2FFC3F6D8290D93E955CFB84AF28F93D4BD5CE14ADE4B60C0FA97C0AC2648C78)(0x3771A3D88E40F6FD0BAA5EDB0BDACE39E818D589C8A771CE3A675D5F260F2DCA 0x2144693340D772215D1551D2DB4BC950BD8157BA1C6D094D086BB1746EA0849F))((0x11A2E655C0983544600AD55354AEE2A81F66D485FA0F4052755BAAB5C2FA5259 0x1609DC1547E66F471C5BFD67CC47D9BD06E0BFCB7FC8A5E9BC023BC17FC6805A)(0x0B5F91C927E8A1CEA286B72C344F22918C927F1CDE43E1F9F143950253607766 0x1697ED227000BFA8BB7D7450C6D5B47BE4B30C5295E6302D21092B68DF12F888))((0x06A493D1F92CEB7BB79242DF582000913469F1A472276D67A8F9A530FF846124 0x366A07E7AC1CBA543E64E599F8992B26771151ECE9E6A30D2D77E46C05D44A64)(0x13EF0731EC16A188F46A87B8B5E0CD01F3A5540FE029AA286D72695410314B5F 0x385688914778C7AD81D7C9ED2D5FD507776B84DE2C8499769E2D64BA8EB476EB))((0x21CFF818A13BA85D852762E95B01AB839C4F661BCF3098A4935198320095DDAE 0x3BC21383B9261C2B68BAAE258FDAFAA0404A358E6D8CC56B826FC50895B324EE)(0x02638875AC74FFF33D6ACCC5558C691351C57E36F46621C1850B25C7CFEB4B89 0x3D31D8D52098EB3005372D794BC2BBB30EEAFE8D96AA4B1ADE337C8576245A20))((0x22D23ED16FD6DA913031FEA888ECE595141D714E3059F750B17678EC9C9F2B38 0x137028201A2338C0CE98379AB7486B2C71CFE144B4FC1E9F0A9BCF2237F038C3)(0x05B36982D9FE19770439A8FD6CCD8DF5FD97317858B8606335D0BAF76D941F67 0x368C9F05617E1FC9C5FB0025A0D944833468B4520DF802F5CADECC4E16473BBD))))(z_1 0x003D0991F10A52FAFFA6B6E03E3C86B907B2575B56C4F508C45F5368A656AF25)(z_2 0x03EAEA0E857636F6997D713E738E913F3721E52A14463C5B1DE990F9C7FE516D)(delta(0x39BEBDA6562FA72049826E464930B95A19AFE997BDCFFB753FAA7F829788E081 0x1EE57B9AEEA4E5F5F982C2D38AC065704A50428A54A84AF751530AB66B56FFAF))(challenge_polynomial_commitment(0x24DA84F3696FBDD34C9D8E1464491DF55132A2BA47C21AC74F4A9785197CCC92 0x1DB6D17093A509F615A37458B2CF67D9CD4877A90615696E1F478D3B96ACDDD8))))(evals((w(((0x15125FF678AD89D1E500BAF7C659F1823DB4F8A9FFB2BDA4C60690772F47D3F0)(0x39CF77DC9310922B3633E5A6D35ACDAB0964D9F9AE9FD25566B4B1EC48A06C5C))((0x122DE41E56F867D5C8A07658F3280426ED257CEDF86532466DD300514D051738)(0x3D21AE729EFEB2358CC7E64BAA41AADD555199A33FB5FA5691A795081E245D30))((0x24AE188705FCDE038C88E1FE34983025607A9F530038CF0CD255B61F6B125994)(0x13F5BFC102362D75066FC2DD3A62F4A8EF7B22CB6ADF0D4ACAAF5A6559E38943))((0x2C9F8857C3FF7F7616E2426E2D7491632B4259A7E1F7F6D915447FBFB0721733)(0x2B18AA0836FD4858BC1A58C454153016C938EF4184069B8E724D162435EBD1F6))((0x283002AE852B8502B4918EC60033902C57FAC9200F9B855863FDB5536ED7D38C)(0x01D1470A79AEF46502A769B4E42031EC87D4F5C14508F3B1E325E1D09E667F22))((0x09F57F816639A0D156A124EBD736975B9ADE44593D4FD7DB3AD6D3A91011AEE6)(0x10B570BE92B6E4FCA3C6D9BA45062424E3001A76D18D2ED95BB6C21FD42FFB47))((0x1A7185449A4473CD86CFEEC62757D989B258606A8B7B3138308F2DA870E9D9C9)(0x35DFFFF2A695675ACB81439976631DB8EC0023CB90D6161D856855C032DF26A5))((0x3F0FDF9160290ADC73AF41434E8C0564722923A3F9CA056DE6363410295FE935)(0x06863E5B52E526B656D030A211F01FA2D7ED81781590D79AAADD59487356046F))((0x0C4E2B068264AB88DAD2926F9F3869FA9DAAA5F6E60C76F47C3AA60AB44C51BE)(0x3B324936ADD5EB47B42BDED200C5DCD14B1118A7148E877F16FC45B365F276E2))((0x390EA5B20F9DC7D27D5F7DFAA98A2184470DE221246580011894DB5B67215913)(0x38F4FB936D98D4B7E019F7A08780C0D8DB2C8D9CA88E720ACBEE3AD1DC60C39D))((0x0C095D727D1D3F30E69C4A5ACE2E0F70881B7AD9E65FBCF216B60CDEA450CF94)(0x0FAE8851CDBDA53DD22BE5E8A793D33F7EB4ADA6D95ABC0018E394CFA95527F5))((0x30D3452B8DDF4806271A9B3B19C5C0DEFD657DF998E717DF4627E8267D41CA41)(0x12BE0A18D15932F7266966F4B7340A645DDC8FD125F0A9EA7455340361A0A352))((0x366925204946F7612083E2725EE5599BA80027346C6D9DD0206F86A58DE9A5F3)(0x2BF94D8B241FD405309BD4058D34F8F1FAA65BD34A95F026898EE05E8D72435C))((0x202BFE8BD2D1E8595DFC62F26FC005962E94E76BDD2ABE5524014B727AE59DC4)(0x267578C890956D884102D1A791B35C77F1E09B8E9144564803902B9B30CA2A36))((0x0759C2E5C6BFDBDA0CD97252E189D82BC2561B0443CAF809715F673CF67DFF64)(0x1C9F4E4A109A12E08DE27CAE21EFAB0FBC7FFADB4D68C4A97A3287F7B583D8CE))))(z((0x04EA2042F9AC6B0E650147BC6A201BFC93D3E1C948A0EEF5074A9B8D175405A4)(0x1D33B5712078496ED004507FA5D55F249DFC9C2D9C0D04EFC28E47799E0C1486)))(s(((0x05B3F0806FD927059687813ED25504F59B0C013B6DECB98FBD5E5F63C281234C)(0x1F8174155D1EA360D3AFFD2E2B698A18ABC2726019908DADC46ECB3067EF59F9))((0x30ECA125CD05E96E63E6608602E9CBA9AE7E23B05DE22003D1A10D1125025AA7)(0x08C1B15484FAFDF460791838060A61E866398BDEFEE4F80C591A5992F1159C99))((0x1FBC3E343069A75F9A441C7E4C30AF5B0B742FA3B1B2C95EAE021DEF18008B5B)(0x037A78C443F16247D72DBE549F82BEFCA7790480D2F22464C8183AE28C9381E1))((0x37B2E96A2BDEDB37133371F232C1FD7932EA6E8CB52EB8E7FA967B5BDB548CA6)(0x005AE494B8D15165B77FAC3A91474DB63B7F26A3FE8635B5267B6CCC98A7BCCC))((0x1B088B7B28327696BF494E9ED439D3FA0E63F8AB177A4DE992ADECC7533105E7)(0x0EDAEB6D5D912747E59A4908CA6582BD78968D32E59BE971250F16471B1667E0))((0x29908D0F640B978EA407CE55F5E4C0775166BCA799CA5376704D0C5462187813)(0x3F7D2E763404772E6EF96605AD7F197E48603C670906446A32454CD97F5C6755))))(generic_selector((0x17A115DBBB1709179AB35D903C6F04572FAFBAADF4D8ED97A8381823FB905EFC)(0x3C85133C5BD2284FA521DE78FCA95760CA87368075898DFB473E6423FFEF0ED2)))(poseidon_selector((0x285DE08FAD25CEEDC80C498DD8AB9A38BB2A090225F74A72AB8CFD8D16C6F75B)(0x21F47CE2A3EDD4BFEDF6ACFDD294834CD1F24D340A8004BBE16CF20CF97A8EA8)))(lookup())))(ft_eval1 0x266CC53A6F357AA234547BA0DD3BE05F8CC567266D63C0841D7FE45AADA2FFF2))))))"
}


console.log('verify...');
let ok = await verify(MyProof.fromJSON(proof), verificationKey);
console.log('ok?', ok);

await shutdown()

The behavior of the code to send multiple account updates in a single transaction has varied between all recent releases, but on the current network this code no longer works when making more than one balance update. https://gist.github.com/garethtdavies/576e86683ca8b7cd1722108d7efe9504

When making a single transfer, the code works e.g. https://berkeley.minaexplorer.com/transaction/CkpaDtG9L5LqYguqTya6qYp6k8wvb1xZ1Pc25pEgd8votCS9sunPG

When making two (or more) transactions, it fails with Update not permitted balance e.g. https://berkeley.minaexplorer.com/transaction/CkpYxz2WGF1HLng3D4DfyNwtAjbY7nY8bjfiUgJCcqrPEjaJjjAvx

How can a zkApp make multiple balance updates in a single transaction?

hello , I am implementing sha256.

before that i should know the preimage size to do the padding.

  export class Sha256 extends Circuit {
    @circuitMain
    static main(preimage: Field, @public_ hash: Field) {

      let size = preimage.toBits().length

    }
  }

but when calling toBits().length, it returns 255 all the tme.

so any idea to get the preimage size?

Description

Addresses #282

This PR proposes a scaffold structure to add zkApp test applications and tests to Snarkyjs.

File Structure and Location

The smart contract used for this scaffold is located in the src/examples/hellow_world directory of the SnarkyJS repo. Creating future test applications, and adding them to the examples directory can serve the dual purpose of testing and providing more examples for the community. The tests are colocated with smart contract in a tests directory with the naming convention <SmartContractName>.integration.test.ts . Here is a basic folder structure for the contract and tests.

- hello_world
  hellow_world.ts
  - tests
    hellow_world.integration.ts 

Testing and CI

These test are created using the Jest testing framework that is already included in the SnarkyJS repo. The Mina.LocalBlochain API is used to setup a local ledger to deploy the contract to and test it's logic. Theses tests and all future test application tests will be included in the SnarkyJS CI tests that are run here:

https://github.com/o1-labs/snarkyjs/blob/b70511aa2f4dd9472f8b2e2b7edfa0486a699863/.github/workflows/build-action.yml#L24-L26

At the moment, all zkApps are given an init method, which the holder of the private key can call to reset state.

It should be possible to create a zkApp where the private key holder can't reset the state.

Would advocate for removing the init method, instead performing initialization inside deploy, to have fewer special functions for developers to learn how to use

We should make it easier to roll up updates to a Merkle tree with actions /.reducer. Ideal (IMO) architecture is laid out here: https://github.com/o1-labs/snarkyjs/issues/659#issuecomment-1361320687

closes #632

• re-implements signing of payments, stake delegations and strings in JS
• tested against reference signatures created with the OCaml mina-signer (test_signatures.js)
• to support legacy signatures, we also implement Poseidon with legacy parameters
• Legacy Poseidon is tested against test vectors created with the Rust tool

Motivation

The actions/reducer(link) paradigm looks very promising as a way to handle mutli-user, async state update events. However, it is currently not so obvious how to process these events for state which happens to be the root of a merkle tree. The ability to merge Witness objects would allow developers to reduce multiple Actions of the form { witness: Witness, leafValue: Field } into a new root hash which incorporates each separate action and does not require the full tree to be loaded in order to generate a new root.

Current State

Imagine a scenario in which we have a zkapp with some state which represents the root hash of a merkle tree. The merkle tree can store the current balance for each user in the zkapp. We have 3 users, Alice, Bob, and Charlie who each wish to deposit into the app.

Standalone Transaction

This can be accomplished without using a reducer, for instance:

@state root = State<Field>();

@method
deposit(user: PublicKey, amount: Field, witness: Witness) {
	// Simplified function calls
	this.root.assertEquals(this.root.get());
	this.root.assertEquals(witness.computeRoot(amount));
	user.send(this.account, amount);
	this.root.set(witness.computeRoot(amount));
}

The problem with this implementation is that it has a max throughput of one deposit per block (later transactions attempting to update the root will fail the second assertion. Their witness is now out of date). This is not acceptable for a variety of apps. In particular, imagine some kind of "mint" or auction event which goes live at a certain time with hundreds or thousands of users. I.e. ~20 transactions per hour might be appropriate in steady state for some apps, but there are certainly other apps with burst usage which far exceeds this rate.

Actions/Reducer

The best available way to solve our problem is to emit actions in the deposit method, then reduce them into one state update. This solves the problem of only allowing one transaction per block to succeed but it introduces a new problem.

Naive Solution

class MerkleUpdate extends Struct({ witness: Witness, newLeaf: Field }) {};

-----------------------------------------------------

@state root = State<Field>();
@state actionsHash = State<Field>();
reducer = Reducer({ actionType: MerkleUpdate})

@method
deposit(user: PublicKey, amount: Field, witness: Witness) {
	// Simplified function calls
	this.root.assertEquals(this.root.get());
	this.root.assertEquals(witness.computeRoot(amount));
	user.send(this.account, amount);
	this.reducer.dispatch({ witness: witness, newLeaf: amount })
}

@method
reduceMerkleUpdates() {
	let root = this.root.get();
	let actionsHash = this.actionsHash.get();
	
	let { state: newRoot, actionsHash: newActionsHash } = this.reducer.reduce(
		this.reducer.getActions(actionsHash),
		MerkleUpdate,
		(state: Field, action: MerkleUpdate) => {
			return action.witness.computeRoot(action.newLeaf);
		}
	);
	
	this.root.set(newRoot);
	this.actionsHash.set(newActionsHash);
}

This seemingly solves the problem and would probably run, but there's an issue. This reduction does not fail when multiple users make an update, but the root hash that ends up on the chain will not reflect the sum of all three state changes. It will only reflect one of the state changes, whichever one happens to go last. That's becuase the Witness being used in action.witness.computeRoot(action.newLeaf); is the stale witness to the existing tree whose root is on chain, not to a tree which has already processed the other updates.

It turns out that in order to process all of these updates at once, we'd have to build the full tree in javascript, make the updates on that tree, then compute the new root after all of the updates are done. This is a little weird since MerkleTree is not provable and can't be used as a parameter to the method. We would need the full tree to exist outside of the scope of the method. It also limits who is capable of running the reducer method to someone who has the enitre state stored.

Proposal

A more elegant, and scalable, solution would be to merge witnesses to the same tree into a single witness of a new tree.

An API for this could look like:

BaseMerkleWitness {
	/*
	 Observes the value of this witness with the value of leaf
	 merges the paths of the other witness with the paths of this after observing the leaf
	 @returns a new witness of the related path as other, but with hashes updated based on this' observation of leaf
	*/
	merge(leaf: Field, other: BaseMerkleWitness);
}

And usage in a reducer could look like

let initialWitness = actions[0].witness;
let leaf = actions[0].leaf;
finalWitness = (state: Witness, action: MerkleUpdate) => {
	newWitness = action.witness.merge(leaf, action.witness);
	leaf = action.newLeaf;
	return newWitness;
}

this.root.set(finalWitness.computeRoot(leaf));

The algorithm I am imagining looks like:

• Confirm that witnesses are the same heght and not identical
  • If pass then these witnesses are mergable
• Identify the height within the path at which the witnesses differ (h)
  • example:
  • tree with height of 4, leaf count is 8
  • 1 and 5 are on different halves of the tree, so they differ at level 3
  • 7 and 8 are on the same half of the same half of the tree, so they differ at level 1
  • 6 and 8 would be 2
  • I believe this idea could be generalized
• calculate the hash of witness1 at the leaf up to h (hash)
• create a new witness with the same path at witness2 (w3)
• set the path of w3 at index h to hash
• returrn w3

TODO: Better discriminate between different kinds of errors in places like Mina.getAccount. Example:

• If the endpoint doesn't respond, that should always result in an error
• A missing, on the other hand, account is sometimes an error (e.g. in getAccount) and sometimes just information that this account doesn't exist yet (in hasAccount)