331 lines
10 KiB
OCaml
331 lines
10 KiB
OCaml
(**************************************************************************)
|
|
(* *)
|
|
(* Copyright (c) 2014 - 2016. *)
|
|
(* Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
|
|
(* *)
|
|
(* All rights reserved. No warranty, explicit or implicit, provided. *)
|
|
(* *)
|
|
(**************************************************************************)
|
|
|
|
(* Tezos Protocol Implementation - Low level Repr. of Operations *)
|
|
|
|
type operation = {
|
|
hash: Operation_hash.t ;
|
|
shell: Updater.shell_operation ;
|
|
contents: proto_operation ;
|
|
signature: Ed25519.signature option ;
|
|
}
|
|
|
|
and proto_operation =
|
|
| Anonymous_operations of anonymous_operation list
|
|
| Sourced_operations of sourced_operations
|
|
|
|
and anonymous_operation =
|
|
| Seed_nonce_revelation of {
|
|
level: Raw_level_repr.t ;
|
|
nonce: Seed_repr.nonce ;
|
|
}
|
|
|
|
and sourced_operations =
|
|
| Manager_operations of {
|
|
source: Contract_repr.contract ;
|
|
public_key: Ed25519.public_key option ;
|
|
fee: Tez_repr.tez ;
|
|
counter: counter ;
|
|
operations: manager_operation list ;
|
|
}
|
|
| Delegate_operations of {
|
|
source: Ed25519.public_key ;
|
|
operations: delegate_operation list ;
|
|
}
|
|
|
|
and manager_operation =
|
|
| Transaction of {
|
|
amount: Tez_repr.tez ;
|
|
parameters: Script_repr.expr option ;
|
|
destination: Contract_repr.contract ;
|
|
}
|
|
| Origination of {
|
|
manager: Ed25519.Public_key_hash.t ;
|
|
delegate: Ed25519.Public_key_hash.t option ;
|
|
script: Script_repr.t ;
|
|
spendable: bool ;
|
|
delegatable: bool ;
|
|
credit: Tez_repr.tez ;
|
|
}
|
|
| Issuance of {
|
|
asset: Asset_repr.asset * Ed25519.Public_key_hash.t ;
|
|
amount: Tez_repr.tez ;
|
|
}
|
|
| Delegation of Ed25519.Public_key_hash.t option
|
|
|
|
and delegate_operation =
|
|
| Endorsement of {
|
|
block: Block_hash.t ;
|
|
slot: int ;
|
|
}
|
|
| Proposals of {
|
|
period: Voting_period_repr.t ;
|
|
proposals: Protocol_hash.t list ;
|
|
}
|
|
| Ballot of {
|
|
period: Voting_period_repr.t ;
|
|
proposal: Protocol_hash.t ;
|
|
ballot: Vote_repr.ballot ;
|
|
}
|
|
|
|
and counter = Int32.t
|
|
|
|
module Encoding = struct
|
|
|
|
open Data_encoding
|
|
|
|
let transaction_encoding =
|
|
(obj4
|
|
(req "kind" (constant "transaction"))
|
|
(req "amount" Tez_repr.encoding)
|
|
(req "destination" Contract_repr.encoding)
|
|
(opt "parameters" Script_repr.expr_encoding))
|
|
|
|
let transaction_case tag =
|
|
case ~tag transaction_encoding
|
|
(function
|
|
| Transaction { amount ; destination ; parameters } ->
|
|
Some ((), amount, destination, parameters)
|
|
| _ -> None)
|
|
(fun ((), amount, destination, parameters) ->
|
|
Transaction { amount ; destination ; parameters })
|
|
|
|
let origination_encoding =
|
|
(obj7
|
|
(req "kind" (constant "origination"))
|
|
(req "managerPubkey" Ed25519.Public_key_hash.encoding)
|
|
(req "balance" Tez_repr.encoding)
|
|
(opt "spendable" bool)
|
|
(opt "delegatable" bool)
|
|
(opt "delegate" Ed25519.Public_key_hash.encoding)
|
|
(req "script" Script_repr.encoding))
|
|
|
|
let origination_case tag =
|
|
case ~tag origination_encoding
|
|
(function
|
|
| Origination { manager ; credit ; spendable ;
|
|
delegatable ; delegate ; script } ->
|
|
Some ((), manager, credit, Some spendable,
|
|
Some delegatable, delegate, script)
|
|
| _ -> None)
|
|
(fun ((), manager, credit, spendable, delegatable, delegate, script) ->
|
|
let delegatable =
|
|
match delegatable with None -> true | Some b -> b in
|
|
let spendable =
|
|
match spendable with None -> true | Some b -> b in
|
|
Origination
|
|
{manager ; credit ; spendable ; delegatable ; delegate ; script })
|
|
|
|
let issuance_encoding =
|
|
(obj3
|
|
(req "kind" (constant "issuance"))
|
|
(req "asset" (tup2 Asset_repr.encoding Ed25519.Public_key_hash.encoding))
|
|
(req "quantity" Tez_repr.encoding))
|
|
|
|
let issuance_case tag =
|
|
case ~tag issuance_encoding
|
|
(function
|
|
| Issuance { asset ; amount } -> Some ((), asset, amount)
|
|
| _ -> None)
|
|
(fun ((), asset, amount) -> Issuance { asset ; amount })
|
|
|
|
let delegation_encoding =
|
|
(obj2
|
|
(req "kind" (constant "delegation"))
|
|
(opt "delegate" Ed25519.Public_key_hash.encoding))
|
|
|
|
let delegation_case tag =
|
|
case ~tag delegation_encoding
|
|
(function Delegation key -> Some ((), key) | _ -> None)
|
|
(fun ((), key) -> Delegation key)
|
|
|
|
let manager_kind_encoding =
|
|
(obj5
|
|
(req "source" Contract_repr.encoding)
|
|
(opt "public_key" Ed25519.public_key_encoding)
|
|
(req "fee" Tez_repr.encoding)
|
|
(req "counter" int32)
|
|
(req "operations"
|
|
(list (union ~tag_size:`Uint8 [
|
|
transaction_case 0 ;
|
|
origination_case 1 ;
|
|
issuance_case 2 ;
|
|
delegation_case 3 ;
|
|
]))))
|
|
|
|
let manager_kind_case tag =
|
|
case ~tag manager_kind_encoding
|
|
(function
|
|
| Manager_operations { source; public_key ; fee ; counter ;operations } ->
|
|
Some (source, public_key, fee, counter, operations)
|
|
| _ -> None)
|
|
(fun (source, public_key, fee, counter, operations) ->
|
|
Manager_operations { source; public_key ; fee ; counter ; operations })
|
|
|
|
let endorsement_encoding =
|
|
(obj3
|
|
(req "kind" (constant "endorsement"))
|
|
(req "block" Block_hash.encoding)
|
|
(req "slot" int31))
|
|
|
|
let endorsement_case tag =
|
|
case ~tag endorsement_encoding
|
|
(function
|
|
| Endorsement { block ; slot } ->
|
|
Some ((), block, slot)
|
|
| _ -> None)
|
|
(fun ((), block, slot) ->
|
|
Endorsement { block ; slot })
|
|
|
|
let proposal_encoding =
|
|
(obj3
|
|
(req "kind" (constant "proposal"))
|
|
(req "period" Voting_period_repr.encoding)
|
|
(req "proposals" (list Protocol_hash.encoding)))
|
|
|
|
let proposal_case tag =
|
|
case ~tag proposal_encoding
|
|
(function
|
|
| Proposals { period ; proposals } ->
|
|
Some ((), period, proposals)
|
|
| _ -> None)
|
|
(fun ((), period, proposals) ->
|
|
Proposals { period ; proposals })
|
|
|
|
let ballot_encoding =
|
|
(obj4
|
|
(req "kind" (constant "ballot"))
|
|
(req "period" Voting_period_repr.encoding)
|
|
(req "proposal" Protocol_hash.encoding)
|
|
(req "ballot" Vote_repr.ballot_encoding))
|
|
|
|
let ballot_case tag =
|
|
case ~tag ballot_encoding
|
|
(function
|
|
| Ballot { period ; proposal ; ballot } ->
|
|
Some ((), period, proposal, ballot)
|
|
| _ -> None)
|
|
(fun ((), period, proposal, ballot) ->
|
|
Ballot { period ; proposal ; ballot })
|
|
|
|
let delegate_kind_encoding =
|
|
(obj2
|
|
(req "source" Ed25519.public_key_encoding)
|
|
(req "operations"
|
|
(list (union [
|
|
endorsement_case 0 ;
|
|
proposal_case 1 ;
|
|
ballot_case 2 ;
|
|
]))))
|
|
|
|
let delegate_kind_case tag =
|
|
case ~tag delegate_kind_encoding
|
|
(function
|
|
| Delegate_operations { source ; operations } ->
|
|
Some (source, operations)
|
|
| _ -> None)
|
|
(fun (source, operations) -> Delegate_operations { source ; operations })
|
|
|
|
let signed_operations_case tag =
|
|
case ~tag
|
|
(union [
|
|
manager_kind_case 0 ;
|
|
delegate_kind_case 1 ;
|
|
])
|
|
(function Sourced_operations ops -> Some ops | _ -> None)
|
|
(fun ops -> Sourced_operations ops)
|
|
|
|
let seed_nonce_revelation_encoding =
|
|
(obj3
|
|
(req "kind" (constant "seed_nonce_revelation"))
|
|
(req "level" Raw_level_repr.encoding)
|
|
(req "nonce" Seed_repr.nonce_encoding))
|
|
|
|
let seed_nonce_revelation_case tag =
|
|
case ~tag seed_nonce_revelation_encoding
|
|
(function
|
|
| Seed_nonce_revelation { level ; nonce } -> Some ((), level, nonce)
|
|
(* | _ -> None *)
|
|
)
|
|
(fun ((), level, nonce) -> Seed_nonce_revelation { level ; nonce })
|
|
|
|
let unsigned_operation_case tag =
|
|
case ~tag
|
|
(obj1
|
|
(req "operations"
|
|
(list
|
|
(union [
|
|
seed_nonce_revelation_case 0 ;
|
|
]))))
|
|
(function Anonymous_operations ops -> Some ops | _ -> None)
|
|
(fun ops -> Anonymous_operations ops)
|
|
|
|
let proto_operation_encoding =
|
|
union [
|
|
signed_operations_case 0 ;
|
|
unsigned_operation_case 1 ;
|
|
]
|
|
|
|
let unsigned_operation_encoding =
|
|
merge_objs
|
|
Updater.shell_operation_encoding
|
|
proto_operation_encoding
|
|
|
|
let signed_proto_operation_encoding =
|
|
merge_objs
|
|
proto_operation_encoding
|
|
(obj1 (varopt "signature" Ed25519.signature_encoding))
|
|
|
|
end
|
|
|
|
type error += Cannot_parse_operation
|
|
|
|
let parse hash (op: Updater.raw_operation) =
|
|
if not (Compare.Int.(MBytes.length op.proto <= Constants_repr.max_operation_data_length)) then
|
|
error Cannot_parse_operation
|
|
else
|
|
match Data_encoding.Binary.of_bytes
|
|
Encoding.signed_proto_operation_encoding
|
|
op.proto with
|
|
| Some (contents, signature) ->
|
|
let shell = { Updater.net_id = op.shell.net_id } in
|
|
ok { hash ; shell ; contents ; signature }
|
|
| None -> error Cannot_parse_operation
|
|
|
|
type error +=
|
|
| Invalid_signature
|
|
| Missing_signature
|
|
|
|
let forge shell proto =
|
|
Data_encoding.Binary.to_bytes
|
|
Encoding.unsigned_operation_encoding (shell, proto)
|
|
|
|
let check_signature key { shell ; contents ; signature } =
|
|
match contents, signature with
|
|
| Anonymous_operations _, _ -> return ()
|
|
| Sourced_operations _, None ->
|
|
fail Missing_signature
|
|
| Sourced_operations _, Some signature ->
|
|
let unsigned_operation = forge shell contents in
|
|
if Ed25519.check_signature key signature unsigned_operation then
|
|
return ()
|
|
else
|
|
fail Invalid_signature
|
|
|
|
let parse_proto bytes =
|
|
match Data_encoding.Binary.of_bytes
|
|
Encoding.signed_proto_operation_encoding
|
|
bytes with
|
|
| Some (proto, signature) -> return (proto, signature)
|
|
| None -> fail Cannot_parse_operation
|
|
|
|
include Encoding
|
|
|
|
let max_operation_data_length = Constants_repr.max_operation_data_length
|