feat: process designated teardown function call

[just-mitch]

Deviations from the spec:

I needed to create a new stack for processing the teardown calls, instead of storing a single call. I.e.

class PublicKernelCircuitPublicInputs {
    // ... other fields
--- +CallRequest public_teardown_call_request
+++ +CallRequest[MAX_PUBLIC_CALL_STACK_LENGTH_PER_TX] public_teardown_call_stack
}

This is because a teardown function can call a nested function, and, similar to the current design for public/private calls,
we need a way to keep track of our execution stack.

Further, in order to pass in the CallRequest to the private kernel circuits, I needed to add a new parameter to the PrivateCallData.

Overview

We designate a function to be run for teardown as:

context.set_public_teardown_function(
    context.this_address(),
    FunctionSelector::from_signature("pay_fee_with_shielded_rebate(Field,(Field),Field)"),
    [amount, asset.to_field(), secret_hash]
);

As I note in a comment, I created #6277 for getting back to something like:

FPC::at(context.this_address()).pay_fee_with_shielded_rebate(amount, asset, secret_hash).set_public_teardown_function(&mut context)

This sets publicTeardownFunctionCall: PublicCallRequest in the encapsulating ClientExecutionContext, which defaults to PublicCallRequest.empty().

When private simulation is finished, we collect an array of all the public teardown functions that were set during the simulation.

We assert that the length of that array is 0 or 1.

When proving, we convert the publicTeardownFunctionCall to a CallRequest if it is not empty, otherwise we use CallRequest.empty().

This is specified in the PrivateCallData which is passed to the private kernel circuit.

In the private kernel circuits, we assert that if the public_teardown_function_hash is not zero on the PrivateCircuitPublicInputs, then it matches the hash of the publicTeardownFunctionCall in the PrivateCallData.

Further, we assert that if the teardown call request in the PrivateCallData is not empty, then the teardown call request from the previous kernel is empty.

In the private kernel tail, we assert that the public teardown call request is empty.

In private kernel tail to public, we initialize the teardown call stack to have the single element corresponding to the call request if it is not empty, and initialize it to an empty array otherwise.

Since teardown now has its own stack, we update the logic for how to know when we are in the different phases to simply look at each of their stacks:

• setup uses end_non_revertible.public_call_stack
• app logic uses end.public_call_stack
• teardown uses public_teardown_call_stack

Note:

This does not change the fact that teardown is still non-revertible. That is covered by #5924

[just-mitch]

• feat: plumb fee payer #6286
• feat: process designated teardown function call #6244 👈
• master

This stack of pull requests is managed by Graphite. Learn more about stacking.

Join @just-mitch and the rest of your teammates on Graphite

[AztecBot]

Docs Preview

Hey there! 👋 You can check your preview at https://663d2d3f143d0349f0976b3c--aztec-docs-dev.netlify.app

[LeilaWang]

Now that we have different stacks for different phases, we can re-enable this check in validate_inputs:
assert(needs_setup == false)

[LeilaWang]

$debug?

[just-mitch]

Thank you!

[LeilaWang]

...execResult.nestedExecutions.flatMap().
This is probably copied from the function above, which is also overdone 😂

[just-mitch]

I cleaned them up a little!

[LeilaWang]

Can it be const teardownCallStack = !tx.publicTeardownFunctionCall.isEmpty() ? [tx.publicTeardownFunctionCall] : []?
Using the length to create the stack makes it look like something is wrong: the length might be larger than 1 (although it won't be) but the array will only contain at most 1 item.

[LeilaWang]

LGTM! 🚀

[spalladino]

LGTM!

[spalladino]

Sorry, I accidentally hit Comment instead of Approve :-P