MinaProtocol / mina / 411

(* zkapp_command_builder.ml -- combinators to build Zkapp_command.t for tests *)

open Core_kernel

open Mina_base

let mk_forest ps :

    (Account_update.Body.Simple.t, unit, unit) Zkapp_command.Call_forest.t =

let mk_node account_update calls : _ Zkapp_command.Call_forest.Tree.t =

    token_id balance_change : Account_update.Body.Simple.t =

  let preconditions =

    Option.value preconditions

      ~default:

        Account_update.Preconditions.

          { network = Zkapp_precondition.Protocol_state.accept

          ; account = Zkapp_precondition.Account.accept

          ; valid_while = Ignore

          }

  in

  ; token_id

  ; balance_change =

      Currency.Amount.Signed.create

        ~magnitude:

  ; increment_nonce

  ; events = []

  ; actions = []

  ; call_data = Pickles.Impls.Step.Field.Constant.zero

  ; call_depth = 0

  ; preconditions

  ; use_full_commitment = true

  ; implicit_account_creation_fee = false

  ; may_use_token

  ; authorization_kind

  }

let mk_zkapp_command ?memo ~fee ~fee_payer_pk ~fee_payer_nonce account_updates :

    Zkapp_command.t =

  let fee_payer : Account_update.Fee_payer.t =

    Account_update.Fee_payer.make

      ~body:

        { public_key = fee_payer_pk

        ; valid_until = None

        ; nonce = fee_payer_nonce

        }

      ~authorization:Signature.dummy

  in

  let memo =

    Option.value_map memo ~default:Signed_command_memo.dummy

      ~f:Signed_command_memo.create_from_string_exn

  in

    { Zkapp_command.Poly.fee_payer

    ; memo

    ; account_updates =

          ~f:(fun (body : Account_update.Body.Simple.t) ->

              match body.authorization_kind with

                  Control.Poly.None_given

                  Control.Poly.Proof

                  Control.Poly.Signature Signature.dummy

            in

            Account_update.with_no_aux

              ~authorization )

    }

(* replace dummy signatures, proofs with valid ones for fee payer, other zkapp_command

   [keymap] maps compressed public keys to private keys

*)

let replace_authorizations ?prover ~keymap (zkapp_command : Zkapp_command.t) :

    Zkapp_command.t Async_kernel.Deferred.t =

  let txn_commitment, full_txn_commitment =

    Zkapp_command.get_transaction_commitments ~signature_kind zkapp_command

  in

    in

    let signature_kind = Mina_signature_kind.t_DEPRECATED in

    Signature_lib.Schnorr.Chunked.sign ~signature_kind sk

  in

  let fee_payer_sk =

    Signature_lib.Public_key.Compressed.Map.find_exn keymap

      zkapp_command.fee_payer.body.public_key

  in

    sign_for_account_update ~use_full_commitment:true fee_payer_sk

  in

    { zkapp_command.fee_payer with authorization = fee_payer_signature }

  in

  let open Async_kernel.Deferred.Let_syntax in

  let%map account_updates_with_valid_authorizations =

      ~f:(fun _ndx ({ body; authorization; aux } : _ Account_update.Poly.t) tree

         ->

        let%map valid_authorization =

          match authorization with

              let pk = body.Account_update.Body.public_key in

              let sk =

                match

                  Signature_lib.Public_key.Compressed.Map.find keymap pk

                with

                    sk

                      "Could not find private key for public key %s in keymap"

                      ()

              in

              let use_full_commitment = body.use_full_commitment in

              let signature = sign_for_account_update ~use_full_commitment sk in

              match prover with

                  let txn_stmt = Zkapp_statement.of_tree tree in

                      (Snarky_backendless.Request.With { request; respond }) =

                  in

                  let%map (), (), proof =

                  in

        in

  in

    fee_payer = fee_payer_with_valid_signature

  ; account_updates = account_updates_with_valid_authorizations