balsoft/ligo
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Shell/Alpha: allow usage of secp256k1 for signature

Browse Source
This commit is contained in:
Arthur B 2018-04-05 17:35:35 +02:00 committed by Benjamin Canou
parent 9adee55234
commit eb1dfb7f20
84 changed files with 1302 additions and 397 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
src/bin_client/test/test_basic.sh
View File

@ -14,8 +14,8 @@ sleep 2
$client rpc call '/blocks/head/raw_context/version' | assert '{ "content": "616c706861" }'
$client rpc call '/blocks/head/raw_context/non-existent' | assert 'No service found at this URL'
$client rpc call '/blocks/head/raw_context/delegates/?depth=2' | assert '{ "content":
{ "02": { "29": null }, "a9": { "ce": null }, "c5": { "5c": null },
"da": { "c9": null }, "e7": { "67": null } } }'
{ "ed25519":
{ "02": null, "a9": null, "c5": null, "da": null, "e7": null } } }'
$client rpc call '/blocks/head/raw_context/non-existent?depth=-1' | assert 'No service found at this URL'
$client rpc call '/blocks/head/raw_context/non-existent?depth=0' | assert 'No service found at this URL'
@ -25,24 +25,30 @@ sleep 1
key1=foo
key2=bar
key3=boo
$client gen keys $key1
$client gen keys $key2
$client gen keys $key2 --sig secp256k1
$client gen keys $key3 --sig ed25519
$client list known identities
$client get balance for bootstrap1
bake_after $client transfer 1,000 from bootstrap1 to $key1
bake_after $client transfer 2,000 from bootstrap1 to $key2
bake_after $client transfer 3,000 from bootstrap1 to $key3
$client get balance for $key1 | assert "1,000 ꜩ"
$client get balance for $key2 | assert "2,000 ꜩ"
$client get balance for $key3 | assert "3,000 ꜩ"
bake_after $client transfer 1,000 from $key2 to $key1
bake_after $client transfer 1,000 from $key2 to $key1 -fee 0
$client get balance for $key1 | assert "2,000 ꜩ"
$client get balance for $key2 | assert "999.95 ꜩ"
$client get balance for $key2 | assert "1,000 ꜩ"
bake_after $client transfer 1,000 from $key1 to $key2
$client get balance for $key1 | assert "999.95 ꜩ"
$client get balance for $key2 | assert "2,000 ꜩ"
# Should fail
# $client transfer 999.95 from $key2 to $key1

40
src/lib_client_base/client_keys.ml
View File

@ -22,10 +22,10 @@ let () =
(fun s -> Unregistered_key_scheme s)
module Public_key_hash = Client_aliases.Alias (struct
type t = Ed25519.Public_key_hash.t
let encoding = Ed25519.Public_key_hash.encoding
let of_source s = Lwt.return (Ed25519.Public_key_hash.of_b58check s)
let to_source p = return (Ed25519.Public_key_hash.to_b58check p)
type t = Signature.Public_key_hash.t
let encoding = Signature.Public_key_hash.encoding
let of_source s = Lwt.return (Signature.Public_key_hash.of_b58check s)
let to_source p = return (Signature.Public_key_hash.to_b58check p)
let name = "public key hash"
end)
@ -106,9 +106,9 @@ module Locator (K : KEY) (L : LOCATOR) = struct
let encoding = Data_encoding.(conv to_string of_string string)
end
module Secret_key_locator = Locator(Ed25519.Secret_key)(Sk_locator)
module Secret_key_locator = Locator(Signature.Secret_key)(Sk_locator)
module Secret_key = Client_aliases.Alias (Secret_key_locator)
module Public_key_locator = Locator(Ed25519.Public_key)(Pk_locator)
module Public_key_locator = Locator(Signature.Public_key)(Pk_locator)
module Public_key = Client_aliases.Alias (Public_key_locator)
module type SIGNER = sig
@ -125,9 +125,9 @@ module type SIGNER = sig
val sk_to_locator : secret_key -> sk_locator Lwt.t
val pk_to_locator : public_key -> pk_locator Lwt.t
val neuterize : secret_key -> public_key Lwt.t
val public_key : public_key -> Ed25519.Public_key.t Lwt.t
val public_key_hash : public_key -> Ed25519.Public_key_hash.t Lwt.t
val sign : secret_key -> MBytes.t -> Ed25519.t tzresult Lwt.t
val public_key : public_key -> Signature.Public_key.t Lwt.t
val public_key_hash : public_key -> Signature.Public_key_hash.t Lwt.t
val sign : secret_key -> MBytes.t -> Signature.t tzresult Lwt.t
end
let signers_table : (string, (module SIGNER) * bool) Hashtbl.t = Hashtbl.create 13
@ -157,22 +157,20 @@ let sign cctxt ((Sk_locator { scheme }) as skloc) buf =
let append cctxt loc buf =
sign cctxt loc buf >>|? fun signature ->
MBytes.concat buf (Ed25519.to_bytes signature)
Signature.concat buf signature
let gen_keys ?(force=false) ?seed (cctxt : #Client_context.io_wallet) name =
let seed =
match seed with
| None -> Ed25519.Seed.generate ()
| Some s -> s in
let _, public_key, secret_key = Ed25519.generate_seeded_key seed in
let gen_keys ?(force=false) ?algo ?seed (cctxt : #Client_context.io_wallet) name =
let public_key_hash, public_key, secret_key =
Signature.generate_key ?algo ?seed () in
Secret_key.add ~force cctxt name
(Secret_key_locator.of_unencrypted secret_key) >>=? fun () ->
Public_key.add ~force cctxt name
(Public_key_locator.of_unencrypted public_key) >>=? fun () ->
Public_key_hash.add ~force
cctxt name (Ed25519.Public_key.hash public_key) >>=? fun () ->
cctxt name public_key_hash >>=? fun () ->
return ()
let gen_keys_containing ?(prefix=false) ?(force=false) ~containing ~name (cctxt : #Client_context.full) =
let unrepresentable =
List.filter (fun s -> not @@ Base58.Alphabet.all_in_alphabet Base58.Alphabet.bitcoin s) containing in
@ -208,15 +206,17 @@ let gen_keys_containing ?(prefix=false) ?(force=false) ~containing ~name (cctxt
with Not_found -> false) in
let rec loop attempts =
let seed = Ed25519.Seed.generate () in
let _, public_key, secret_key = Ed25519.generate_seeded_key seed in
let hash = Ed25519.Public_key_hash.to_b58check @@ Ed25519.Public_key.hash public_key in
let public_key_hash, public_key, secret_key =
Signature.generate_key ~seed () in
let hash = Signature.Public_key_hash.to_b58check @@
Signature.Public_key.hash public_key in
if matches hash
then
Secret_key.add ~force cctxt name
(Secret_key_locator.of_unencrypted secret_key) >>=? fun () ->
Public_key.add ~force cctxt name
(Public_key_locator.of_unencrypted public_key) >>=? fun () ->
Public_key_hash.add ~force cctxt name (Ed25519.Public_key.hash public_key) >>=? fun () ->
Public_key_hash.add ~force cctxt name public_key_hash >>=? fun () ->
return hash
else begin if attempts mod 25_000 = 0
then cctxt#message "Tried %d keys without finding a match" attempts

17
src/lib_client_base/client_keys.mli
View File

@ -29,7 +29,7 @@ module Public_key_locator : LOCATOR with type t = pk_locator
(** {2 Cryptographic keys tables } *)
module Public_key_hash :
Client_aliases.Alias with type t = Ed25519.Public_key_hash.t
Client_aliases.Alias with type t = Signature.Public_key_hash.t
module Public_key :
Client_aliases.Alias with type t = pk_locator
module Secret_key :
@ -84,13 +84,13 @@ module type SIGNER = sig
val neuterize : secret_key -> public_key Lwt.t
(** [neuterize sk] is the corresponding [pk]. *)
val public_key : public_key -> Ed25519.Public_key.t Lwt.t
(** [public_key pk] is the Ed25519 version of [pk]. *)
val public_key : public_key -> Signature.Public_key.t Lwt.t
(** [public_key pk] is the full version of [pk]. *)
val public_key_hash : public_key -> Ed25519.Public_key_hash.t Lwt.t
val public_key_hash : public_key -> Signature.Public_key_hash.t Lwt.t
(** [public_key_hash pk] is the hash of [pk]. *)
val sign : secret_key -> MBytes.t -> Ed25519.t tzresult Lwt.t
val sign : secret_key -> MBytes.t -> Signature.t tzresult Lwt.t
(** [sign sk data] is signature obtained by signing [data] with
[sk]. *)
end
@ -105,13 +105,14 @@ val find_signer_for_key :
#Client_context.io_wallet -> scheme:string -> (module SIGNER) tzresult Lwt.t
val sign :
#Client_context.io_wallet ->
sk_locator -> MBytes.t -> Ed25519.t tzresult Lwt.t
sk_locator -> MBytes.t -> Signature.t tzresult Lwt.t
val append :
#Client_context.io_wallet ->
sk_locator -> MBytes.t -> MBytes.t tzresult Lwt.t
val gen_keys :
?force:bool ->
?algo:Signature.algo ->
?seed:Ed25519.Seed.t ->
#Client_context.io_wallet -> string -> unit tzresult Lwt.t
@ -133,10 +134,10 @@ val alias_keys :
val get_key:
#Client_context.io_wallet ->
Public_key_hash.t ->
(string * Ed25519.Public_key.t * sk_locator) tzresult Lwt.t
(string * Signature.Public_key.t * sk_locator) tzresult Lwt.t
val get_keys:
#Client_context.io_wallet ->
(string * Public_key_hash.t * Ed25519.Public_key.t * sk_locator) list tzresult Lwt.t
(string * Public_key_hash.t * Signature.Public_key.t * sk_locator) list tzresult Lwt.t
val force_switch : unit -> (bool, #Client_context.full) Clic.arg

6
src/lib_client_base_unix/client_main_run.ml
View File

@ -140,13 +140,13 @@ let main select_commands =
Lwt.return 1
end begin function
| Client_commands.Version_not_found ->
Format.eprintf "@{<error>@{<title>Fatal error@}@} unknown protocol version." ;
Format.eprintf "@{<error>@{<title>Fatal error@}@} unknown protocol version.@." ;
Lwt.return 1
| Failure message ->
Format.eprintf "@{<error>@{<title>Fatal error@}@} %s." message ;
Format.eprintf "@{<error>@{<title>Fatal error@}@} %s.@." message ;
Lwt.return 1
| exn ->
Format.printf "@{<error>@{<title>Fatal error@}@} %s." (Printexc.to_string exn) ;
Format.printf "@{<error>@{<title>Fatal error@}@} %s.@." (Printexc.to_string exn) ;
Lwt.return 1
end >>= fun retcode ->
Format.pp_print_flush Format.err_formatter () ;

38
src/lib_client_base_unix/client_signer_encrypted.ml
View File

@ -24,8 +24,8 @@ module Encrypted_signer : SIGNER = struct
The format for importing public keys is the raw Base58-encoded \
key (starting with 'edpk')."
type secret_key = Ed25519.Secret_key.t
type public_key = Ed25519.Public_key.t
type secret_key = Signature.Secret_key.t
type public_key = Signature.Public_key.t
(* https://tools.ietf.org/html/rfc2898#section-4.1 *)
let salt_len = 8
@ -33,7 +33,7 @@ module Encrypted_signer : SIGNER = struct
(* Fixed zero nonce *)
let nonce = Crypto_box.zero_nonce
(* skloc -> Ed25519.Secret_key.t *)
(* skloc -> Signature.Secret_key.t *)
let decrypted_sks = Hashtbl.create 13
let pbkdf ~salt ~password =
@ -67,7 +67,9 @@ module Encrypted_signer : SIGNER = struct
match Crypto_box.Secretbox.box_open key skenc nonce with
| None -> passwd_ask_loop cctxt ~name ~salt ~skenc
| Some decrypted_sk ->
Lwt.return (password, (Ed25519.Secret_key.of_bytes_exn decrypted_sk))
Lwt.return (password, (Data_encoding.Binary.of_bytes_exn
Signature.Secret_key.encoding
decrypted_sk))
let ask_all_passwords (cctxt : #Client_context.io_wallet) sks =
Lwt_list.fold_left_s begin fun a (name, skloc) ->
@ -82,7 +84,7 @@ module Encrypted_signer : SIGNER = struct
match decrypt_sk skenc salt a with
| Some sk ->
Hashtbl.replace decrypted_sks location
(Ed25519.Secret_key.of_bytes_exn sk) ;
(Data_encoding.Binary.of_bytes_exn Signature.Secret_key.encoding sk) ;
Lwt.return a
| None ->
passwd_ask_loop
@ -110,7 +112,7 @@ module Encrypted_signer : SIGNER = struct
let password = MBytes.of_string password in
let salt = Rand.generate salt_len in
let key = Crypto_box.Secretbox.of_bytes_exn (pbkdf ~password ~salt) in
let msg = Ed25519.Secret_key.to_bytes sk in
let msg = Data_encoding.Binary.to_bytes Signature.Secret_key.encoding sk in
let encrypted_passwd = Crypto_box.Secretbox.box key msg nonce in
let payload = MBytes.(to_string (concat salt encrypted_passwd)) in
let location = Base58.safe_encode payload in
@ -143,25 +145,25 @@ module Encrypted_signer : SIGNER = struct
"Enter the password used for the paper wallet: " >>= fun password ->
let sk = Bip39.to_seed ~passphrase:(password ^ email) t in
let sk = Cstruct.(to_bigarray (sub sk 0 32)) in
let sk = Ed25519.Secret_key.of_bytes_exn sk in
let pk = Ed25519.Secret_key.to_public_key sk in
let pkh = Ed25519.Public_key.hash pk in
let sk = Data_encoding.Binary.of_bytes_exn Signature.Secret_key.encoding sk in
let pk = Signature.Secret_key.to_public_key sk in
let pkh = Signature.Public_key.hash pk in
let msg = Format.asprintf
"Your public Tezos address is %a is that correct?"
Ed25519.Public_key_hash.pp pkh in
Signature.Public_key_hash.pp pkh in
get_boolean_answer cctxt ~msg ~default:true >>=? function
| true -> return sk
| false -> sk_of_mnemonic cctxt
let sk_locator_of_human_input cctxt = function
| sk :: _ ->
Lwt.return (Ed25519.Secret_key.of_b58check sk) >>=? fun sk ->
Lwt.return (Signature.Secret_key.of_b58check sk) >>=? fun sk ->
encrypt_sk cctxt sk
| [] -> begin
get_boolean_answer
cctxt ~msg:"Generate a new key" ~default:true >>=? function
| true ->
let _, _, sk = Ed25519.generate_key () in
let _, _, sk = Signature.generate_key () in
encrypt_sk cctxt sk
| false ->
get_boolean_answer cctxt
@ -182,22 +184,22 @@ module Encrypted_signer : SIGNER = struct
| sk -> return sk
let pk_of_locator (Pk_locator { location }) =
Lwt.return (Ed25519.Public_key.of_b58check location)
Lwt.return (Signature.Public_key.of_b58check location)
let sk_to_locator sk =
Secret_key_locator.create
~scheme ~location:(Ed25519.Secret_key.to_b58check sk) |>
~scheme ~location:(Signature.Secret_key.to_b58check sk) |>
Lwt.return
let pk_to_locator pk =
Public_key_locator.create
~scheme ~location:(Ed25519.Public_key.to_b58check pk) |>
~scheme ~location:(Signature.Public_key.to_b58check pk) |>
Lwt.return
let neuterize x = Lwt.return (Ed25519.Secret_key.to_public_key x)
let neuterize x = Lwt.return (Signature.Secret_key.to_public_key x)
let public_key x = Lwt.return x
let public_key_hash x = Lwt.return (Ed25519.Public_key.hash x)
let sign t buf = return (Ed25519.sign t buf)
let public_key_hash x = Lwt.return (Signature.Public_key.hash x)
let sign t buf = return (Signature.sign t buf)
end
let () =

18
src/lib_client_base_unix/client_signer_unencrypted.ml
View File

@ -23,8 +23,8 @@ module Unencrypted_signer : SIGNER = struct
The format for importing public keys is the raw Base58-encoded \
key (starting with 'edpk')."
type secret_key = Ed25519.Secret_key.t
type public_key = Ed25519.Public_key.t
type secret_key = Signature.Secret_key.t
type public_key = Signature.Public_key.t
let init _wallet = return ()
@ -41,25 +41,25 @@ module Unencrypted_signer : SIGNER = struct
| pk :: _ -> return (Public_key_locator.create ~scheme ~location:pk)
let sk_of_locator (Sk_locator { location }) =
Lwt.return (Ed25519.Secret_key.of_b58check location)
Lwt.return (Signature.Secret_key.of_b58check location)
let pk_of_locator (Pk_locator { location }) =
Lwt.return (Ed25519.Public_key.of_b58check location)
Lwt.return (Signature.Public_key.of_b58check location)
let sk_to_locator sk =
Secret_key_locator.create
~scheme ~location:(Ed25519.Secret_key.to_b58check sk) |>
~scheme ~location:(Signature.Secret_key.to_b58check sk) |>
Lwt.return
let pk_to_locator pk =
Public_key_locator.create
~scheme ~location:(Ed25519.Public_key.to_b58check pk) |>
~scheme ~location:(Signature.Public_key.to_b58check pk) |>
Lwt.return
let neuterize x = Lwt.return (Ed25519.Secret_key.to_public_key x)
let neuterize x = Lwt.return (Signature.Secret_key.to_public_key x)
let public_key x = Lwt.return x
let public_key_hash x = Lwt.return (Ed25519.Public_key.hash x)
let sign t buf = return (Ed25519.sign t buf)
let public_key_hash x = Lwt.return (Signature.Public_key.hash x)
let sign t buf = return (Signature.sign t buf)
end
let () =

19
src/lib_client_commands/client_keys_commands.ml
View File

@ -13,6 +13,15 @@ let group =
{ Clic.name = "keys" ;
title = "Commands for managing the wallet of cryptographic keys" }
let sig_algo_arg =
Clic.default_arg
~doc:"use custom signature algorithm"
~long:"sig"
~short:'s'
~placeholder:"ed25519|secp256k1"
~default: "ed25519"
(Signature.algo_param ())
let commands () =
let open Clic in
let show_private_switch =
@ -46,13 +55,13 @@ let commands () =
signers >>= return) ;
command ~group ~desc: "Generate a pair of (unencrypted) keys."
(args1 (Secret_key.force_switch ()))
(args2 (Secret_key.force_switch ()) sig_algo_arg)
(prefixes [ "gen" ; "keys" ]
@@ Secret_key.fresh_alias_param
@@ stop)
(fun force name (cctxt : #Client_context.full) ->
(fun (force, algo) name (cctxt : #Client_context.full) ->
Secret_key.of_fresh cctxt force name >>=? fun name ->
gen_keys ~force cctxt name) ;
gen_keys ~force ~algo cctxt name) ;
command ~group ~desc: "Generate (unencrypted) keys including the given string."
(args2
@ -176,7 +185,7 @@ let commands () =
| None -> ok_lwt @@ cctxt#message "No keys found for identity"
| Some (pkh, pk, skloc) ->
ok_lwt @@ cctxt#message "Hash: %a"
Ed25519.Public_key_hash.pp pkh >>=? fun () ->
Signature.Public_key_hash.pp pkh >>=? fun () ->
match pk with
| None -> return ()
| Some (Pk_locator { scheme } as pkloc) ->
@ -185,7 +194,7 @@ let commands () =
Signer.pk_of_locator pkloc >>=? fun pk ->
Signer.public_key pk >>= fun pk ->
ok_lwt @@ cctxt#message "Public Key: %a"
Ed25519.Public_key.pp pk >>=? fun () ->
Signature.Public_key.pp pk >>=? fun () ->
if show_private then
match skloc with
| None -> return ()

8
src/lib_crypto/base58.ml
View File

@ -309,16 +309,24 @@ module Prefix = struct
(* 20 *)
let ed25519_public_key_hash = "\006\161\159" (* tz1(36) *)
(* 20 *)
let secp256k1_public_key_hash = "\006\161\161" (* tz2(36) *)
(* 16 *)
let cryptobox_public_key_hash = "\153\103" (* id(30) *)
(* 32 *)
let ed25519_seed = "\013\015\058\007" (* edsk(54) *)
let ed25519_public_key = "\013\015\037\217" (* edpk(54) *)
let secp256k1_secret_key = "\017\162\224\201" (* spsk(54) *)
(* 33 *)
let secp256k1_public_key = "\003\254\226\086" (* sppk(55) *)
(* 64 *)
let ed25519_secret_key = "\043\246\078\007" (* edsk(98) *)
let ed25519_signature = "\009\245\205\134\018" (* edsig(99) *)
let secp256k1_signature = "\013\115\101\019\063" (* spsig1(99) *)
(* 4 *)
let chain_id = "\087\082\000" (* Net(15) *)

4
src/lib_crypto/base58.mli
View File

@ -18,11 +18,15 @@ module Prefix : sig
val protocol_hash: string
val context_hash: string
val ed25519_public_key_hash: string
val secp256k1_public_key_hash: string
val cryptobox_public_key_hash: string
val ed25519_seed: string
val ed25519_public_key: string
val ed25519_secret_key: string
val ed25519_signature: string
val secp256k1_public_key: string
val secp256k1_secret_key: string
val secp256k1_signature: string
val chain_id: string
end

1
src/lib_crypto/jbuild
View File

@ -18,6 +18,7 @@
nocrypto
blake2
tweetnacl
secp256k1-internal
zarith))))
(alias

2
src/lib_crypto/s.ml
View File

@ -172,7 +172,6 @@ module type SIGNATURE = sig
val pp: Format.formatter -> t -> unit
include Compare.S with type t := t
include RAW_DATA with type t := t
include B58_DATA with type t := t
include ENCODER with type t := t
@ -186,7 +185,6 @@ module type SIGNATURE = sig
val pp: Format.formatter -> t -> unit
include Compare.S with type t := t
include RAW_DATA with type t := t
include B58_DATA with type t := t
include ENCODER with type t := t

271
src/lib_crypto/secp256k1.ml Normal file
View File

@ -0,0 +1,271 @@
(**************************************************************************)
(* *)
(* Copyright (c) 2014 - 2018. *)
(* Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* All rights reserved. No warranty, explicit or implicit, provided. *)
(* *)
(**************************************************************************)
module Public_key_hash = Blake2B.Make(Base58)(struct
let name = "Secp256k1.Public_key_hash"
let title = "A Secp256k1 public key hash"
let b58check_prefix = Base58.Prefix.secp256k1_public_key_hash
let size = Some 20
end)
let () =
Base58.check_encoded_prefix Public_key_hash.b58check_encoding "tz2" 36
open Secp256k1_ml.External
let context = Context.(create [Verify; Sign])
module Public_key = struct
type t = Key.public Key.t
let name = "Secp256k1.Public_key"
let title = "A Secp256k1 public key"
let to_bytes pk = Key.to_bytes context pk
let of_bytes_opt s =
try Some (Key.read_pk_exn context s)
with _ -> None
let to_string s = MBytes.to_string (to_bytes s)
let of_string_opt s = of_bytes_opt (MBytes.of_string s)
let size = 33 (* TODO not hardcoded ?? *)
type Base58.data +=
| Data of t
let b58check_encoding =
Base58.register_encoding
~prefix: Base58.Prefix.secp256k1_public_key
~length: size
~to_raw: to_string
~of_raw: of_string_opt
~wrap: (fun x -> Data x)
let () =
Base58.check_encoded_prefix b58check_encoding "sppk" 55
let hash v =
Public_key_hash.hash_bytes [to_bytes v]
include Compare.Make(struct
type nonrec t = t
let compare a b =
MBytes.compare (Key.to_buffer a) (Key.to_buffer b)
end)
include Helpers.MakeRaw(struct
type nonrec t = t
let name = name
let of_bytes_opt = of_bytes_opt
let of_string_opt = of_string_opt
let to_string = to_string
end)
include Helpers.MakeB58(struct
type nonrec t = t
let title = title
let name = name
let b58check_encoding = b58check_encoding
end)
include Helpers.MakeEncoder(struct
type nonrec t = t
let name = name
let title = title
let raw_encoding =
let open Data_encoding in
conv to_bytes of_bytes_exn (Fixed.bytes size)
let of_b58check = of_b58check
let of_b58check_opt = of_b58check_opt
let of_b58check_exn = of_b58check_exn
let to_b58check = to_b58check
let to_short_b58check = to_short_b58check
end)
let pp ppf t = Format.fprintf ppf "%s" (to_b58check t)
end
module Secret_key = struct
type t = Key.secret Key.t
let name = "Secp256k1.Secret_key"
let title = "A Secp256k1 secret key"
let size = 32 (* TODO don't hardcode *)
let of_bytes_opt s =
match Key.read_sk context s with
| Ok x -> Some x
| _ -> None
let to_bytes x = Key.to_bytes context x
let to_string s = MBytes.to_string (to_bytes s)
let of_string_opt s = of_bytes_opt (MBytes.of_string s)
let to_public_key key = Key.neuterize_exn context key
type Base58.data +=
| Data of t
let b58check_encoding =
Base58.register_encoding
~prefix: Base58.Prefix.secp256k1_secret_key
~length: size
~to_raw: to_string
~of_raw: of_string_opt
~wrap: (fun x -> Data x)
let () =
Base58.check_encoded_prefix b58check_encoding "spsk" 54
include Compare.Make(struct
type nonrec t = t
let compare a b =
MBytes.compare (Key.to_buffer a) (Key.to_buffer b)
end)
include Helpers.MakeRaw(struct
type nonrec t = t
let name = name
let of_bytes_opt = of_bytes_opt
let of_string_opt = of_string_opt
let to_string = to_string
end)
include Helpers.MakeB58(struct
type nonrec t = t
let title = title
let name = name
let b58check_encoding = b58check_encoding
end)
include Helpers.MakeEncoder(struct
type nonrec t = t
let name = name
let title = title
let raw_encoding =
let open Data_encoding in
conv to_bytes of_bytes_exn (Fixed.bytes size)
let of_b58check = of_b58check
let of_b58check_opt = of_b58check_opt
let of_b58check_exn = of_b58check_exn
let to_b58check = to_b58check
let to_short_b58check = to_short_b58check
end)
let pp ppf t = Format.fprintf ppf "%s" (to_b58check t)
end
type t = MBytes.t
let name = "Secp256k1"
let title = "A Secp256k1 signature"
let size = 64 (* TODO don't hardcode? *)
let of_bytes_opt s =
if MBytes.length s = size then Some s else None
let to_bytes x = x
let to_string s = MBytes.to_string (to_bytes s)
let of_string_opt s = of_bytes_opt (MBytes.of_string s)
type Base58.data +=
| Data of t
let b58check_encoding =
Base58.register_encoding
~prefix: Base58.Prefix.secp256k1_signature
~length: size
~to_raw: to_string
~of_raw: of_string_opt
~wrap: (fun x -> Data x)
let () =
Base58.check_encoded_prefix b58check_encoding "spsig1" 99
include Compare.Make(struct
type nonrec t = t
let compare = MBytes.compare
end)
include Helpers.MakeRaw(struct
type nonrec t = t
let name = name
let of_bytes_opt = of_bytes_opt
let of_string_opt = of_string_opt
let to_string = to_string
end)
include Helpers.MakeB58(struct
type nonrec t = t
let title = title
let name = name
let b58check_encoding = b58check_encoding
end)
include Helpers.MakeEncoder(struct
type nonrec t = t
let name = name
let title = title
let raw_encoding =
let open Data_encoding in
conv to_bytes of_bytes_exn (Fixed.bytes size)
let of_b58check = of_b58check
let of_b58check_opt = of_b58check_opt
let of_b58check_exn = of_b58check_exn
let to_b58check = to_b58check
let to_short_b58check = to_short_b58check
end)
let pp ppf t = Format.fprintf ppf "%s" (to_b58check t)
let zero = of_bytes_exn (MBytes.init size '\000')
let sign secret_key message =
match Sign.msg_of_bytes message with
| None ->
Pervasives.invalid_arg
"Secp256k1.sign: argument message couldn't be converted"
| Some msg -> begin
match Sign.sign context ~sk:secret_key ~msg with
| Ok signature ->
Sign.to_bytes ~der:false context signature
| _ ->
Pervasives.invalid_arg "Secp256k1.sign: couldn't sign"
end
let check public_key signature msg =
match Sign.msg_of_bytes msg, Sign.read context signature with
| Some msg, Ok signature -> begin
match Sign.verify context ~pk:public_key ~msg ~signature with
| Ok b -> b
| _ -> false
end
| _, _ -> false
let concat msg signature =
MBytes.concat msg signature
let append key msg =
let signature = sign key msg in
concat msg signature
let generate_key () =
let sk = Key.read_sk_exn context (Cstruct.to_bigarray (Tweetnacl.Rand.gen 32)) in
let pk = Key.neuterize_exn context sk in
let pkh = Public_key.hash pk in
(pkh, pk, sk)

14
src/lib_crypto/secp256k1.mli Normal file
View File

@ -0,0 +1,14 @@
(**************************************************************************)
(* *)
(* Copyright (c) 2014 - 2018. *)
(* Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* All rights reserved. No warranty, explicit or implicit, provided. *)
(* *)
(**************************************************************************)
(** Tezos - Secp256k1 cryptography *)
include S.SIGNATURE
include S.RAW_DATA with type t := t

495
src/lib_crypto/signature.ml Normal file
View File

@ -0,0 +1,495 @@
(**************************************************************************)
(* *)
(* Copyright (c) 2014 - 2018. *)
(* Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* All rights reserved. No warranty, explicit or implicit, provided. *)
(* *)
(**************************************************************************)
open Error_monad
type public_key_hash =
| Ed25519 of Ed25519.Public_key_hash.t
| Secp256k1 of Secp256k1.Public_key_hash.t
type public_key =
| Ed25519 of Ed25519.Public_key.t
| Secp256k1 of Secp256k1.Public_key.t
type secret_key =
| Ed25519 of Ed25519.Secret_key.t
| Secp256k1 of Secp256k1.Secret_key.t
module Public_key_hash = struct
type t = public_key_hash =
| Ed25519 of Ed25519.Public_key_hash.t
| Secp256k1 of Secp256k1.Public_key_hash.t
let name = "Signature.Public_key_hash"
let title = "A Secp256k1 or Ed25519 public key hash"
type Base58.data += Data of t (* unused *)
let b58check_encoding = (* unused *)
Base58.register_encoding
~prefix: "\255\255"
~length: 2
~to_raw: (fun _ -> assert false)
~of_raw: (fun _ -> assert false)
~wrap: (fun x -> Data x)
let raw_encoding =
let open Data_encoding in
union [
case (Tag 0) Ed25519.Public_key_hash.encoding
(function Ed25519 x -> Some x | _ -> None)
(function x -> Ed25519 x);
case (Tag 1) Secp256k1.Public_key_hash.encoding
(function Secp256k1 x -> Some x | _ -> None)
(function x -> Secp256k1 x)
]
let to_bytes s =
Data_encoding.Binary.to_bytes raw_encoding s
let of_bytes_opt s =
Data_encoding.Binary.of_bytes raw_encoding s
let to_string s = MBytes.to_string (to_bytes s)
let of_string_opt s = of_bytes_opt (MBytes.of_string s)
let size = 1 + Ed25519.size
include Helpers.MakeRaw(struct
type nonrec t = t
let name = name
let of_bytes_opt = of_bytes_opt
let of_string_opt = of_string_opt
let to_string = to_string
end)
let of_b58check_opt s =
match Base58.decode s with
| Some Ed25519.Public_key_hash.Data pkh -> Some (Ed25519 pkh)
| Some Secp256k1.Public_key_hash.Data pkh -> Some (Secp256k1 pkh)
| _ -> None
let of_b58check_exn s =
match of_b58check_opt s with
| Some x -> x
| None -> Format.kasprintf Pervasives.failwith "Unexpected data (%s)" name
let of_b58check s =
match of_b58check_opt s with
| Some x -> Ok x
| None ->
generic_error
"Failed to read a b58check_encoding data (%s): %S"
name s
let to_b58check = function
| Ed25519 pkh -> Ed25519.Public_key_hash.to_b58check pkh
| Secp256k1 pkh -> Secp256k1.Public_key_hash.to_b58check pkh
let to_short_b58check = function
| Ed25519 pkh -> Ed25519.Public_key_hash.to_short_b58check pkh
| Secp256k1 pkh -> Secp256k1.Public_key_hash.to_short_b58check pkh
let to_path key l = match key with
| Ed25519 h -> "ed25519" :: Ed25519.Public_key_hash.to_path h l
| Secp256k1 h -> "secp256k1" :: Secp256k1.Public_key_hash.to_path h l
let of_path = function
| "ed25519" :: q -> begin
match Ed25519.Public_key_hash.of_path q with
| Some pkh -> Some (Ed25519 pkh)
| None -> None
end
| "secp256k1" :: q -> begin
match Secp256k1.Public_key_hash.of_path q with
| Some pkh -> Some (Secp256k1 pkh)
| None -> None
end
| _ -> assert false (* FIXME classification des erreurs *)
let of_path_exn = function
| "ed25519" :: q -> Ed25519 (Ed25519.Public_key_hash.of_path_exn q)
| "secp256k1" :: q -> Secp256k1 (Secp256k1.Public_key_hash.of_path_exn q)
| _ -> assert false (* FIXME classification des erreurs *)
let path_length =
let l1 = Ed25519.Public_key_hash.path_length
and l2 = Secp256k1.Public_key_hash.path_length in
assert Compare.Int.(l1 = l2) ;
1 + l1
let prefix_path _ = assert false (* unused *)
let hash = Hashtbl.hash
include Compare.Make(struct
type nonrec t = t
let compare a b =
match (a, b) with
| Ed25519 _ , Secp256k1 _ -> 1
| Secp256k1 _, Ed25519 _ -> -1
| Ed25519 x, Ed25519 y ->
Ed25519.Public_key_hash.compare x y
| Secp256k1 x, Secp256k1 y ->
Secp256k1.Public_key_hash.compare x y
end)
include Helpers.MakeEncoder(struct
type nonrec t = t
let name = name
let title = title
let raw_encoding = raw_encoding
let of_b58check = of_b58check
let of_b58check_opt = of_b58check_opt
let of_b58check_exn = of_b58check_exn
let to_b58check = to_b58check
let to_short_b58check = to_short_b58check
end)
include Helpers.MakeIterator(struct
type nonrec t = t
let hash = hash
let compare = compare
let equal = equal
let encoding = encoding
end)
end
module Public_key = struct
type t = public_key =
| Ed25519 of Ed25519.Public_key.t
| Secp256k1 of Secp256k1.Public_key.t
let name = "Signature.Public_key"
let title = "A Secp256k1 or Ed25519 public key"
let hash pk =
match pk with
| Ed25519 pk -> Public_key_hash.Ed25519 (Ed25519.Public_key.hash pk)
| Secp256k1 pk -> Public_key_hash.Secp256k1 (Secp256k1.Public_key.hash pk)
include Compare.Make(struct
type nonrec t = t
let compare a b = match (a, b) with
| (Ed25519 _ , Secp256k1 _) -> 1
| (Secp256k1 _, Ed25519 _ ) -> -1
| (Ed25519 x, Ed25519 y) -> Ed25519.Public_key.compare x y
| (Secp256k1 x, Secp256k1 y) -> Secp256k1.Public_key.compare x y
end)
type Base58.data += Data of t (* unused *)
let b58check_encoding = (* unused *)
Base58.register_encoding
~prefix: "\255\255"
~length: 2
~to_raw: (fun _ -> assert false)
~of_raw: (fun _ -> assert false)
~wrap: (fun x -> Data x)
let of_b58check_opt s =
match Base58.decode s with
| Some (Ed25519.Public_key.Data public_key) -> Some (Ed25519 public_key)
| Some (Secp256k1.Public_key.Data public_key) -> Some (Secp256k1 public_key)
| _ -> None
let of_b58check_exn s =
match of_b58check_opt s with
| Some x -> x
| None -> Format.kasprintf Pervasives.failwith "Unexpected data (%s)" name
let of_b58check s =
match of_b58check_opt s with
| Some x -> Ok x
| None ->
generic_error
"Failed to read a b58check_encoding data (%s): %S"
name s
let to_b58check = function
| Ed25519 pk -> Ed25519.Public_key.to_b58check pk
| Secp256k1 pk -> Secp256k1.Public_key.to_b58check pk
let to_short_b58check = function
| Ed25519 pk -> Ed25519.Public_key.to_short_b58check pk
| Secp256k1 pk -> Secp256k1.Public_key.to_short_b58check pk
include Helpers.MakeEncoder(struct
type nonrec t = t
let name = name
let title = title
let raw_encoding =
let open Data_encoding in
union [
case (Tag 0) Ed25519.Public_key.encoding
(function Ed25519 x -> Some x | _ -> None)
(function x -> Ed25519 x);
case (Tag 1) Secp256k1.Public_key.encoding
(function Secp256k1 x -> Some x | _ -> None)
(function x -> Secp256k1 x)
]
let of_b58check = of_b58check
let of_b58check_opt = of_b58check_opt
let of_b58check_exn = of_b58check_exn
let to_b58check = to_b58check
let to_short_b58check = to_short_b58check
end)
let pp ppf t = Format.fprintf ppf "%s" (to_b58check t)
end
module Secret_key = struct
type t = secret_key =
| Ed25519 of Ed25519.Secret_key.t
| Secp256k1 of Secp256k1.Secret_key.t
let name = "Signature.Secret_key"
let title = "A Secp256k1 or Ed25519 secret key"
let to_public_key = function
| Ed25519 sk -> Public_key.Ed25519 (Ed25519.Secret_key.to_public_key sk)
| Secp256k1 sk -> Public_key.Secp256k1 (Secp256k1.Secret_key.to_public_key sk)
include Compare.Make(struct
type nonrec t = t
let compare a b = match (a, b) with
| (Ed25519 _ , Secp256k1 _) -> 1
| (Secp256k1 _, Ed25519 _ ) -> -1
| (Ed25519 x, Ed25519 y) -> Ed25519.Secret_key.compare x y
| (Secp256k1 x, Secp256k1 y) -> Secp256k1.Secret_key.compare x y
end)
type Base58.data += Data of t (* unused *)
let b58check_encoding = (* unused *)
Base58.register_encoding
~prefix: "\255\255"
~length: 2
~to_raw: (fun _ -> assert false)
~of_raw: (fun _ -> assert false)
~wrap: (fun x -> Data x)
let of_b58check_opt b =
match Base58.decode b with
| Some (Ed25519.Secret_key.Data sk) -> Some (Ed25519 sk)
| Some (Secp256k1.Secret_key.Data sk) -> Some (Secp256k1 sk)
| _ -> None
let of_b58check_exn s =
match of_b58check_opt s with
| Some x -> x
| None -> Format.kasprintf Pervasives.failwith "Unexpected data (%s)" name
let of_b58check s =
match of_b58check_opt s with
| Some x -> Ok x
| None ->
generic_error
"Failed to read a b58check_encoding data (%s): %S"
name s
let to_b58check = function
| Ed25519 sk -> Ed25519.Secret_key.to_b58check sk
| Secp256k1 sk -> Secp256k1.Secret_key.to_b58check sk
let to_short_b58check = function
| Ed25519 sk -> Ed25519.Secret_key.to_short_b58check sk
| Secp256k1 sk -> Secp256k1.Secret_key.to_short_b58check sk
include Helpers.MakeEncoder(struct
type nonrec t = t
let name = name
let title = title
let raw_encoding =
let open Data_encoding in
union [
case (Tag 0) Ed25519.Secret_key.encoding
(function Ed25519 x -> Some x | _ -> None)
(function x -> Ed25519 x);
case (Tag 1) Secp256k1.Secret_key.encoding
(function Secp256k1 x -> Some x | _ -> None)
(function x -> Secp256k1 x)
]
let of_b58check = of_b58check
let of_b58check_opt = of_b58check_opt
let of_b58check_exn = of_b58check_exn
let to_b58check = to_b58check
let to_short_b58check = to_short_b58check
end)
let pp ppf t = Format.fprintf ppf "%s" (to_b58check t)
end
type t =
| Ed25519 of Ed25519.t
| Secp256k1 of Secp256k1.t
| Unknown of MBytes.t
let name = "Signature"
let title = "A Secp256k1 or Ed25519 signature"
let () = assert (Ed25519.size = Secp256k1.size)
let size = Ed25519.size
let to_bytes = function
| Unknown b -> b
| Ed25519 b -> Ed25519.to_bytes b
| Secp256k1 b -> Secp256k1.to_bytes b
let of_bytes_opt s =
if MBytes.length s = size then Some (Unknown s) else None
let to_string s = MBytes.to_string (to_bytes s)
let of_string_opt s = of_bytes_opt (MBytes.of_string s)
type Base58.data += Data of t
let b58check_encoding =
Base58.register_encoding
~prefix: "\004\130\043"
~length: 96
~to_raw: to_string
~of_raw: of_string_opt
~wrap: (fun x -> Data x)
include Helpers.MakeRaw(struct
type nonrec t = t
let name = name
let of_bytes_opt = of_bytes_opt
let of_string_opt = of_string_opt
let to_string = to_string
end)
include Compare.Make(struct
type nonrec t = t
let compare a b =
let a = to_bytes a
and b = to_bytes b in
MBytes.compare a b
end)
let of_b58check_opt s =
if TzString.has_prefix ~prefix:Ed25519.b58check_encoding.encoded_prefix s then
Option.map
(Ed25519.of_b58check_opt s)
~f: (fun x -> Ed25519 x)
else if TzString.has_prefix ~prefix:Secp256k1.b58check_encoding.encoded_prefix s then
Option.map
(Secp256k1.of_b58check_opt s)
~f: (fun x -> Secp256k1 x)
else
Base58.simple_decode b58check_encoding s
let of_b58check_exn s =
match of_b58check_opt s with
| Some x -> x
| None -> Format.kasprintf Pervasives.failwith "Unexpected data (%s)" name
let of_b58check s =
match of_b58check_opt s with
| Some x -> Ok x
| None ->
generic_error
"Failed to read a b58check_encoding data (%s): %S"
name s
let to_b58check = function
| Ed25519 b -> Ed25519.to_b58check b
| Secp256k1 b -> Secp256k1.to_b58check b
| Unknown b -> Base58.simple_encode b58check_encoding (Unknown b)
let to_short_b58check = function
| Ed25519 b -> Ed25519.to_short_b58check b
| Secp256k1 b -> Secp256k1.to_short_b58check b
| Unknown b -> Base58.simple_encode b58check_encoding (Unknown b)
include Helpers.MakeEncoder(struct
type nonrec t = t
let name = name
let title = title
let raw_encoding =
Data_encoding.conv
to_bytes
of_bytes_exn
(Data_encoding.Fixed.bytes size)
let of_b58check = of_b58check
let of_b58check_opt = of_b58check_opt
let of_b58check_exn = of_b58check_exn
let to_b58check = to_b58check
let to_short_b58check = to_short_b58check
end)
let pp ppf t = Format.fprintf ppf "%s" (to_b58check t)
let of_secp256k1 s = Secp256k1 s
let of_ed25519 s = Ed25519 s
let zero = of_ed25519 Ed25519.zero
let sign secret_key message =
match secret_key with
| Secret_key.Ed25519 sk -> of_ed25519 (Ed25519.sign sk message)
| Secret_key.Secp256k1 sk -> of_secp256k1 (Secp256k1.sign sk message)
let check public_key signature message =
match public_key, signature with
| Public_key.Ed25519 pk, Unknown signature -> begin
match Ed25519.of_bytes_opt signature with
| Some s -> Ed25519.check pk s message
| None -> false
end
| Public_key.Secp256k1 pk, Unknown signature -> begin
match Secp256k1.of_bytes_opt signature with
| Some s -> Secp256k1.check pk s message
| None -> false
end
| Public_key.Ed25519 pk, Ed25519 signature ->
Ed25519.check pk signature message
| Public_key.Secp256k1 pk, Secp256k1 signature ->
Secp256k1.check pk signature message
| Public_key.Ed25519 _, Secp256k1 _ -> false
| Public_key.Secp256k1 _, Ed25519 _ -> false
let append sk bytes =
match sk with
| Secret_key.Ed25519 s -> Ed25519.append s bytes
| Secret_key.Secp256k1 s -> Secp256k1.append s bytes
let concat msg signature =
MBytes.concat msg (to_bytes signature)
type algo =
| Ed25519
| Secp256k1
let algo_param () =
Clic.parameter
~autocomplete:(fun _ -> return [ "ed25519" ; "secp256k1" ])
begin fun _ name ->
match name with
| "ed25519" -> return Ed25519
| "secp256k1" -> return Secp256k1
| name ->
failwith
"Unknown signature algorithm (%s). \
Available: 'ed25519' or 'secp256k1'"
name
end
let generate_key ?(algo = Ed25519) ?seed () =
match algo, seed with
| Secp256k1, Some _ ->
invalid_arg "Signature.generate_key"
| Secp256k1, None ->
let (pkh, pk, sk) = Secp256k1.generate_key () in
(Public_key_hash.Secp256k1 pkh,
Public_key.Secp256k1 pk, Secret_key.Secp256k1 sk)
| Ed25519, seed ->
let seed =
match seed with
| None -> Ed25519.Seed.generate ()
| Some seed -> seed in
let (pkh, pk, sk) = Ed25519.generate_seeded_key seed in
(Public_key_hash.Ed25519 pkh,
Public_key.Ed25519 pk, Secret_key.Ed25519 sk)

37
src/lib_crypto/signature.mli Normal file
View File

@ -0,0 +1,37 @@
(**************************************************************************)
(* *)
(* Copyright (c) 2014 - 2018. *)
(* Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* All rights reserved. No warranty, explicit or implicit, provided. *)
(* *)
(**************************************************************************)
type public_key_hash =
| Ed25519 of Ed25519.Public_key_hash.t
| Secp256k1 of Secp256k1.Public_key_hash.t
type public_key =
| Ed25519 of Ed25519.Public_key.t
| Secp256k1 of Secp256k1.Public_key.t
type secret_key =
| Ed25519 of Ed25519.Secret_key.t
| Secp256k1 of Secp256k1.Secret_key.t
include S.SIGNATURE with type Public_key_hash.t = public_key_hash
and type Public_key.t = public_key
and type Secret_key.t = secret_key
include S.RAW_DATA with type t := t
type algo =
| Ed25519
| Secp256k1
val algo_param: unit -> (algo, 'a) Clic.parameter
val generate_key:
?algo:algo ->
?seed:Ed25519.Seed.t ->
unit -> public_key_hash * public_key * secret_key

1
src/lib_crypto/tezos-crypto.opam
View File

@ -19,6 +19,7 @@ depends: [
"blake2"
"tweetnacl"
"zarith"
"secp256k1-internal"
"alcotest" { test }
]
build: [

2
src/lib_protocol_environment/sigs/jbuild
View File

@ -40,6 +40,8 @@
v1/map.mli
v1/blake2B.mli
v1/ed25519.mli
v1/secp256k1.mli
v1/signature.mli
v1/block_hash.mli
v1/operation_hash.mli
v1/operation_list_hash.mli

1
src/lib_protocol_environment/sigs/v1/blake2B.mli
View File

@ -36,4 +36,3 @@ module Make
'a Base58.encoding
end)
(Name : PrefixedName) : S.HASH

12
src/lib_protocol_environment/sigs/v1/secp256k1.mli Normal file
View File

@ -0,0 +1,12 @@
(**************************************************************************)
(* *)
(* Copyright (c) 2014 - 2018. *)
(* Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* All rights reserved. No warranty, explicit or implicit, provided. *)
(* *)
(**************************************************************************)
(** Tezos - Secp256k1 cryptography *)
include S.SIGNATURE

19
src/lib_protocol_environment/sigs/v1/signature.mli Normal file
View File

@ -0,0 +1,19 @@
(**************************************************************************)
(* *)
(* Copyright (c) 2014 - 2018. *)
(* Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* *)
(* All rights reserved. No warranty, explicit or implicit, provided. *)
(* *)
(**************************************************************************)
type public_key_hash =
| Ed25519 of Ed25519.Public_key_hash.t
| Secp256k1 of Secp256k1.Public_key_hash.t
type public_key =
| Ed25519 of Ed25519.Public_key.t
| Secp256k1 of Secp256k1.Public_key.t
include S.SIGNATURE with type Public_key_hash.t = public_key_hash
and type Public_key.t = public_key

8
src/lib_protocol_environment/tezos_protocol_environment.ml
View File

@ -128,6 +128,12 @@ module Make (Context : CONTEXT) = struct
and type Ed25519.Public_key_hash.t = Ed25519.Public_key_hash.t
and type Ed25519.Public_key.t = Ed25519.Public_key.t
and type Ed25519.t = Ed25519.t
and type Secp256k1.Public_key_hash.t = Secp256k1.Public_key_hash.t
and type Secp256k1.Public_key.t = Secp256k1.Public_key.t
and type Secp256k1.t = Secp256k1.t
and type Signature.public_key_hash = Signature.public_key_hash
and type Signature.public_key = Signature.public_key
and type Signature.t = Signature.t
and type 'a Micheline.canonical = 'a Micheline.canonical
and type ('a, 'b) RPC_path.t = ('a, 'b) RPC_path.t
and type ('a, 'b) Micheline.node = ('a, 'b) Micheline.node
@ -187,6 +193,8 @@ module Make (Context : CONTEXT) = struct
module Data_encoding = Data_encoding
module Time = Time
module Ed25519 = Ed25519
module Secp256k1 = Secp256k1
module Signature = Signature
module S = struct
module type T = Tezos_base.S.T
module type HASHABLE = Tezos_base.S.HASHABLE

6
src/lib_protocol_environment/tezos_protocol_environment.mli
View File

@ -121,6 +121,12 @@ module Make (Context : CONTEXT) : sig
and type Ed25519.Public_key_hash.t = Ed25519.Public_key_hash.t
and type Ed25519.Public_key.t = Ed25519.Public_key.t
and type Ed25519.t = Ed25519.t
and type Secp256k1.Public_key_hash.t = Secp256k1.Public_key_hash.t
and type Secp256k1.Public_key.t = Secp256k1.Public_key.t
and type Secp256k1.t = Secp256k1.t
and type Signature.public_key_hash = Signature.public_key_hash
and type Signature.public_key = Signature.public_key
and type Signature.t = Signature.t
and type 'a Micheline.canonical = 'a Micheline.canonical
and type ('a, 'b) Micheline.node = ('a, 'b) Micheline.node
and type Data_encoding.json_schema = Data_encoding.json_schema

2
src/proto_alpha/lib_baking/client_baking_endorsement.ml
View File

@ -128,7 +128,7 @@ let check_endorsement cctxt level slot =
let forge_endorsement (cctxt : #Proto_alpha.full)
block
~src_sk ?slots ?max_priority src_pk =
let src_pkh = Ed25519.Public_key.hash src_pk in
let src_pkh = Signature.Public_key.hash src_pk in
Alpha_services.Context.level cctxt block >>=? fun { level } ->
begin
match slots with

3
src/proto_alpha/lib_baking/client_baking_operations.ml
View File

@ -35,7 +35,7 @@ let filter_valid_endorsement cctxt ({ hash ; content } : operation) =
| Some { shell = {chain_id} ;
contents =
Sourced_operations (Delegate_operations { source ; operations }) } ->
let source = Ed25519.Public_key.hash source in
let source = Signature.Public_key.hash source in
let endorsements =
Utils.unopt_list @@ List.map
(function
@ -102,4 +102,3 @@ let monitor_endorsement cctxt =
let monitor_endorsement _ =
let stream, _push = Lwt_stream.create () in
return stream

44
src/proto_alpha/lib_baking/test/proto_alpha_helpers.ml
View File

@ -154,9 +154,9 @@ module Account = struct
type t = {
alias : string ;
sk : Ed25519.Secret_key.t ;
pk : public_key ;
pkh : public_key_hash ;
sk : Signature.secret_key ;
pk : Signature.public_key ;
pkh : Signature.public_key_hash ;
contract : Contract.t ;
}
@ -170,9 +170,9 @@ module Account = struct
{ alias ; sk ; pk ; pkh ; contract })
(obj5
(req "alias" string)
(req "sk" Ed25519.Secret_key.encoding)
(req "pk" Ed25519.Public_key.encoding)
(req "pkh" Ed25519.Public_key_hash.encoding)
(req "sk" Signature.Secret_key.encoding)
(req "pk" Signature.Public_key.encoding)
(req "pkh" Signature.Public_key_hash.encoding)
(req "contract" Contract.encoding))
let pp_account ppf account =
@ -182,8 +182,8 @@ module Account = struct
let create ?keys alias =
let sk, pk = match keys with
| Some keys -> keys
| None -> let _, pk, sk = Ed25519.generate_key () in sk, pk in
let pkh = Ed25519.Public_key.hash pk in
| None -> let _, pk, sk = Signature.generate_key () in sk, pk in
let pkh = Signature.Public_key.hash pk in
let contract = Contract.implicit_contract pkh in
{ alias ; contract ; pkh ; pk ; sk }
@ -203,8 +203,8 @@ module Account = struct
{ alias ; pk ; pkh ; contract })
(obj4
(req "alias" string)
(req "pk" Ed25519.Public_key.encoding)
(req "pkh" Ed25519.Public_key_hash.encoding)
(req "pk" Signature.Public_key.encoding)
(req "pkh" Signature.Public_key_hash.encoding)
(req "contract" Contract.encoding))
let pp_destination ppf destination =
@ -212,7 +212,7 @@ module Account = struct
Format.fprintf ppf "%s" (Data_encoding.Json.to_string json)
let create_destination ~alias ~contract ~pk =
let pkh = Ed25519.Public_key.hash pk in
let pkh = Signature.Public_key.hash pk in
{ alias ; contract ; pk ; pkh }
type bootstrap_accounts = { b1 : t ; b2 : t ; b3 : t ; b4 : t ; b5 : t ; }
@ -231,10 +231,10 @@ module Account = struct
let cpt = ref 0 in
match List.map begin fun sk ->
incr cpt ;
let sk = Ed25519.Secret_key.of_b58check_exn sk in
let sk = Signature.Secret_key.of_b58check_exn sk in
let alias = Printf.sprintf "bootstrap%d" !cpt in
let pk = Ed25519.Secret_key.to_public_key sk in
let pkh = Ed25519.Public_key.hash pk in
let pk = Signature.Secret_key.to_public_key sk in
let pkh = Signature.Public_key.hash pk in
{ alias ; contract = Contract.implicit_contract pkh; pkh ; pk ; sk }
end [ bootstrap1_sk; bootstrap2_sk; bootstrap3_sk;
bootstrap4_sk; bootstrap5_sk; ]
@ -250,7 +250,7 @@ module Account = struct
~amount () =
let src_sk = Client_keys.Secret_key_locator.create
~scheme:"unencrypted"
~location:(Ed25519.Secret_key.to_b58check account.sk) in
~location:(Signature.Secret_key.to_b58check account.sk) in
Client_proto_context.transfer
(new wrap_full (no_write_context !rpc_config ~block))
block
@ -274,7 +274,7 @@ module Account = struct
| Some delegate -> true, Some delegate in
let src_sk = Client_keys.Secret_key_locator.create
~scheme:"unencrypted"
~location:(Ed25519.Secret_key.to_b58check src.sk) in
~location:(Signature.Secret_key.to_b58check src.sk) in
Client_proto_context.originate_account
~source:src.contract
~src_pk:src.pk
@ -330,7 +330,7 @@ module Protocol = struct
~period:next_level.voting_period
~proposals
() >>=? fun bytes ->
let signed_bytes = Ed25519.append sk bytes in
let signed_bytes = Signature.append sk bytes in
return (Tezos_base.Operation.of_bytes_exn signed_bytes)
let ballot ?(block = `Head 0) ~src:({ pkh; sk } : Account.t) ~proposal ballot =
@ -343,7 +343,7 @@ module Protocol = struct
~proposal
~ballot
() >>=? fun bytes ->
let signed_bytes = Ed25519.append sk bytes in
let signed_bytes = Signature.append sk bytes in
return (Tezos_base.Operation.of_bytes_exn signed_bytes)
end
@ -368,11 +368,11 @@ module Assert = struct
match pkh1, pkh2 with
| None, None -> true
| Some pkh1, Some pkh2 ->
Ed25519.Public_key_hash.equal pkh1 pkh2
Signature.Public_key_hash.equal pkh1 pkh2
| _ -> false in
let prn = function
| None -> "none"
| Some pkh -> Ed25519.Public_key_hash.to_b58check pkh in
| Some pkh -> Signature.Public_key_hash.to_b58check pkh in
equal ?msg ~prn ~eq pkh1 pkh2
let equal_tez ?msg tz1 tz2 =
@ -508,7 +508,7 @@ module Baking = struct
None in
let src_sk = Client_keys.Secret_key_locator.create
~scheme:"unencrypted"
~location:(Ed25519.Secret_key.to_b58check contract.sk) in
~location:(Signature.Secret_key.to_b58check contract.sk) in
Client_baking_forge.forge_block
ctxt
block
@ -538,7 +538,7 @@ module Endorse = struct
~level:level.level
~slots:[slot]
() >>=? fun bytes ->
let signed_bytes = Ed25519.append src_sk bytes in
let signed_bytes = Signature.append src_sk bytes in
return (Tezos_base.Operation.of_bytes_exn signed_bytes)
let signing_slots

8
src/proto_alpha/lib_baking/test/proto_alpha_helpers.mli
View File

@ -29,15 +29,15 @@ module Account : sig
type t = {
alias : string ;
sk : Ed25519.Secret_key.t ;
pk : Ed25519.Public_key.t ;
pkh : Ed25519.Public_key_hash.t ;
sk : Signature.Secret_key.t ;
pk : Signature.Public_key.t ;
pkh : Signature.Public_key_hash.t ;
contract : Contract.t ;
}
val encoding : t Data_encoding.t
val pp_account : Format.formatter -> t -> unit
val create : ?keys:(Ed25519.Secret_key.t * public_key) -> string -> t
val create : ?keys:(Signature.secret_key * public_key) -> string -> t
(** [create ?keys alias] is an account with alias [alias]. If
[?keys] is [None], a pair of keys will be minted. *)

4
src/proto_alpha/lib_baking/test/test_endorsement.ml
View File

@ -44,10 +44,10 @@ let test_double_endorsement_evidence contract block =
(* FIXME: Baking.Invalid_signature is unclassified *)
let test_invalid_signature block =
let public_key =
Ed25519.Public_key.of_b58check_exn
Signature.Public_key.of_b58check_exn
"edpkv8EUUH68jmo3f7Um5PezmfGrRF24gnfLpH3sVNwJnV5bVCxL2n" in
let secret_key =
Ed25519.Secret_key.of_b58check_exn
Signature.Secret_key.of_b58check_exn
"edsk3gUfUPyBSfrS9CCgmCiQsTCHGkviBDusMxDJstFtojtc1zcpsh" in
let account =
Helpers.Account.create ~keys:(secret_key, public_key) "WRONG SIGNATURE" in

2
src/proto_alpha/lib_baking/test/test_origination.ml
View File

@ -52,7 +52,7 @@ let run blkid ({ b1 ; b2 ; _ } : Helpers.Account.bootstrap_accounts) =
(* Change delegate of a non-delegatable contract *)
let manager_sk = Client_keys.Secret_key_locator.create
~scheme:"unencrypted"
~location:(Ed25519.Secret_key.to_b58check b1.sk) in
~location:(Signature.Secret_key.to_b58check b1.sk) in
Helpers.Account.set_delegate
~fee:(cents 5L)

16
src/proto_alpha/lib_baking/test/test_rpc.ml
View File

@ -35,16 +35,16 @@ let run blkid =
("e7", Dir [("67", Cut)]);
] in
let tests = [(("version",1), is_equal version);
(("",0), is_equal dir_depth0);
(("delegates",2), is_equal dir_depth2);
(("",-1), is_not_found);
(("not-existent",1), is_not_found);
(("not-existent",0), is_not_found);
(("not-existent",-1), is_not_found);
let tests = [((["version"],1), is_equal version);
(([""],0), is_equal dir_depth0);
((["delegates";"ed25519"],2), is_equal dir_depth2);
(([""],-1), is_not_found);
((["not-existent"],1), is_not_found);
((["not-existent"],0), is_not_found);
((["not-existent"],-1), is_not_found);
] in
iter_s (fun ((path,depth),predicate) ->
Helpers.rpc_raw_context blkid [path] depth >>= fun result ->
Helpers.rpc_raw_context blkid path depth >>= fun result ->
return (assert (predicate result))
) tests

2
src/proto_alpha/lib_client/client_proto_args.mli
View File

@ -17,7 +17,7 @@ val fee_arg: (Tez.t, Proto_alpha.full) Clic.arg
val arg_arg: (string, Proto_alpha.full) Clic.arg
val source_arg: (string option, Proto_alpha.full) Clic.arg
val delegate_arg: (Ed25519.Public_key_hash.t option, Proto_alpha.full) Clic.arg
val delegate_arg: (Signature.Public_key_hash.t option, Proto_alpha.full) Clic.arg
val delegatable_switch: (bool, Proto_alpha.full) Clic.arg
val spendable_switch: (bool, Proto_alpha.full) Clic.arg
val max_priority_arg: (int option, Proto_alpha.full) Clic.arg

14
src/proto_alpha/lib_client/client_proto_context.ml
View File

@ -55,7 +55,7 @@ let transfer cctxt
~destination ?parameters ~fee () >>=? fun bytes ->
Block_services.predecessor cctxt block >>=? fun predecessor ->
Client_keys.sign cctxt src_sk bytes >>=? fun signature ->
let signed_bytes = Ed25519.concat bytes signature in
let signed_bytes = Signature.concat bytes signature in
let oph = Operation_hash.hash_bytes [ signed_bytes ] in
Alpha_services.Helpers.apply_operation cctxt block
predecessor oph bytes (Some signature) >>=? fun contracts ->
@ -73,7 +73,7 @@ let reveal cctxt
cctxt block
~branch ~source ~sourcePubKey:src_pk ~counter ~fee () >>=? fun bytes ->
Client_keys.sign cctxt src_sk bytes >>=? fun signature ->
let signed_bytes = Ed25519.concat bytes signature in
let signed_bytes = Signature.concat bytes signature in
let oph = Operation_hash.hash_bytes [ signed_bytes ] in
Shell_services.inject_operation
cctxt ~chain_id signed_bytes >>=? fun injected_oph ->
@ -84,7 +84,7 @@ let originate rpc_config ?chain_id ~block ?signature bytes =
let signed_bytes =
match signature with
| None -> bytes
| Some signature -> Ed25519.concat bytes signature in
| Some signature -> Signature.concat bytes signature in
Block_services.predecessor rpc_config block >>=? fun predecessor ->
let oph = Operation_hash.hash_bytes [ signed_bytes ] in
Alpha_services.Helpers.apply_operation rpc_config block
@ -135,7 +135,7 @@ let delegate_contract cctxt
~branch ~source ?sourcePubKey:src_pk ~counter ~fee delegate_opt
>>=? fun bytes ->
Client_keys.sign cctxt manager_sk bytes >>=? fun signature ->
let signed_bytes = Ed25519.concat bytes signature in
let signed_bytes = Signature.concat bytes signature in
let oph = Operation_hash.hash_bytes [ signed_bytes ] in
Shell_services.inject_operation
cctxt ~chain_id signed_bytes >>=? fun injected_oph ->
@ -182,8 +182,8 @@ let dictate rpc_config block command seckey =
rpc_config block >>=? fun { chain_id ; hash = branch } ->
Alpha_services.Forge.Dictator.operation
rpc_config block ~branch command >>=? fun bytes ->
let signature = Ed25519.sign seckey bytes in
let signed_bytes = Ed25519.concat bytes signature in
let signature = Signature.sign seckey bytes in
let signed_bytes = Signature.concat bytes signature in
let oph = Operation_hash.hash_bytes [ signed_bytes ] in
Shell_services.inject_operation
rpc_config ~chain_id signed_bytes >>=? fun injected_oph ->
@ -195,7 +195,7 @@ let set_delegate cctxt block ~fee contract ~src_pk ~manager_sk opt_delegate =
cctxt block ~source:contract ~src_pk ~manager_sk ~fee opt_delegate
let register_as_delegate cctxt block ~fee ~manager_sk src_pk =
let source = Ed25519.Public_key.hash src_pk in
let source = Signature.Public_key.hash src_pk in
delegate_contract
cctxt block
~source:(Contract.implicit_contract source) ~src_pk ~manager_sk ~fee

2
src/proto_alpha/lib_client/client_proto_context.mli
View File

@ -132,5 +132,5 @@ val dictate :
#Proto_alpha.rpc_context ->
Block_services.block ->
dictator_operation ->
Ed25519.Secret_key.t ->
Signature.secret_key ->
Operation_hash.t tzresult Lwt.t

2
src/proto_alpha/lib_client/client_proto_programs.ml
View File

@ -120,7 +120,7 @@ let trace
let hash_and_sign (data : Michelson_v1_parser.parsed) (typ : Michelson_v1_parser.parsed) sk block cctxt =
Alpha_services.Helpers.hash_data cctxt block (data.expanded, typ.expanded) >>=? fun hash ->
Client_keys.sign cctxt sk (MBytes.of_string hash) >>=? fun signature ->
let `Hex signature = Ed25519.to_hex signature in
let `Hex signature = Signature.to_hex signature in
return (hash, signature)
let typecheck_data

4
src/proto_alpha/lib_client_commands/client_proto_context_commands.ml
View File

@ -307,7 +307,7 @@ let commands () =
@@ Protocol_hash.param ~name:"version"
~desc:"protocol version (b58check)"
@@ prefixes [ "with" ; "key" ]
@@ Ed25519.Secret_key.param
@@ Signature.Secret_key.param
~name:"password" ~desc:"dictator's key"
@@ stop)
begin fun () hash seckey cctxt ->
@ -360,7 +360,7 @@ let commands () =
@@ Protocol_hash.param ~name:"version"
~desc:"protocol version (b58check)"
@@ prefixes [ "with" ; "key" ]
@@ Ed25519.Secret_key.param
@@ Signature.Secret_key.param
~name:"password" ~desc:"dictator's key"
@@ stop)
begin fun () hash seckey cctxt ->

7
src/proto_alpha/lib_protocol/src/alpha_context.ml
View File

@ -49,9 +49,10 @@ module Script = struct
include Michelson_v1_primitives
include Script_repr
end
type public_key = Ed25519.Public_key.t
type public_key_hash = Ed25519.Public_key_hash.t
type signature = Ed25519.t
type public_key = Signature.Public_key.t
type public_key_hash = Signature.Public_key_hash.t
type signature = Signature.t
module Constants = struct
include Constants_repr

16
src/proto_alpha/lib_protocol/src/alpha_context.mli
View File

@ -17,9 +17,9 @@ end
type t
type context = t
type public_key = Ed25519.Public_key.t
type public_key_hash = Ed25519.Public_key_hash.t
type signature = Ed25519.t
type public_key = Signature.Public_key.t
type public_key_hash = Signature.Public_key_hash.t
type signature = Signature.t
module Tez : sig
@ -271,7 +271,7 @@ module Constants : sig
endorsers_per_block: int ;
max_gas: int ;
proof_of_work_threshold: int64 ;
dictator_pubkey: Ed25519.Public_key.t ;
dictator_pubkey: Signature.Public_key.t ;
max_operation_data_length: int ;
tokens_per_roll: Tez.t ;
michelson_maximum_type_size: int;
@ -295,7 +295,7 @@ module Constants : sig
val endorsers_per_block: context -> int
val max_gas: context -> int
val proof_of_work_threshold: context -> int64
val dictator_pubkey: context -> Ed25519.Public_key.t
val dictator_pubkey: context -> Signature.Public_key.t
val max_operation_data_length: context -> int
val tokens_per_roll: context -> Tez.t
val michelson_maximum_type_size: context -> int
@ -606,7 +606,7 @@ module Block_header : sig
type t = {
shell: Block_header.shell_header ;
protocol_data: protocol_data ;
signature: Ed25519.t ;
signature: Signature.t ;
}
and protocol_data = {
@ -682,7 +682,7 @@ and anonymous_operation =
and sourced_operations =
| Consensus_operation of consensus_operation
| Amendment_operation of {
source: Ed25519.Public_key_hash.t ;
source: Signature.Public_key_hash.t ;
operation: amendment_operation ;
}
| Manager_operations of {
@ -712,7 +712,7 @@ and amendment_operation =
}
and manager_operation =
| Reveal of Ed25519.Public_key.t
| Reveal of Signature.Public_key.t
| Transaction of {
amount: Tez.t ;
parameters: Script.expr option ;

44
src/proto_alpha/lib_protocol/src/apply.ml
View File

@ -20,7 +20,7 @@ type error += Invalid_commitment of { expected: bool }
type error += Invalid_double_endorsement_evidence (* `Permanent *)
type error += Inconsistent_double_endorsement_evidence
of { delegate1: Ed25519.Public_key_hash.t ; delegate2: Ed25519.Public_key_hash.t } (* `Permanent *)
of { delegate1: Signature.Public_key_hash.t ; delegate2: Signature.Public_key_hash.t } (* `Permanent *)
type error += Unrequired_double_endorsement_evidence (* `Branch*)
type error += Too_early_double_endorsement_evidence
of { level: Raw_level.t ; current: Raw_level.t } (* `Temporary *)
@ -30,7 +30,7 @@ type error += Outdated_double_endorsement_evidence
type error += Invalid_double_baking_evidence
of { level1: Int32.t ; level2: Int32.t } (* `Permanent *)
type error += Inconsistent_double_baking_evidence
of { delegate1: Ed25519.Public_key_hash.t ; delegate2: Ed25519.Public_key_hash.t } (* `Permanent *)
of { delegate1: Signature.Public_key_hash.t ; delegate2: Signature.Public_key_hash.t } (* `Permanent *)
type error += Unrequired_double_baking_evidence (* `Branch*)
type error += Too_early_double_baking_evidence
of { level: Raw_level.t ; current: Raw_level.t } (* `Temporary *)
@ -136,11 +136,11 @@ let () =
Format.fprintf ppf
"Inconsistent double-endorsement evidence \
\ (distinct delegate: %a and %a)"
Ed25519.Public_key_hash.pp_short delegate1
Ed25519.Public_key_hash.pp_short delegate2)
Signature.Public_key_hash.pp_short delegate1
Signature.Public_key_hash.pp_short delegate2)
Data_encoding.(obj2
(req "delegate1" Ed25519.Public_key_hash.encoding)
(req "delegate2" Ed25519.Public_key_hash.encoding))
(req "delegate1" Signature.Public_key_hash.encoding)
(req "delegate2" Signature.Public_key_hash.encoding))
(function
| Inconsistent_double_endorsement_evidence { delegate1 ; delegate2 } ->
Some (delegate1, delegate2)
@ -226,11 +226,11 @@ let () =
Format.fprintf ppf
"Inconsistent double-baking evidence \
\ (distinct delegate: %a and %a)"
Ed25519.Public_key_hash.pp_short delegate1
Ed25519.Public_key_hash.pp_short delegate2)
Signature.Public_key_hash.pp_short delegate1
Signature.Public_key_hash.pp_short delegate2)
Data_encoding.(obj2
(req "delegate1" Ed25519.Public_key_hash.encoding)
(req "delegate2" Ed25519.Public_key_hash.encoding))
(req "delegate1" Signature.Public_key_hash.encoding)
(req "delegate2" Signature.Public_key_hash.encoding))
(function
| Inconsistent_double_baking_evidence { delegate1 ; delegate2 } ->
Some (delegate1, delegate2)
@ -334,7 +334,7 @@ let apply_consensus_operation_content ctxt
ctxt slots >>=? fun ctxt ->
Baking.check_endorsements_rights ctxt lvl slots >>=? fun delegate ->
Operation.check_signature delegate operation >>=? fun () ->
let delegate = Ed25519.Public_key.hash delegate in
let delegate = Signature.Public_key.hash delegate in
let ctxt = Fitness.increase ~gap:(List.length slots) ctxt in
Baking.freeze_endorsement_deposit ctxt delegate >>=? fun ctxt ->
Baking.endorsement_reward ctxt ~block_priority >>=? fun reward ->
@ -523,11 +523,11 @@ let apply_anonymous_operation ctxt _delegate origination_nonce kind =
Baking.check_endorsements_rights ctxt level e2.slots >>=? fun delegate2 ->
Operation.check_signature delegate2 op2 >>=? fun () ->
fail_unless
(Ed25519.Public_key.equal delegate1 delegate2)
(Signature.Public_key.equal delegate1 delegate2)
(Inconsistent_double_endorsement_evidence
{ delegate1 = Ed25519.Public_key.hash delegate1 ;
delegate2 = Ed25519.Public_key.hash delegate2 }) >>=? fun () ->
let delegate = Ed25519.Public_key.hash delegate1 in
{ delegate1 = Signature.Public_key.hash delegate1 ;
delegate2 = Signature.Public_key.hash delegate2 }) >>=? fun () ->
let delegate = Signature.Public_key.hash delegate1 in
Delegate.has_frozen_balance ctxt delegate level.cycle >>=? fun valid ->
fail_unless valid Unrequired_double_endorsement_evidence >>=? fun () ->
Delegate.punish ctxt delegate level.cycle >>=? fun (ctxt, burned) ->
@ -562,11 +562,11 @@ let apply_anonymous_operation ctxt _delegate origination_nonce kind =
ctxt level ~priority:bh2.protocol_data.priority >>=? fun delegate2 ->
Baking.check_signature bh2 delegate2 >>=? fun () ->
fail_unless
(Ed25519.Public_key.equal delegate1 delegate2)
(Signature.Public_key.equal delegate1 delegate2)
(Inconsistent_double_baking_evidence
{ delegate1 = Ed25519.Public_key.hash delegate1 ;
delegate2 = Ed25519.Public_key.hash delegate2 }) >>=? fun () ->
let delegate = Ed25519.Public_key.hash delegate1 in
{ delegate1 = Signature.Public_key.hash delegate1 ;
delegate2 = Signature.Public_key.hash delegate2 }) >>=? fun () ->
let delegate = Signature.Public_key.hash delegate1 in
Delegate.has_frozen_balance ctxt delegate level.cycle >>=? fun valid ->
fail_unless valid Unrequired_double_baking_evidence >>=? fun () ->
Delegate.punish ctxt delegate level.cycle >>=? fun (ctxt, burned) ->
@ -586,7 +586,7 @@ let apply_anonymous_operation ctxt _delegate origination_nonce kind =
Blinded_public_key_hash.(blinded_pkh = submitted_bpkh)
Wrong_activation_secret >>=? fun () ->
Commitment.delete ctxt h_pkh >>=? fun ctxt ->
Contract.(credit ctxt (implicit_contract pkh) amount) >>=? fun ctxt ->
Contract.(credit ctxt (implicit_contract (Signature.Ed25519 pkh)) amount) >>=? fun ctxt ->
return (ctxt, origination_nonce)
let apply_operation
@ -634,7 +634,7 @@ let begin_full_construction ctxt pred_timestamp protocol_data =
protocol_data) >>=? fun protocol_data ->
Baking.check_baking_rights
ctxt protocol_data pred_timestamp >>=? fun delegate_pk ->
let delegate_pkh = Ed25519.Public_key.hash delegate_pk in
let delegate_pkh = Signature.Public_key.hash delegate_pk in
Baking.freeze_baking_deposit ctxt protocol_data delegate_pkh >>=? fun (ctxt, deposit) ->
let ctxt = Fitness.increase ctxt in
return (ctxt, protocol_data, delegate_pk, deposit)
@ -658,7 +658,7 @@ let begin_application ctxt block_header pred_timestamp =
Compare.Bool.(has_commitment = current_level.expected_commitment)
(Invalid_commitment
{ expected = current_level.expected_commitment }) >>=? fun () ->
let delegate_pkh = Ed25519.Public_key.hash delegate_pk in
let delegate_pkh = Signature.Public_key.hash delegate_pk in
Baking.freeze_baking_deposit ctxt
block_header.protocol_data delegate_pkh >>=? fun (ctxt, deposit) ->
let ctxt = Fitness.increase ctxt in

20
src/proto_alpha/lib_protocol/src/baking.ml
View File

@ -18,7 +18,7 @@ type error += Cannot_freeze_baking_deposit (* `Permanent *)
type error += Cannot_freeze_endorsement_deposit (* `Permanent *)
type error += Inconsistent_endorsement of public_key_hash list (* `Permanent *)
type error += Empty_endorsement
type error += Invalid_block_signature of Block_hash.t * Ed25519.Public_key_hash.t (* `Permanent *)
type error += Invalid_block_signature of Block_hash.t * Signature.Public_key_hash.t (* `Permanent *)
type error += Invalid_signature (* `Permanent *)
type error += Invalid_stamp (* `Permanent *)
@ -91,9 +91,9 @@ let () =
~pp:(fun ppf l ->
Format.fprintf ppf
"@[<v 2>The endorsement is inconsistent. Delegates:@ %a@]"
(Format.pp_print_list Ed25519.Public_key_hash.pp) l)
(Format.pp_print_list Signature.Public_key_hash.pp) l)
Data_encoding.(obj1
(req "delegates" (list Ed25519.Public_key_hash.encoding)))
(req "delegates" (list Signature.Public_key_hash.encoding)))
(function Inconsistent_endorsement l -> Some l | _ -> None)
(fun l -> Inconsistent_endorsement l) ;
register_error_kind
@ -105,10 +105,10 @@ let () =
~pp:(fun ppf (block, pkh) ->
Format.fprintf ppf "Invalid signature for block %a. Expected: %a."
Block_hash.pp_short block
Ed25519.Public_key_hash.pp_short pkh)
Signature.Public_key_hash.pp_short pkh)
Data_encoding.(obj2
(req "block" Block_hash.encoding)
(req "expected" Ed25519.Public_key_hash.encoding))
(req "expected" Signature.Public_key_hash.encoding))
(function Invalid_block_signature (block, pkh) -> Some (block, pkh) | _ -> None)
(fun (block, pkh) -> Invalid_block_signature (block, pkh));
register_error_kind
@ -187,8 +187,8 @@ let check_endorsements_rights c level slots =
| [] -> fail Empty_endorsement
| delegate :: delegates as all_delegates ->
fail_unless
(List.for_all (fun d -> Ed25519.Public_key.equal d delegate) delegates)
(Inconsistent_endorsement (List.map Ed25519.Public_key.hash all_delegates)) >>=? fun () ->
(List.for_all (fun d -> Signature.Public_key.equal d delegate) delegates)
(Inconsistent_endorsement (List.map Signature.Public_key.hash all_delegates)) >>=? fun () ->
return delegate
let paying_priorities c =
@ -224,7 +224,7 @@ let select_delegate delegate delegate_list max_priority =
else
let LCons (pk, t) = l in
let acc =
if Ed25519.Public_key_hash.equal delegate (Ed25519.Public_key.hash pk)
if Signature.Public_key_hash.equal delegate (Signature.Public_key.hash pk)
then n :: acc
else acc in
t () >>=? fun t ->
@ -265,12 +265,12 @@ let check_proof_of_work_stamp ctxt block =
let check_signature block key =
let check_signature key { Block_header.protocol_data ; shell ; signature } =
let unsigned_header = Block_header.forge_unsigned shell protocol_data in
Ed25519.check key signature unsigned_header in
Signature.check key signature unsigned_header in
if check_signature key block then
return ()
else
fail (Invalid_block_signature (Block_header.hash block,
Ed25519.Public_key.hash key))
Signature.Public_key.hash key))
let max_fitness_gap ctxt =
let slots = Int64.of_int (Constants.endorsers_per_block ctxt + 1) in

2
src/proto_alpha/lib_protocol/src/baking.mli
View File

@ -17,7 +17,7 @@ type error += Timestamp_too_early of Timestamp.t * Timestamp.t (* `Permanent *)
type error += Inconsistent_endorsement of public_key_hash list (* `Permanent *)
type error += Cannot_freeze_baking_deposit (* `Permanent *)
type error += Cannot_freeze_endorsement_deposit (* `Permanent *)
type error += Invalid_block_signature of Block_hash.t * Ed25519.Public_key_hash.t (* `Permanent *)
type error += Invalid_block_signature of Block_hash.t * Signature.Public_key_hash.t (* `Permanent *)
val paying_priorities: context -> int list

6
src/proto_alpha/lib_protocol/src/block_header_repr.ml
View File

@ -13,7 +13,7 @@
type t = {
shell: Block_header.shell_header ;
protocol_data: protocol_data ;
signature: Ed25519.t ;
signature: Signature.t ;
}
and protocol_data = {
@ -47,7 +47,7 @@ let signed_protocol_data_encoding =
let open Data_encoding in
merge_objs
protocol_data_encoding
(obj1 (req "signature" Ed25519.encoding))
(obj1 (req "signature" Signature.encoding))
let unsigned_header_encoding =
let open Data_encoding in
@ -75,7 +75,7 @@ let max_header_length =
seed_nonce_hash = Some Nonce_hash.zero } in
Data_encoding.Binary.length
signed_protocol_data_encoding
(fake, Ed25519.zero)
(fake, Signature.zero)
(** Header parsing entry point *)

2
src/proto_alpha/lib_protocol/src/block_header_repr.mli
View File

@ -11,7 +11,7 @@
type t = {
shell: Block_header.shell_header ;
protocol_data: protocol_data ;
signature: Ed25519.t ;
signature: Signature.t ;
}
and protocol_data = {

2
src/proto_alpha/lib_protocol/src/bootstrap_storage.ml
View File

@ -8,7 +8,7 @@
(**************************************************************************)
let init ctxt (account: Parameters_repr.bootstrap_account) =
let public_key_hash = Ed25519.Public_key.hash account.public_key in
let public_key_hash = Signature.Public_key.hash account.public_key in
let contract = Contract_repr.implicit_contract public_key_hash in
Contract_storage.credit ctxt contract account.amount >>=? fun ctxt ->
Contract_storage.update_manager_key ctxt contract

6
src/proto_alpha/lib_protocol/src/constants_repr.ml
View File

@ -54,7 +54,7 @@ type parametric = {
endorsers_per_block: int ;
max_gas: int ;
proof_of_work_threshold: int64 ;
dictator_pubkey: Ed25519.Public_key.t ;
dictator_pubkey: Signature.Public_key.t ;
max_operation_data_length: int ;
tokens_per_roll: Tez_repr.t ;
michelson_maximum_type_size: int;
@ -80,7 +80,7 @@ let default = {
proof_of_work_threshold =
Int64.(sub (shift_left 1L 56) 1L) ;
dictator_pubkey =
Ed25519.Public_key.of_b58check_exn
Signature.Public_key.of_b58check_exn
"edpkugeDwmwuwyyD3Q5enapgEYDxZLtEUFFSrvVwXASQMVEqsvTqWu" ;
max_operation_data_length =
16 * 1024 ; (* 16kB *)
@ -179,7 +179,7 @@ let parametric_encoding =
(req "instructions_per_transaction" int31)
(req "proof_of_work_threshold" int64))
(obj10
(req "dictator_pubkey" Ed25519.Public_key.encoding)
(req "dictator_pubkey" Signature.Public_key.encoding)
(req "max_operation_data_length" int31)
(req "tokens_per_roll" Tez_repr.encoding)
(req "michelson_maximum_type_size" uint16)

41
src/proto_alpha/lib_protocol/src/contract_repr.ml
View File

@ -8,7 +8,7 @@
(**************************************************************************)
type t =
| Implicit of Ed25519.Public_key_hash.t
| Implicit of Signature.Public_key_hash.t
| Originated of Contract_hash.t
include Compare.Make(struct
@ -16,7 +16,7 @@ include Compare.Make(struct
let compare l1 l2 =
match l1, l2 with
| Implicit pkh1, Implicit pkh2 ->
Ed25519.Public_key_hash.compare pkh1 pkh2
Signature.Public_key_hash.compare pkh1 pkh2
| Originated h1, Originated h2 ->
Contract_hash.compare h1 h2
| Implicit _, Originated _ -> -1
@ -28,21 +28,22 @@ type contract = t
type error += Invalid_contract_notation of string (* `Permanent *)
let to_b58check = function
| Implicit pbk -> Ed25519.Public_key_hash.to_b58check pbk
| Implicit pbk -> Signature.Public_key_hash.to_b58check pbk
| Originated h -> Contract_hash.to_b58check h
let of_b58check s =
match Base58.decode s with
| Some (Ed25519.Public_key_hash.Data h) -> ok (Implicit h)
| Some (Ed25519.Public_key_hash.Data h) -> ok (Implicit (Signature.Ed25519 h))
| Some (Secp256k1.Public_key_hash.Data h) -> ok (Implicit (Signature.Secp256k1 h))
| Some (Contract_hash.Data h) -> ok (Originated h)
| _ -> error (Invalid_contract_notation s)
let pp ppf = function
| Implicit pbk -> Ed25519.Public_key_hash.pp ppf pbk
| Implicit pbk -> Signature.Public_key_hash.pp ppf pbk
| Originated h -> Contract_hash.pp ppf h
let pp_short ppf = function
| Implicit pbk -> Ed25519.Public_key_hash.pp_short ppf pbk
| Implicit pbk -> Signature.Public_key_hash.pp_short ppf pbk
| Originated h -> Contract_hash.pp_short ppf h
let encoding =
@ -57,7 +58,7 @@ let encoding =
splitted
~binary:
(union ~tag_size:`Uint8 [
case (Tag 0) Ed25519.Public_key_hash.encoding
case (Tag 0) Signature.Public_key_hash.encoding
(function Implicit k -> Some k | _ -> None)
(fun k -> Implicit k) ;
case (Tag 1) Contract_hash.encoding
@ -150,29 +151,31 @@ let arg =
module Index = struct
type t = contract
let path_length =
assert Compare.Int.(Ed25519.Public_key_hash.path_length =
Contract_hash.path_length) ;
Ed25519.Public_key_hash.path_length + 1
assert Compare.Int.(Signature.Public_key_hash.path_length =
1 + Contract_hash.path_length) ;
Signature.Public_key_hash.path_length
let to_path c l =
match c with
| Implicit k ->
"implicit" :: Ed25519.Public_key_hash.to_path k l
Signature.Public_key_hash.to_path k l
| Originated h ->
"originated" :: Contract_hash.to_path h l
let of_path = function
| "implicit" :: key -> begin
match Ed25519.Public_key_hash.of_path key with
| None -> None
| Some h -> Some (Implicit h)
end
| "originated" :: key -> begin
match Contract_hash.of_path key with
| None -> None
| Some h -> Some (Originated h)
end
| _ -> None
| key -> begin
match Signature.Public_key_hash.of_path key with
| None -> None
| Some h -> Some (Implicit h)
end
let contract_prefix s =
"originated" :: Contract_hash.prefix_path s
let pkh_prefix s =
"pubkey" :: Ed25519.Public_key_hash.prefix_path s
let pkh_prefix_ed25519 s =
Ed25519.Public_key_hash.prefix_path s
let pkh_prefix_secp256k1 s =
Secp256k1.Public_key_hash.prefix_path s
end

9
src/proto_alpha/lib_protocol/src/contract_repr.mli
View File

@ -8,7 +8,7 @@
(**************************************************************************)
type t = private
| Implicit of Ed25519.Public_key_hash.t
| Implicit of Signature.Public_key_hash.t
| Originated of Contract_hash.t
type contract = t
@ -16,9 +16,9 @@ include Compare.S with type t := contract
(** {2 Implicit contracts} *****************************************************)
val implicit_contract : Ed25519.Public_key_hash.t -> contract
val implicit_contract : Signature.Public_key_hash.t -> contract
val is_implicit : contract -> Ed25519.Public_key_hash.t option
val is_implicit : contract -> Signature.Public_key_hash.t option
(** {2 Originated contracts} **************************************************)
@ -66,5 +66,6 @@ module Index : sig
val to_path: t -> string list -> string list
val of_path: string list -> t option
val contract_prefix: string -> string list
val pkh_prefix: string -> string list
val pkh_prefix_ed25519: string -> string list
val pkh_prefix_secp256k1: string -> string list
end

8
src/proto_alpha/lib_protocol/src/contract_services.ml
View File

@ -30,12 +30,12 @@ let info_encoding =
(fun (manager, balance, spendable, delegate, script, storage, counter) ->
{manager ; balance ; spendable ; delegate ; script ; storage ; counter}) @@
obj7
(req "manager" Ed25519.Public_key_hash.encoding)
(req "manager" Signature.Public_key_hash.encoding)
(req "balance" Tez.encoding)
(req "spendable" bool)
(req "delegate" @@ obj2
(req "setable" bool)
(opt "value" Ed25519.Public_key_hash.encoding))
(opt "value" Signature.Public_key_hash.encoding))
(opt "script" Script.encoding)
(opt "storage" Script.expr_encoding)
(req "counter" int32)
@ -57,7 +57,7 @@ module S = struct
~description: "Access the manager of a contract."
~query: RPC_query.empty
~input: empty
~output: (obj1 (req "manager" Ed25519.Public_key_hash.encoding))
~output: (obj1 (req "manager" Signature.Public_key_hash.encoding))
RPC_path.(custom_root /: Contract.arg / "manager")
let delegate =
@ -65,7 +65,7 @@ module S = struct
~description: "Access the delegate of a contract, if any."
~query: RPC_query.empty
~input: empty
~output: (obj1 (req "delegate" Ed25519.Public_key_hash.encoding))
~output: (obj1 (req "delegate" Signature.Public_key_hash.encoding))
RPC_path.(custom_root /: Contract.arg / "delegate")
let counter =

40
src/proto_alpha/lib_protocol/src/contract_storage.ml
View File

@ -13,9 +13,9 @@ type error +=
| Counter_in_the_future of Contract_repr.contract * int32 * int32 (* `Temporary *)
| Unspendable_contract of Contract_repr.contract (* `Permanent *)
| Non_existing_contract of Contract_repr.contract (* `Temporary *)
| Inconsistent_hash of Ed25519.Public_key.t * Ed25519.Public_key_hash.t * Ed25519.Public_key_hash.t (* `Permanent *)
| Inconsistent_public_key of Ed25519.Public_key.t * Ed25519.Public_key.t (* `Permanent *)
| Missing_public_key of Ed25519.Public_key_hash.t (* `Permanent *)
| Inconsistent_hash of Signature.Public_key.t * Signature.Public_key_hash.t * Signature.Public_key_hash.t (* `Permanent *)
| Inconsistent_public_key of Signature.Public_key.t * Signature.Public_key.t (* `Permanent *)
| Missing_public_key of Signature.Public_key_hash.t (* `Permanent *)
| Failure of string (* `Permanent *)
let () =
@ -95,13 +95,13 @@ let () =
~description:"A revealed manager public key is inconsistent with the announced hash"
~pp:(fun ppf (k, eh, ph) ->
Format.fprintf ppf "The hash of the manager public key %s is not %a as announced but %a"
(Ed25519.Public_key.to_b58check k)
Ed25519.Public_key_hash.pp ph
Ed25519.Public_key_hash.pp eh)
(Signature.Public_key.to_b58check k)
Signature.Public_key_hash.pp ph
Signature.Public_key_hash.pp eh)
Data_encoding.(obj3
(req "public_key" Ed25519.Public_key.encoding)
(req "expected_hash" Ed25519.Public_key_hash.encoding)
(req "provided_hash" Ed25519.Public_key_hash.encoding))
(req "public_key" Signature.Public_key.encoding)
(req "expected_hash" Signature.Public_key_hash.encoding)
(req "provided_hash" Signature.Public_key_hash.encoding))
(function Inconsistent_hash (k, eh, ph) -> Some (k, eh, ph) | _ -> None)
(fun (k, eh, ph) -> Inconsistent_hash (k, eh, ph)) ;
register_error_kind
@ -111,11 +111,11 @@ let () =
~description:"A provided manager public key is different with the public key stored in the contract"
~pp:(fun ppf (eh, ph) ->
Format.fprintf ppf "Expected manager public key %s but %s was provided"
(Ed25519.Public_key.to_b58check ph)
(Ed25519.Public_key.to_b58check eh))
(Signature.Public_key.to_b58check ph)
(Signature.Public_key.to_b58check eh))
Data_encoding.(obj2
(req "public_key" Ed25519.Public_key.encoding)
(req "expected_public_key" Ed25519.Public_key.encoding))
(req "public_key" Signature.Public_key.encoding)
(req "expected_public_key" Signature.Public_key.encoding))
(function Inconsistent_public_key (eh, ph) -> Some (eh, ph) | _ -> None)
(fun (eh, ph) -> Inconsistent_public_key (eh, ph)) ;
register_error_kind
@ -125,8 +125,8 @@ let () =
~description:"The manager public key must be provided to execute the current operation"
~pp:(fun ppf k ->
Format.fprintf ppf "The manager public key ( with hash %a ) is missing"
Ed25519.Public_key_hash.pp k)
Data_encoding.(obj1 (req "hash" Ed25519.Public_key_hash.encoding))
Signature.Public_key_hash.pp k)
Data_encoding.(obj1 (req "hash" Signature.Public_key_hash.encoding))
(function Missing_public_key k -> Some k | _ -> None)
(fun k -> Missing_public_key k) ;
register_error_kind
@ -249,17 +249,17 @@ let get_manager c contract =
| None -> failwith "get_manager"
end
| Some (Manager_repr.Hash v) -> return v
| Some (Manager_repr.Public_key v) -> return (Ed25519.Public_key.hash v)
| Some (Manager_repr.Public_key v) -> return (Signature.Public_key.hash v)
let update_manager_key c contract = function
| Some public_key ->
begin Storage.Contract.Manager.get c contract >>=? function
| Public_key v -> (* key revealed for the second time *)
if Ed25519.Public_key.(v = public_key) then return (c,v)
if Signature.Public_key.(v = public_key) then return (c,v)
else fail (Inconsistent_public_key (v,public_key))
| Hash v ->
let actual_hash = Ed25519.Public_key.hash public_key in
if (Ed25519.Public_key_hash.equal actual_hash v) then
let actual_hash = Signature.Public_key.hash public_key in
if (Signature.Public_key_hash.equal actual_hash v) then
let v = (Manager_repr.Public_key public_key) in
Storage.Contract.Manager.set c contract v >>=? fun c ->
return (c,public_key) (* reveal and update key *)
@ -335,7 +335,7 @@ let spend_from_script c contract amount =
Delegate_storage.get c contract >>=? function
| Some pkh' ->
(* Don't delete "delegate" contract *)
assert (Ed25519.Public_key_hash.equal pkh pkh') ;
assert (Signature.Public_key_hash.equal pkh pkh') ;
return c
| None ->
(* Delete empty implicit contract *)

16
src/proto_alpha/lib_protocol/src/contract_storage.mli
View File

@ -13,9 +13,9 @@ type error +=
| Counter_in_the_future of Contract_repr.contract * int32 * int32 (* `Temporary *)
| Unspendable_contract of Contract_repr.contract (* `Permanent *)
| Non_existing_contract of Contract_repr.contract (* `Temporary *)
| Inconsistent_hash of Ed25519.Public_key.t * Ed25519.Public_key_hash.t * Ed25519.Public_key_hash.t (* `Permanent *)
| Inconsistent_public_key of Ed25519.Public_key.t * Ed25519.Public_key.t (* `Permanent *)
| Missing_public_key of Ed25519.Public_key_hash.t (* `Permanent *)
| Inconsistent_hash of Signature.Public_key.t * Signature.Public_key_hash.t * Signature.Public_key_hash.t (* `Permanent *)
| Inconsistent_public_key of Signature.Public_key.t * Signature.Public_key.t (* `Permanent *)
| Missing_public_key of Signature.Public_key_hash.t (* `Permanent *)
| Failure of string (* `Permanent *)
val exists: Raw_context.t -> Contract_repr.t -> bool tzresult Lwt.t
@ -35,11 +35,11 @@ val is_delegatable:
val is_spendable: Raw_context.t -> Contract_repr.t -> bool tzresult Lwt.t
val get_manager:
Raw_context.t -> Contract_repr.t -> Ed25519.Public_key_hash.t tzresult Lwt.t
Raw_context.t -> Contract_repr.t -> Signature.Public_key_hash.t tzresult Lwt.t
val update_manager_key:
Raw_context.t -> Contract_repr.t -> Ed25519.Public_key.t option ->
(Raw_context.t * Ed25519.Public_key.t) tzresult Lwt.t
Raw_context.t -> Contract_repr.t -> Signature.Public_key.t option ->
(Raw_context.t * Signature.Public_key.t) tzresult Lwt.t
val get_balance: Raw_context.t -> Contract_repr.t -> Tez_repr.t tzresult Lwt.t
val get_counter: Raw_context.t -> Contract_repr.t -> int32 tzresult Lwt.t
@ -80,9 +80,9 @@ val originate:
Raw_context.t ->
Contract_repr.origination_nonce ->
balance:Tez_repr.t ->
manager:Ed25519.Public_key_hash.t ->
manager:Signature.Public_key_hash.t ->
?script:(Script_repr.t * (Tez_repr.t * Tez_repr.t)) ->
delegate:Ed25519.Public_key_hash.t option ->
delegate:Signature.Public_key_hash.t option ->
spendable:bool ->
delegatable:bool ->
(Raw_context.t * Contract_repr.t * Contract_repr.origination_nonce) tzresult Lwt.t

21
src/proto_alpha/lib_protocol/src/delegate_services.ml
View File

@ -43,7 +43,7 @@ module Baker = struct
(req "baking_rights"
(list
(obj2
(req "delegate" Ed25519.Public_key_hash.encoding)
(req "delegate" Signature.Public_key_hash.encoding)
(req "timestamp" Timestamp.encoding)))))
custom_root
@ -57,7 +57,7 @@ module Baker = struct
~output: (obj2
(req "level" Raw_level.encoding)
(req "delegates"
(list Ed25519.Public_key_hash.encoding)))
(list Signature.Public_key_hash.encoding)))
RPC_path.(custom_root / "level" /: Raw_level.arg)
(* let levels = *)
@ -75,7 +75,8 @@ module Baker = struct
~query: RPC_query.empty
~input: slots_range_encoding
~output: (Data_encoding.list slot_encoding)
RPC_path.(custom_root / "delegate" /: Ed25519.Public_key_hash.rpc_arg)
RPC_path.(custom_root / "delegate" /: Signature.Public_key_hash.rpc_arg)
(* let delegates = *)
(* RPC_service.post_service *)
@ -84,7 +85,7 @@ module Baker = struct
(* ~query: RPC_query.empty *)
(* ~input: empty *)
(* ~output: (obj1 (req "delegates" *)
(* (list Ed25519.Public_key_hash.encoding))) *)
(* (list Signature.Public_key_hash.encoding))) *)
(* RPC_path.(custom_root / "delegate") *)
end
@ -107,7 +108,7 @@ module Baker = struct
let Misc.LCons (h, t) = l in
t () >>=? fun t ->
loop t (pred n) >>=? fun t ->
return (Ed25519.Public_key.hash h :: t)
return (Signature.Public_key.hash h :: t)
in
loop contract_list max >>=? fun prio ->
return (level.level, prio)
@ -204,7 +205,7 @@ module Endorser = struct
~output: (obj2
(req "level" Raw_level.encoding)
(req "delegates"
(list Ed25519.Public_key_hash.encoding)))
(list Signature.Public_key_hash.encoding)))
custom_root
let rights_for_level =
@ -216,7 +217,7 @@ module Endorser = struct
~output: (obj2
(req "level" Raw_level.encoding)
(req "delegates"
(list Ed25519.Public_key_hash.encoding)))
(list Signature.Public_key_hash.encoding)))
RPC_path.(custom_root / "level" /: Raw_level.arg)
(* let levels = *)
@ -234,7 +235,7 @@ module Endorser = struct
~query: RPC_query.empty
~input: slots_range_encoding
~output: (Data_encoding.list slot_encoding)
RPC_path.(custom_root / "delegate" /: Ed25519.Public_key_hash.rpc_arg)
RPC_path.(custom_root / "delegate" /: Signature.Public_key_hash.rpc_arg)
(* let delegates = *)
(* RPC_service.post_service *)
@ -243,7 +244,7 @@ module Endorser = struct
(* ~query: RPC_query.empty *)
(* ~input: empty *)
(* ~output: (obj1 (req "delegates" *)
(* (list Ed25519.Public_key_hash.encoding))) *)
(* (list Signature.Public_key_hash.encoding))) *)
(* RPC_path.(custom_root / "delegate") *)
end
@ -266,7 +267,7 @@ module Endorser = struct
let Misc.LCons (h, t) = l in
t () >>=? fun t ->
loop t (pred n) >>=? fun t ->
return (Ed25519.Public_key.hash h :: t)
return (Signature.Public_key.hash h :: t)
in
loop contract_list max >>=? fun prio ->
return (level.level, prio)

12
src/proto_alpha/lib_protocol/src/delegate_services.mli
View File

@ -13,16 +13,16 @@ module Baker : sig
val rights:
'a #RPC_context.simple -> ?max_priority:int -> 'a ->
(Raw_level.t * (Ed25519.Public_key_hash.t * Time.t) list) shell_tzresult Lwt.t
(Raw_level.t * (Signature.Public_key_hash.t * Time.t) list) shell_tzresult Lwt.t
val rights_for_level:
'a #RPC_context.simple -> ?max_priority:int -> 'a -> Raw_level.t ->
(Raw_level.t * Ed25519.Public_key_hash.t list) shell_tzresult Lwt.t
(Raw_level.t * Signature.Public_key_hash.t list) shell_tzresult Lwt.t
val rights_for_delegate:
'a #RPC_context.simple ->
?max_priority:int -> ?first_level:Raw_level.t -> ?last_level:Raw_level.t ->
'a -> Ed25519.Public_key_hash.t ->
'a -> Signature.Public_key_hash.t ->
(Raw_level.t * int * Time.t) list shell_tzresult Lwt.t
end
@ -31,16 +31,16 @@ module Endorser : sig
val rights:
'a #RPC_context.simple -> ?max_priority:int -> 'a ->
(Raw_level.t * Ed25519.Public_key_hash.t list) shell_tzresult Lwt.t
(Raw_level.t * Signature.Public_key_hash.t list) shell_tzresult Lwt.t
val rights_for_level:
'a #RPC_context.simple -> ?max_priority:int -> 'a -> Raw_level.t ->
(Raw_level.t * Ed25519.Public_key_hash.t list) shell_tzresult Lwt.t
(Raw_level.t * Signature.Public_key_hash.t list) shell_tzresult Lwt.t
val rights_for_delegate:
'a #RPC_context.simple ->
?max_priority:int -> ?first_level:Raw_level.t -> ?last_level:Raw_level.t ->
'a -> Ed25519.Public_key_hash.t ->
'a -> Signature.Public_key_hash.t ->
(Raw_level.t * int) list shell_tzresult Lwt.t
end

16
src/proto_alpha/lib_protocol/src/delegate_storage.ml
View File

@ -9,10 +9,10 @@
type error +=
| Non_delegatable_contract of Contract_repr.contract (* `Permanent *)
| No_deletion of Ed25519.Public_key_hash.t (* `Permanent *)
| No_deletion of Signature.Public_key_hash.t (* `Permanent *)
| Active_delegate (* `Temporary *)
| Current_delegate (* `Temporary *)
| Empty_delegate_account of Ed25519.Public_key_hash.t (* `Temporary *)
| Empty_delegate_account of Signature.Public_key_hash.t (* `Temporary *)
let () =
register_error_kind
@ -34,8 +34,8 @@ let () =
~description:"Tried to unregister a delegate"
~pp:(fun ppf delegate ->
Format.fprintf ppf "Delegate deletion is forbidden (%a)"
Ed25519.Public_key_hash.pp delegate)
Data_encoding.(obj1 (req "delegate" Ed25519.Public_key_hash.encoding))
Signature.Public_key_hash.pp delegate)
Data_encoding.(obj1 (req "delegate" Signature.Public_key_hash.encoding))
(function No_deletion c -> Some c | _ -> None)
(fun c -> No_deletion c) ;
register_error_kind
@ -69,8 +69,8 @@ let () =
Format.fprintf ppf
"Delegate registration is forbidden when the delegate
implicit account is empty (%a)"
Ed25519.Public_key_hash.pp delegate)
Data_encoding.(obj1 (req "delegate" Ed25519.Public_key_hash.encoding))
Signature.Public_key_hash.pp delegate)
Data_encoding.(obj1 (req "delegate" Signature.Public_key_hash.encoding))
(function Empty_delegate_account c -> Some c | _ -> None)
(fun c -> Empty_delegate_account c)
@ -139,7 +139,7 @@ let set c contract delegate =
is_delegatable c contract >>=? fun delegatable ->
let self_delegation =
match Contract_repr.is_implicit contract with
| Some pkh -> Ed25519.Public_key_hash.equal pkh delegate
| Some pkh -> Signature.Public_key_hash.equal pkh delegate
| None -> false in
if not known_delegate || not (registered_delegate || self_delegation) then
fail (Roll_storage.Unregistered_delegate delegate)
@ -149,7 +149,7 @@ let set c contract delegate =
begin
Storage.Contract.Delegate.get_option c contract >>=? function
| Some current_delegate
when Ed25519.Public_key_hash.equal delegate current_delegate ->
when Signature.Public_key_hash.equal delegate current_delegate ->
if self_delegation then
Storage.Contract.Inactive_delegate.mem c contract >>= function
| true -> return ()

26
src/proto_alpha/lib_protocol/src/delegate_storage.mli
View File

@ -13,7 +13,7 @@ val is_delegatable:
(** Allow to register a delegate when creating an account. *)
val init:
Raw_context.t -> Contract_repr.t -> Ed25519.Public_key_hash.t ->
Raw_context.t -> Contract_repr.t -> Signature.Public_key_hash.t ->
Raw_context.t tzresult Lwt.t
(** Cleanup delegation when deleting a contract. *)
@ -23,9 +23,9 @@ val remove:
(** Reading the current delegate of a contract. *)
val get:
Raw_context.t -> Contract_repr.t ->
Ed25519.Public_key_hash.t option tzresult Lwt.t
Signature.Public_key_hash.t option tzresult Lwt.t
val registered: Raw_context.t -> Ed25519.Public_key_hash.t -> bool Lwt.t
val registered: Raw_context.t -> Signature.Public_key_hash.t -> bool Lwt.t
(** Updating the delegate of a contract.
@ -35,7 +35,7 @@ val registered: Raw_context.t -> Ed25519.Public_key_hash.t -> bool Lwt.t
cannot unregister a delegate for now. The associate contract is
now 'undeletable'. *)
val set:
Raw_context.t -> Contract_repr.t -> Ed25519.Public_key_hash.t option ->
Raw_context.t -> Contract_repr.t -> Signature.Public_key_hash.t option ->
Raw_context.t tzresult Lwt.t
type error +=
@ -45,25 +45,25 @@ type error +=
val fold:
Raw_context.t ->
init:'a ->
f:(Ed25519.Public_key_hash.t -> 'a -> 'a Lwt.t) -> 'a Lwt.t
f:(Signature.Public_key_hash.t -> 'a -> 'a Lwt.t) -> 'a Lwt.t
(** List all registered delegates. *)
val list: Raw_context.t -> Ed25519.Public_key_hash.t list Lwt.t
val list: Raw_context.t -> Signature.Public_key_hash.t list Lwt.t
(** Various functions to 'freeze' tokens. A frozen 'deposit' keeps its
associated rolls. When frozen, 'fees' may trigger new rolls
allocation. Rewards won't trigger new rolls allocation until
unfrozen. *)
val freeze_deposit:
Raw_context.t -> Ed25519.Public_key_hash.t -> Tez_repr.t ->
Raw_context.t -> Signature.Public_key_hash.t -> Tez_repr.t ->
Raw_context.t tzresult Lwt.t
val freeze_fees:
Raw_context.t -> Ed25519.Public_key_hash.t -> Tez_repr.t ->
Raw_context.t -> Signature.Public_key_hash.t -> Tez_repr.t ->
Raw_context.t tzresult Lwt.t
val freeze_rewards:
Raw_context.t -> Ed25519.Public_key_hash.t -> Tez_repr.t ->
Raw_context.t -> Signature.Public_key_hash.t -> Tez_repr.t ->
Raw_context.t tzresult Lwt.t
(** Trigger the context maintenance at the end of cycle 'n', i.e.:
@ -77,22 +77,22 @@ val cycle_end:
(** Burn all then frozen deposit/fees/rewards for a delegate at a given
cycle. Returns the burned amount. *)
val punish:
Raw_context.t -> Ed25519.Public_key_hash.t -> Cycle_repr.t ->
Raw_context.t -> Signature.Public_key_hash.t -> Cycle_repr.t ->
(Raw_context.t * Tez_repr.t) tzresult Lwt.t
(** Has the given key some frozen tokens in its implicit contract? *)
val has_frozen_balance:
Raw_context.t -> Ed25519.Public_key_hash.t -> Cycle_repr.t ->
Raw_context.t -> Signature.Public_key_hash.t -> Cycle_repr.t ->
bool tzresult Lwt.t
(** Returns the amount of frozen tokens associated to a given key. *)
val frozen_balance:
Raw_context.t -> Ed25519.Public_key_hash.t ->
Raw_context.t -> Signature.Public_key_hash.t ->
Tez_repr.t tzresult Lwt.t
(** Returns the full 'balance' of the implicit contract associated to
a given key, i.e. the sum of the spendable balance and of the
frozen balance. *)
val full_balance:
Raw_context.t -> Ed25519.Public_key_hash.t ->
Raw_context.t -> Signature.Public_key_hash.t ->
Tez_repr.t tzresult Lwt.t

4
src/proto_alpha/lib_protocol/src/helpers_services.ml
View File

@ -51,7 +51,7 @@ module S = struct
(req "pred_block" Block_hash.encoding)
(req "operation_hash" Operation_hash.encoding)
(req "forged_operation" bytes)
(opt "signature" Ed25519.encoding))
(opt "signature" Signature.encoding))
~output: (obj1 (req "contracts" (list Contract.encoding)))
RPC_path.(custom_root / "apply_operation")
@ -135,7 +135,7 @@ module I = struct
let operation = { shell ; contents ; signature } in
let level = Level.succ ctxt (Level.current ctxt) in
Baking.baking_priorities ctxt level >>=? fun (Misc.LCons (baker_pk, _)) ->
let baker_pkh = Ed25519.Public_key.hash baker_pk in
let baker_pkh = Signature.Public_key.hash baker_pk in
let block_prio = 0 in
Apply.apply_operation
ctxt (Some baker_pkh) pred_block block_prio hash operation

2
src/proto_alpha/lib_protocol/src/helpers_services.mli
View File

@ -18,7 +18,7 @@ val minimal_time:
val apply_operation:
'a #RPC_context.simple ->
'a -> Block_hash.t -> Operation_hash.t -> MBytes.t -> Ed25519.t option ->
'a -> Block_hash.t -> Operation_hash.t -> MBytes.t -> Signature.t option ->
(Contract.t list) shell_tzresult Lwt.t
val run_code:

4
src/proto_alpha/lib_protocol/src/main.ml
View File

@ -70,7 +70,7 @@ let begin_application
Alpha_context.prepare ~level ~timestamp ~fitness ctxt >>=? fun ctxt ->
Apply.begin_application
ctxt block_header pred_timestamp >>=? fun (ctxt, baker, deposit) ->
let mode = Application { block_header ; baker = Ed25519.Public_key.hash baker } in
let mode = Application { block_header ; baker = Signature.Public_key.hash baker } in
return { mode ; ctxt ; op_count = 0 ; deposit }
let begin_construction
@ -96,7 +96,7 @@ let begin_construction
ctxt pred_timestamp
proto_header >>=? fun (ctxt, protocol_data, baker, deposit) ->
let mode =
let baker = Ed25519.Public_key.hash baker in
let baker = Signature.Public_key.hash baker in
Full_construction { predecessor ; baker ; protocol_data } in
return (mode, ctxt, deposit)
end >>=? fun (mode, ctxt, deposit) ->

8
src/proto_alpha/lib_protocol/src/manager_repr.ml
View File

@ -10,22 +10,22 @@
(* Tezos Protocol Implementation - Low level Repr. of Managers' keys *)
type manager_key =
| Hash of Ed25519.Public_key_hash.t
| Public_key of Ed25519.Public_key.t
| Hash of Signature.Public_key_hash.t
| Public_key of Signature.Public_key.t
type t = manager_key
open Data_encoding
let hash_case tag =
case tag Ed25519.Public_key_hash.encoding
case tag Signature.Public_key_hash.encoding
(function
| Hash hash -> Some hash
| _ -> None)
(fun hash -> Hash hash)
let pubkey_case tag =
case tag Ed25519.Public_key.encoding
case tag Signature.Public_key.encoding
(function
| Public_key hash -> Some hash
| _ -> None)

4
src/proto_alpha/lib_protocol/src/manager_repr.mli
View File

@ -14,8 +14,8 @@
of its public key that is stored in the contract. When the public key
is actually reveeld, the public key instead of the hash of the key *)
type manager_key =
| Hash of Ed25519.Public_key_hash.t
| Public_key of Ed25519.Public_key.t
| Hash of Signature.Public_key_hash.t
| Public_key of Signature.Public_key.t
type t = manager_key

2
src/proto_alpha/lib_protocol/src/nonce_storage.ml
View File

@ -47,7 +47,7 @@ let reveal c level nonce =
type unrevealed = Storage.Seed.unrevealed_nonce = {
nonce_hash: Nonce_hash.t ;
delegate: Ed25519.Public_key_hash.t ;
delegate: Signature.Public_key_hash.t ;
deposit: Tez_repr.t ;
rewards: Tez_repr.t ;
fees: Tez_repr.t ;

2
src/proto_alpha/lib_protocol/src/nonce_storage.mli
View File

@ -19,7 +19,7 @@ val encoding: nonce Data_encoding.t
type unrevealed = Storage.Seed.unrevealed_nonce = {
nonce_hash: Nonce_hash.t ;
delegate: Ed25519.Public_key_hash.t ;
delegate: Signature.Public_key_hash.t ;
deposit: Tez_repr.t ;
rewards: Tez_repr.t ;
fees: Tez_repr.t ;

26
src/proto_alpha/lib_protocol/src/operation_repr.ml
View File

@ -19,7 +19,7 @@ let raw_encoding = Operation.encoding
type operation = {
shell: Operation.shell_header ;
contents: proto_operation ;
signature: Ed25519.t option ;
signature: Signature.t option ;
}
and proto_operation =
@ -47,7 +47,7 @@ and anonymous_operation =
and sourced_operations =
| Consensus_operation of consensus_operation
| Amendment_operation of {
source: Ed25519.Public_key_hash.t ;
source: Signature.Public_key_hash.t ;
operation: amendment_operation ;
}
| Manager_operations of {
@ -77,21 +77,21 @@ and amendment_operation =
}
and manager_operation =
| Reveal of Ed25519.Public_key.t
| Reveal of Signature.Public_key.t
| 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 ;
manager: Signature.Public_key_hash.t ;
delegate: Signature.Public_key_hash.t option ;
script: Script_repr.t option ;
spendable: bool ;
delegatable: bool ;
credit: Tez_repr.tez ;
}
| Delegation of Ed25519.Public_key_hash.t option
| Delegation of Signature.Public_key_hash.t option
and dictator_operation =
| Activate of Protocol_hash.t
@ -106,7 +106,7 @@ module Encoding = struct
let reveal_encoding =
(obj2
(req "kind" (constant "reveal"))
(req "public_key" Ed25519.Public_key.encoding))
(req "public_key" Signature.Public_key.encoding))
let reveal_case tag =
case tag reveal_encoding
@ -134,11 +134,11 @@ module Encoding = struct
let origination_encoding =
(obj7
(req "kind" (constant "origination"))
(req "managerPubkey" Ed25519.Public_key_hash.encoding)
(req "managerPubkey" Signature.Public_key_hash.encoding)
(req "balance" Tez_repr.encoding)
(opt "spendable" bool)
(opt "delegatable" bool)
(opt "delegate" Ed25519.Public_key_hash.encoding)
(opt "delegate" Signature.Public_key_hash.encoding)
(opt "script" Script_repr.encoding))
let origination_case tag =
@ -160,7 +160,7 @@ module Encoding = struct
let delegation_encoding =
(obj2
(req "kind" (constant "delegation"))
(opt "delegate" Ed25519.Public_key_hash.encoding))
(opt "delegate" Signature.Public_key_hash.encoding))
let delegation_case tag =
case tag delegation_encoding
@ -247,7 +247,7 @@ module Encoding = struct
let amendment_kind_encoding =
merge_objs
(obj1 (req "source" Ed25519.Public_key_hash.encoding))
(obj1 (req "source" Signature.Public_key_hash.encoding))
(union [
proposal_case (Tag 0) ;
ballot_case (Tag 1) ;
@ -379,7 +379,7 @@ module Encoding = struct
let mu_signed_proto_operation_encoding op_encoding =
merge_objs
(mu_proto_operation_encoding op_encoding)
(obj1 (varopt "signature" Ed25519.encoding))
(obj1 (varopt "signature" Signature.encoding))
let operation_encoding =
mu "operation"
@ -476,7 +476,7 @@ let check_signature key { shell ; contents ; signature } =
fail Missing_signature
| Sourced_operations _, Some signature ->
let unsigned_operation = forge shell contents in
if Ed25519.check key signature unsigned_operation then
if Signature.check key signature unsigned_operation then
return ()
else
fail Invalid_signature

17
src/proto_alpha/lib_protocol/src/operation_repr.mli
View File

@ -19,7 +19,7 @@ val raw_encoding: raw Data_encoding.t
type operation = {
shell: Operation.shell_header ;
contents: proto_operation ;
signature: Ed25519.t option ;
signature: Signature.t option ;
}
and proto_operation =
@ -47,7 +47,7 @@ and anonymous_operation =
and sourced_operations =
| Consensus_operation of consensus_operation
| Amendment_operation of {
source: Ed25519.Public_key_hash.t ;
source: Signature.Public_key_hash.t ;
operation: amendment_operation ;
}
| Manager_operations of {
@ -77,21 +77,21 @@ and amendment_operation =
}
and manager_operation =
| Reveal of Ed25519.Public_key.t
| Reveal of Signature.Public_key.t
| 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 ;
manager: Signature.Public_key_hash.t ;
delegate: Signature.Public_key_hash.t option ;
script: Script_repr.t option ;
spendable: bool ;
delegatable: bool ;
credit: Tez_repr.tez ;
}
| Delegation of Ed25519.Public_key_hash.t option
| Delegation of Signature.Public_key_hash.t option
and dictator_operation =
| Activate of Protocol_hash.t
@ -112,13 +112,14 @@ val acceptable_passes: operation -> int list
val parse_proto:
MBytes.t ->
(proto_operation * Ed25519.t option) tzresult Lwt.t
(proto_operation * Signature.t option) tzresult Lwt.t
type error += Missing_signature (* `Permanent *)
type error += Invalid_signature (* `Permanent *)
val check_signature:
Ed25519.Public_key.t -> operation -> unit tzresult Lwt.t
Signature.Public_key.t -> operation -> unit tzresult Lwt.t
val forge: Operation.shell_header -> proto_operation -> MBytes.t

8
src/proto_alpha/lib_protocol/src/parameters_repr.ml
View File

@ -8,7 +8,7 @@
(**************************************************************************)
type bootstrap_account = {
public_key : Ed25519.Public_key.t ;
public_key : Signature.Public_key.t ;
amount : Tez_repr.t ;
}
@ -23,7 +23,7 @@ let bootstrap_account_encoding =
conv
(fun { public_key ; amount } -> (public_key, amount))
(fun (public_key, amount) -> { public_key ; amount })
(tup2 Ed25519.Public_key.encoding Tez_repr.encoding)
(tup2 Signature.Public_key.encoding Tez_repr.encoding)
(* This encoding is used to read configuration files (e.g. sandbox.json)
where some fields can be missing, in that case they are replaced by
@ -67,7 +67,7 @@ let constants_encoding =
opt Compare.Int64.(=)
default.proof_of_work_threshold c.proof_of_work_threshold
and dictator_pubkey =
opt Ed25519.Public_key.(=)
opt Signature.Public_key.(=)
default.dictator_pubkey c.dictator_pubkey
and max_operation_data_length =
opt Compare.Int.(=)
@ -194,7 +194,7 @@ let constants_encoding =
(opt "instructions_per_transaction" int31)
(opt "proof_of_work_threshold" int64))
(obj10
(opt "dictator_pubkey" Ed25519.Public_key.encoding)
(opt "dictator_pubkey" Signature.Public_key.encoding)
(opt "max_operation_data_length" int31)
(opt "tokens_per_roll" Tez_repr.encoding)
(opt "michelson_maximum_type_size" uint16)

2
src/proto_alpha/lib_protocol/src/parameters_repr.mli
View File

@ -8,7 +8,7 @@
(**************************************************************************)
type bootstrap_account = {
public_key : Ed25519.Public_key.t ;
public_key : Signature.Public_key.t ;
amount : Tez_repr.t ;
}

6
src/proto_alpha/lib_protocol/src/roll_storage.ml
View File

@ -13,7 +13,7 @@ type error +=
| Consume_roll_change
| No_roll_for_delegate
| No_roll_snapshot_for_cycle of Cycle_repr.t
| Unregistered_delegate of Ed25519.Public_key_hash.t (* `Permanent *)
| Unregistered_delegate of Signature.Public_key_hash.t (* `Permanent *)
let () =
register_error_kind
@ -24,8 +24,8 @@ let () =
~pp:(fun ppf (k) ->
Format.fprintf ppf "The provided public key (with hash %a) is \
\ not registered as valid delegate key."
Ed25519.Public_key_hash.pp k)
Data_encoding.(obj1 (req "hash" Ed25519.Public_key_hash.encoding))
Signature.Public_key_hash.pp k)
Data_encoding.(obj1 (req "hash" Signature.Public_key_hash.encoding))
(function Unregistered_delegate (k) -> Some (k) | _ -> None)
(fun (k) -> Unregistered_delegate (k))

22
src/proto_alpha/lib_protocol/src/roll_storage.mli
View File

@ -20,7 +20,7 @@
type error +=
| Consume_roll_change
| No_roll_for_delegate
| Unregistered_delegate of Ed25519.Public_key_hash.t (* `Permanent *)
| Unregistered_delegate of Signature.Public_key_hash.t (* `Permanent *)
val init : Raw_context.t -> Raw_context.t tzresult Lwt.t
val init_first_cycles : Raw_context.t -> Raw_context.t tzresult Lwt.t
@ -31,28 +31,28 @@ val snapshot_rolls : Raw_context.t -> Raw_context.t tzresult Lwt.t
val fold :
Raw_context.t ->
f:(Roll_repr.roll -> Ed25519.Public_key.t -> 'a -> 'a tzresult Lwt.t) ->
f:(Roll_repr.roll -> Signature.Public_key.t -> 'a -> 'a tzresult Lwt.t) ->
'a -> 'a tzresult Lwt.t
val baking_rights_owner :
Raw_context.t -> Level_repr.t -> priority:int ->
Ed25519.Public_key.t tzresult Lwt.t
Signature.Public_key.t tzresult Lwt.t
val endorsement_rights_owner :
Raw_context.t -> Level_repr.t -> slot:int ->
Ed25519.Public_key.t tzresult Lwt.t
Signature.Public_key.t tzresult Lwt.t
module Delegate : sig
val add_amount :
Raw_context.t -> Ed25519.Public_key_hash.t -> Tez_repr.t -> Raw_context.t tzresult Lwt.t
Raw_context.t -> Signature.Public_key_hash.t -> Tez_repr.t -> Raw_context.t tzresult Lwt.t
val remove_amount :
Raw_context.t -> Ed25519.Public_key_hash.t -> Tez_repr.t -> Raw_context.t tzresult Lwt.t
Raw_context.t -> Signature.Public_key_hash.t -> Tez_repr.t -> Raw_context.t tzresult Lwt.t
val set_inactive : Raw_context.t -> Ed25519.Public_key_hash.t -> Raw_context.t tzresult Lwt.t
val set_inactive : Raw_context.t -> Signature.Public_key_hash.t -> Raw_context.t tzresult Lwt.t
val set_active : Raw_context.t -> Ed25519.Public_key_hash.t -> Raw_context.t tzresult Lwt.t
val set_active : Raw_context.t -> Signature.Public_key_hash.t -> Raw_context.t tzresult Lwt.t
end
@ -67,10 +67,10 @@ module Contract : sig
end
val delegate_pubkey:
Raw_context.t -> Ed25519.Public_key_hash.t ->
Ed25519.Public_key.t tzresult Lwt.t
Raw_context.t -> Signature.Public_key_hash.t ->
Signature.Public_key.t tzresult Lwt.t
(**/**)
val get_contract_delegate:
Raw_context.t -> Contract_repr.t -> Ed25519.Public_key_hash.t option tzresult Lwt.t
Raw_context.t -> Contract_repr.t -> Signature.Public_key_hash.t option tzresult Lwt.t

6
src/proto_alpha/lib_protocol/src/script_interpreter.ml
View File

@ -612,7 +612,7 @@ let rec interp
| Compare Nat_key, Item (a, Item (b, rest)) ->
gas_compare descr Script_int.compare Gas.Cost_of.compare_nat a b rest
| Compare Key_hash_key, Item (a, Item (b, rest)) ->
gas_compare descr Ed25519.Public_key_hash.compare
gas_compare descr Signature.Public_key_hash.compare
Gas.Cost_of.compare_key_hash a b rest
| Compare Timestamp_key, Item (a, Item (b, rest)) ->
gas_compare descr Script_timestamp.compare Gas.Cost_of.compare_timestamp a b rest
@ -766,10 +766,10 @@ let rec interp
let gas = Gas.consume gas Gas.Cost_of.check_signature in
Gas.check gas >>=? fun () ->
let message = MBytes.of_string message in
let res = Ed25519.check key signature message in
let res = Signature.check key signature message in
logged_return (Item (res, rest), gas, ctxt)
| Hash_key, Item (key, rest) ->
logged_return (Item (Ed25519.Public_key.hash key, rest), Gas.consume gas Gas.Cost_of.hash_key, ctxt)
logged_return (Item (Signature.Public_key.hash key, rest), Gas.consume gas Gas.Cost_of.hash_key, ctxt)
| H ty, Item (v, rest) ->
let gas = Gas.consume gas (Gas.Cost_of.hash v) in
Gas.check gas >>=? fun () ->

14
src/proto_alpha/lib_protocol/src/script_ir_translator.ml
View File

@ -353,7 +353,7 @@ let compare_comparable
| String_key -> Compare.String.compare x y
| Bool_key -> Compare.Bool.compare x y
| Tez_key -> Tez.compare x y
| Key_hash_key -> Ed25519.Public_key_hash.compare x y
| Key_hash_key -> Signature.Public_key_hash.compare x y
| Int_key ->
let res = (Script_int.compare x y) in
if Compare.Int.(res = 0) then 0
@ -576,14 +576,14 @@ let rec unparse_data
| Signature_t, s ->
let `Hex text =
MBytes.to_hex
(Data_encoding.Binary.to_bytes Ed25519.encoding s) in
(Data_encoding.Binary.to_bytes Signature.encoding s) in
String (-1, text)
| Tez_t, v ->
String (-1, Tez.to_string v)
| Key_t, k ->
String (-1, Ed25519.Public_key.to_b58check k)
String (-1, Signature.Public_key.to_b58check k)
| Key_hash_t, k ->
String (-1, Ed25519.Public_key_hash.to_b58check k)
String (-1, Signature.Public_key_hash.to_b58check k)
| Pair_t ((tl, _), (tr, _)), (l, r) ->
let l = unparse_data tl l in
let r = unparse_data tr r in
@ -1067,7 +1067,7 @@ let rec parse_data
| Key_t, String (_, s) ->
begin
try
return (Ed25519.Public_key.of_b58check_exn s)
return (Signature.Public_key.of_b58check_exn s)
with _ -> fail (error ())
end
| Key_t, expr ->
@ -1075,14 +1075,14 @@ let rec parse_data
| Key_hash_t, String (_, s) ->
begin
try
return (Ed25519.Public_key_hash.of_b58check_exn s)
return (Signature.Public_key_hash.of_b58check_exn s)
with _ -> fail (error ()) end
| Key_hash_t, expr ->
traced (fail (Invalid_kind (location expr, [ String_kind ], kind expr)))
(* Signatures *)
| Signature_t, String (_, s) -> begin try
match Data_encoding.Binary.of_bytes
Ed25519.encoding
Signature.encoding
(MBytes.of_hex (`Hex s)) with
| Some s -> return s
| None -> raise Not_found

38
src/proto_alpha/lib_protocol/src/storage.ml
View File

@ -103,7 +103,7 @@ module Contract = struct
module Delegate =
Indexed_context.Make_map
(struct let name = ["delegate"] end)
(Make_value(Ed25519.Public_key_hash))
(Make_value(Signature.Public_key_hash))
module Inactive_delegate =
Indexed_context.Make_set
@ -180,7 +180,7 @@ end
module Delegates =
Make_data_set_storage
(Make_subcontext(Raw_context)(struct let name = ["delegates"] end))
(Ed25519.Public_key_hash)
(Signature.Public_key_hash)
(** Rolls *)
@ -206,7 +206,7 @@ module Cycle = struct
type unrevealed_nonce = {
nonce_hash: Nonce_hash.t ;
delegate: Ed25519.Public_key_hash.t ;
delegate: Signature.Public_key_hash.t ;
deposit: Tez_repr.t ;
rewards: Tez_repr.t ;
fees: Tez_repr.t ;
@ -222,7 +222,7 @@ module Cycle = struct
case (Tag 0)
(tup5
Nonce_hash.encoding
Ed25519.Public_key_hash.encoding
Signature.Public_key_hash.encoding
Tez_repr.encoding
Tez_repr.encoding
Tez_repr.encoding)
@ -285,7 +285,7 @@ module Roll = struct
module Delegate_roll_list =
Wrap_indexed_data_storage(Contract.Roll_list)(struct
type t = Ed25519.Public_key_hash.t
type t = Signature.Public_key_hash.t
let wrap = Contract_repr.implicit_contract
let unwrap = Contract_repr.is_implicit
end)
@ -297,7 +297,7 @@ module Roll = struct
module Delegate_change =
Wrap_indexed_data_storage(Contract.Change)(struct
type t = Ed25519.Public_key_hash.t
type t = Signature.Public_key_hash.t
let wrap = Contract_repr.implicit_contract
let unwrap = Contract_repr.is_implicit
end)
@ -324,7 +324,7 @@ module Roll = struct
(Make_subcontext(Raw_context)(struct let name = ["owner"] end))
(Snapshoted_owner_index)
(Roll_repr.Index)
(Make_value(Ed25519.Public_key))
(Make_value(Signature.Public_key))
module Snapshot_for_cycle = Cycle.Roll_snapshot
module Last_for_snapshot = Cycle.Last_roll
@ -370,18 +370,18 @@ module Vote = struct
module Listings =
Make_indexed_data_storage
(Make_subcontext(Raw_context)(struct let name = ["listings"] end))
(Ed25519.Public_key_hash)
(Signature.Public_key_hash)
(Make_value(Int32))
module Proposals =
Make_data_set_storage
(Make_subcontext(Raw_context)(struct let name = ["proposals"] end))
(Pair(Protocol_hash)(Ed25519.Public_key_hash))
(Pair(Protocol_hash)(Signature.Public_key_hash))
module Ballots =
Make_indexed_data_storage
(Make_subcontext(Raw_context)(struct let name = ["ballots"] end))
(Ed25519.Public_key_hash)
(Signature.Public_key_hash)
(Make_value(struct
type t = Vote_repr.ballot
let encoding = Vote_repr.ballot_encoding
@ -395,7 +395,7 @@ module Seed = struct
type unrevealed_nonce = Cycle.unrevealed_nonce = {
nonce_hash: Nonce_hash.t ;
delegate: Ed25519.Public_key_hash.t ;
delegate: Signature.Public_key_hash.t ;
deposit: Tez_repr.t ;
rewards: Tez_repr.t ;
fees: Tez_repr.t ;
@ -446,10 +446,22 @@ let () =
Raw_context.register_resolvers
Ed25519.Public_key_hash.b58check_encoding
(fun ctxt p ->
let p = Contract_repr.Index.pkh_prefix p in
let p = Contract_repr.Index.pkh_prefix_ed25519 p in
Contract.Indexed_context.resolve ctxt p >|= fun l ->
List.map
(function
| Contract_repr.Implicit s -> s
| Contract_repr.Implicit (Ed25519 pkh) -> pkh
| Contract_repr.Implicit _ -> assert false
| Contract_repr.Originated _ -> assert false)
l) ;
Raw_context.register_resolvers
Secp256k1.Public_key_hash.b58check_encoding
(fun ctxt p ->
let p = Contract_repr.Index.pkh_prefix_secp256k1 p in
Contract.Indexed_context.resolve ctxt p >|= fun l ->
List.map
(function
| Contract_repr.Implicit (Secp256k1 pkh) -> pkh
| Contract_repr.Implicit _ -> assert false
| Contract_repr.Originated _ -> assert false)
l)

18
src/proto_alpha/lib_protocol/src/storage.mli
View File

@ -28,7 +28,7 @@ module Roll : sig
module Owner : Indexed_data_snapshotable_storage
with type key = Roll_repr.t
and type snapshot = (Cycle_repr.t * int)
and type value = Ed25519.Public_key.t
and type value = Signature.Public_key.t
and type t := Raw_context.t
val clear: Raw_context.t -> Raw_context.t Lwt.t
@ -48,7 +48,7 @@ module Roll : sig
(** Rolls associated to contracts, a linked list per contract *)
module Delegate_roll_list : Indexed_data_storage
with type key = Ed25519.Public_key_hash.t
with type key = Signature.Public_key_hash.t
and type value = Roll_repr.t
and type t := Raw_context.t
@ -60,7 +60,7 @@ module Roll : sig
(** The tez of a contract that are not assigned to rolls *)
module Delegate_change : Indexed_data_storage
with type key = Ed25519.Public_key_hash.t
with type key = Signature.Public_key_hash.t
and type value = Tez_repr.t
and type t := Raw_context.t
@ -126,7 +126,7 @@ module Contract : sig
(** The delegate of a contract, if any. *)
module Delegate : Indexed_data_storage
with type key = Contract_repr.t
and type value = Ed25519.Public_key_hash.t
and type value = Signature.Public_key_hash.t
and type t := Raw_context.t
module Delegated : Data_set_storage
@ -188,7 +188,7 @@ end
(** Set of all registered delegates. *)
module Delegates : Data_set_storage
with type t := Raw_context.t
and type elt = Ed25519.Public_key_hash.t
and type elt = Signature.Public_key_hash.t
(** Votes *)
@ -211,16 +211,16 @@ module Vote : sig
and type t := Raw_context.t
module Listings : Indexed_data_storage
with type key = Ed25519.Public_key_hash.t
with type key = Signature.Public_key_hash.t
and type value = int32 (* number of rolls for the key. *)
and type t := Raw_context.t
module Proposals : Data_set_storage
with type elt = Protocol_hash.t * Ed25519.Public_key_hash.t
with type elt = Protocol_hash.t * Signature.Public_key_hash.t
and type t := Raw_context.t
module Ballots : Indexed_data_storage
with type key = Ed25519.Public_key_hash.t
with type key = Signature.Public_key_hash.t
and type value = Vote_repr.ballot
and type t := Raw_context.t
@ -235,7 +235,7 @@ module Seed : sig
type unrevealed_nonce = {
nonce_hash: Nonce_hash.t ;
delegate: Ed25519.Public_key_hash.t ;
delegate: Signature.Public_key_hash.t ;
deposit: Tez_repr.t ;
rewards: Tez_repr.t ;
fees: Tez_repr.t ;

2
src/proto_alpha/lib_protocol/src/vote_storage.ml
View File

@ -51,7 +51,7 @@ let freeze_listings ctxt =
Roll_storage.fold ctxt (ctxt, 0l)
~f:(fun _roll delegate (ctxt, total) ->
(* TODO use snapshots *)
let delegate = Ed25519.Public_key.hash delegate in
let delegate = Signature.Public_key.hash delegate in
begin
Storage.Vote.Listings.get_option ctxt delegate >>=? function
| None -> return 0l

6
src/proto_alpha/lib_protocol/src/vote_storage.mli
View File

@ -8,7 +8,7 @@
(**************************************************************************)
val record_proposal:
Raw_context.t -> Protocol_hash.t -> Ed25519.Public_key_hash.t ->
Raw_context.t -> Protocol_hash.t -> Signature.Public_key_hash.t ->
Raw_context.t Lwt.t
val get_proposals:
@ -23,7 +23,7 @@ type ballots = {
}
val record_ballot:
Raw_context.t -> Ed25519.Public_key_hash.t -> Vote_repr.ballot ->
Raw_context.t -> Signature.Public_key_hash.t -> Vote_repr.ballot ->
Raw_context.t Lwt.t
val get_ballots: Raw_context.t -> ballots tzresult Lwt.t
val clear_ballots: Raw_context.t -> Raw_context.t Lwt.t
@ -33,7 +33,7 @@ val clear_listings: Raw_context.t -> Raw_context.t tzresult Lwt.t
val listing_size: Raw_context.t -> int32 tzresult Lwt.t
val in_listings:
Raw_context.t -> Ed25519.Public_key_hash.t -> bool Lwt.t
Raw_context.t -> Signature.Public_key_hash.t -> bool Lwt.t
val get_current_quorum: Raw_context.t -> int32 tzresult Lwt.t
val set_current_quorum: Raw_context.t -> int32 -> Raw_context.t tzresult Lwt.t

17
src/proto_alpha/lib_protocol/test/helpers/helpers_account.ml
View File

@ -12,9 +12,9 @@ open Proto_alpha.Error_monad
open Proto_alpha.Alpha_context
type account = {
hpub : Ed25519.Public_key_hash.t ;
pub : Ed25519.Public_key.t ;
ppk : Ed25519.Secret_key.t ;
hpub : Signature.Public_key_hash.t ;
pub : Signature.Public_key.t ;
ppk : Signature.Secret_key.t ;
contract : Contract.contract
}
type t = account
@ -39,11 +39,11 @@ let bootstrap_accounts =
"edskS7rLN2Df3nbS1EYvwJbWo4umD7yPM1SUeX7gp1WhCVpMFXjcC\
yM58xs6xsnTsVqHQmJQ2RxoAjJGedWfvFmjQy6etA3dgZ";
] in
let pubs = List.map Ed25519.Public_key.of_b58check_exn pubs in
let ppks = List.map Ed25519.Secret_key.of_b58check_exn ppks in
let pubs = List.map Signature.Public_key.of_b58check_exn pubs in
let ppks = List.map Signature.Secret_key.of_b58check_exn ppks in
let keys = List.combine pubs ppks in
let aux (pub, ppk) : account =
let hpub = Ed25519.Public_key.hash pub in {
let hpub = Signature.Public_key.hash pub in {
pub ;
ppk ;
hpub ;
@ -52,7 +52,7 @@ let bootstrap_accounts =
in List.map aux keys
let new_account () : account =
let (hpub, pub, ppk) = Ed25519.generate_key () in
let (hpub, pub, ppk) = Signature.generate_key () in
let contract = Contract.implicit_contract hpub in
{hpub ; pub ; ppk ; contract}
@ -96,11 +96,10 @@ let display_account ~tc account =
| Ok balance -> (
Helpers_logger.lwt_debug
"Account %a : (%a tz)"
Ed25519.Public_key_hash.pp account.hpub
Signature.Public_key_hash.pp account.hpub
Tez.pp balance
)| Error _ -> Helpers_logger.lwt_debug "Error in balance"
let display_accounts ~tc accounts =
Helpers_logger.lwt_debug "Got accounts" >>= fun () ->
Lwt_list.iter_s (display_account ~tc) accounts

6
src/proto_alpha/lib_protocol/test/helpers/helpers_account.mli
View File

@ -15,9 +15,9 @@ open Alpha_context
(** Explicit account type *)
type account = {
hpub : Ed25519.Public_key_hash.t;
pub : Ed25519.Public_key.t;
ppk : Ed25519.Secret_key.t;
hpub : Signature.Public_key_hash.t;
pub : Signature.Public_key.t;
ppk : Signature.Secret_key.t;
contract :
Contract.contract;
}

4
src/proto_alpha/lib_protocol/test/helpers/helpers_assert.ml
View File

@ -91,11 +91,11 @@ let equal_pkh ?msg pkh1 pkh2 =
match pkh1, pkh2 with
| None, None -> true
| Some pkh1, Some pkh2 ->
Ed25519.Public_key_hash.equal pkh1 pkh2
Signature.Public_key_hash.equal pkh1 pkh2
| _ -> false in
let prn = function
| None -> "none"
| Some pkh -> Ed25519.Public_key_hash.to_b58check pkh in
| Some pkh -> Signature.Public_key_hash.to_b58check pkh in
Assert.equal ?msg ~prn ~eq pkh1 pkh2
let equal_int64 ?msg =

5
src/proto_alpha/lib_protocol/test/helpers/helpers_assert.mli
View File

@ -57,8 +57,8 @@ exception No_error
val no_error : ?msg:string -> ('a, 'b) result -> 'a
val equal_pkh :
?msg:string -> Ed25519.Public_key_hash.t option ->
Ed25519.Public_key_hash.t option -> unit
?msg:string -> Signature.Public_key_hash.t option ->
Signature.Public_key_hash.t option -> unit
val equal_int64 : ?msg:string -> Int64.t -> Int64.t -> unit
val equal_int : ?msg:string -> int -> int -> unit
val equal_tez : ?msg:string -> Tez.t -> Tez.t -> unit
@ -87,4 +87,3 @@ val balance_too_low : msg:string -> 'a proto_tzresult -> unit
val non_spendable : msg:string -> 'a tzresult -> unit
val inconsistent_pkh : msg:string -> 'a tzresult -> unit
val non_delegatable : msg:string -> 'a tzresult -> unit

2
src/proto_alpha/lib_protocol/test/helpers/helpers_misc.ml
View File

@ -16,7 +16,7 @@ let no_ops_hash =
let find_account accounts hpub =
let hpub_pred (x : Helpers_account.t) =
Ed25519.Public_key_hash.equal x.hpub hpub in
Signature.Public_key_hash.equal x.hpub hpub in
List.find hpub_pred accounts
let read_file path =

3
src/proto_alpha/lib_protocol/test/helpers/helpers_misc.mli
View File

@ -14,7 +14,6 @@ exception Unknown_protocol
val no_ops_hash : Operation_list_list_hash.t
val find_account :
Helpers_account.t list -> Ed25519.Public_key_hash.t -> Helpers_account.t
Helpers_account.t list -> Signature.Public_key_hash.t -> Helpers_account.t
val read_file : string -> string

5
src/proto_alpha/lib_protocol/test/helpers/helpers_operation.ml
View File

@ -99,12 +99,12 @@ let sign src oph protop =
let signature_content = Operation.forge oph protop in
let signature = match src with
| None -> None
| Some(src: Helpers_account.t) -> Some (Ed25519.sign src.ppk signature_content) in
| Some(src: Helpers_account.t) -> Some (Signature.sign src.ppk signature_content) in
let open Data_encoding in
let signed_proto_operation_encoding =
Data_encoding.merge_objs
Operation.proto_operation_encoding
(obj1 @@ varopt "signature" Ed25519.encoding) in
(obj1 @@ varopt "signature" Signature.encoding) in
let proto_bytes =
Data_encoding.Binary.to_bytes
signed_proto_operation_encoding
@ -129,4 +129,3 @@ let apply_of_proto
contents = protocol_operation ;
signature
}

3
src/proto_alpha/lib_protocol/test/helpers/helpers_operation.mli
View File

@ -60,7 +60,7 @@ val endorsement_full :
val sign :
Helpers_account.t option -> Tezos_base.Operation.shell_header ->
proto_operation -> MBytes.t * Ed25519.t option
proto_operation -> MBytes.t * Signature.t option
val main_of_proto :
Helpers_account.t -> Tezos_base.Operation.shell_header ->
@ -69,4 +69,3 @@ val main_of_proto :
val apply_of_proto :
Helpers_account.t option -> Tezos_base.Operation.shell_header ->
proto_operation -> operation

2
src/proto_alpha/lib_protocol/test/main.ml
View File

@ -23,5 +23,5 @@ let () =
"origination", List.map wrap Test_origination.tests ;
"bigmaps", List.map wrap Test_big_maps.tests ;
"michelson", List.map wrap Test_michelson.tests ;
"activation", List.map wrap Test_activation.tests ;
(* "activation", List.map wrap Test_activation.tests ; *)
]

2
src/proto_alpha/lib_protocol/test/test_endorsement.ml
View File

@ -68,7 +68,7 @@ let test_endorsement_payment () =
Proto_alpha.Baking.check_baking_rights
result.tezos_context protocol_data root.tezos_header.shell.timestamp
>>=? fun baker_pub ->
let baker_hpub = Ed25519.Public_key.hash baker_pub in
let baker_hpub = Signature.Public_key.hash baker_pub in
let endorsement_security_deposit =
Constants.endorsement_security_deposit in
let baking = baker_hpub = contract_p.hpub && block_priority < 4 in

7
src/proto_alpha/lib_protocol/test/test_michelson.ml
View File

@ -388,7 +388,6 @@ let test_example () =
(* Did the given key sign the string? (key is bootstrap1) *)
test_output ~location: __LOC__ "check_signature" "(Pair \"26981d372a7b3866621bf79713d249197fe6d518ef702fa65738e1715bde9da54df04fefbcc84287ecaa9f74ad9296462731aa24bbcece63c6bf73a8f5752309\" \"hello\")" "\"edpkuBknW28nW72KG6RoHtYW7p12T6GKc7nAbwYX5m8Wd9sDVC9yav\"" "True" >>=? fun _ ->
test_output ~location: __LOC__ "check_signature" "(Pair \"26981d372a7b3866621bf79713d249197fe6d518ef702fa65738e1715bde9da54df04fefbcc84287ecaa9f74ad9296462731aa24bbcece63c6bf73a8f5752309\" \"abcd\")" "\"edpkuBknW28nW72KG6RoHtYW7p12T6GKc7nAbwYX5m8Wd9sDVC9yav\"" "False" >>=? fun _ ->
(* Convert a public key to a public key hash *)
@ -420,14 +419,14 @@ let test_example () =
(* Test TRANSFER_TO *)
Account.make_account ~tc: sb.tezos_context >>=?? fun (account, tc) ->
let account_str = quote @@ Ed25519.Public_key_hash.to_b58check account.hpub in
let account_str = quote @@ Signature.Public_key_hash.to_b58check account.hpub in
test_tc ~tc "transfer_to" "Unit" account_str >>=? fun tc ->
let amount = Account.init_amount + 100 in
Assert.equal_cents_balance ~tc (account.contract, amount * 100) >>=?? fun _ ->
(* Test CREATE_ACCOUNT *)
Account.make_account ~tc: sb.tezos_context >>=?? fun (account, tc) ->
let account_str = quote @@ Ed25519.Public_key_hash.to_b58check account.hpub in
let account_str = quote @@ Signature.Public_key_hash.to_b58check account.hpub in
test_contract ~tc "create_account" account_str account_str >>=? fun (cs, tc) ->
Assert.equal_int 1 @@ List.length cs ;
@ -442,7 +441,7 @@ let test_example () =
(* Test DEFAULT_ACCOUNT *)
let account = Account.new_account () in
let b_str = quote @@ Ed25519.Public_key_hash.to_b58check account.hpub in
let b_str = quote @@ Signature.Public_key_hash.to_b58check account.hpub in
test_contract ~tc "default_account" "Unit" b_str >>=? fun (_cs, tc) ->
Assert.equal_cents_balance ~tc (account.contract, 100 * 100) >>=?? fun _ ->
return ()

10
src/proto_genesis/lib_protocol/src/data.ml
View File

@ -65,7 +65,7 @@ module Command = struct
let open Data_encoding in
obj2
(req "content" encoding)
(req "signature" Ed25519.encoding)
(req "signature" Signature.encoding)
let forge shell command =
Data_encoding.Binary.to_bytes
@ -79,25 +79,25 @@ module Pubkey = struct
let pubkey_key = ["genesis_key"]
let default =
Ed25519.Public_key.of_b58check_exn
Signature.Public_key.of_b58check_exn
"edpkuEH8DSby4w167NpxYbMagBapWvM8jsqKJpiW3JpVD7Af8oGmEo"
let get_pubkey ctxt =
Context.get ctxt pubkey_key >>= function
| None -> Lwt.return default
| Some b ->
match Data_encoding.Binary.of_bytes Ed25519.Public_key.encoding b with
match Data_encoding.Binary.of_bytes Signature.Public_key.encoding b with
| None -> Lwt.return default
| Some pk -> Lwt.return pk
let set_pubkey ctxt v =
Context.set ctxt pubkey_key @@
Data_encoding.Binary.to_bytes Ed25519.Public_key.encoding v
Data_encoding.Binary.to_bytes Signature.Public_key.encoding v
let sandbox_encoding =
let open Data_encoding in
merge_objs
(obj1 (req "genesis_pubkey" Ed25519.Public_key.encoding))
(obj1 (req "genesis_pubkey" Signature.Public_key.encoding))
Data_encoding.unit
let may_change_default ctxt json =

6
src/proto_genesis/lib_protocol/src/main.ml
View File

@ -41,7 +41,7 @@ let validation_passes = []
type block = {
shell: Block_header.shell_header ;
command: Data.Command.t ;
signature: Ed25519.t ;
signature: Signature.t ;
}
let max_block_length =
@ -49,7 +49,7 @@ let max_block_length =
Data.Command.encoding
(Activate_testchain { protocol = Protocol_hash.zero ;
delay = 0L })
+ Ed25519.size
+ Signature.size
let parse_block { Block_header.shell ; protocol_data } : block tzresult =
match
@ -62,7 +62,7 @@ let check_signature ctxt { shell ; command ; signature } =
let bytes = Data.Command.forge shell command in
Data.Pubkey.get_pubkey ctxt >>= fun public_key ->
fail_unless
(Ed25519.check public_key signature bytes)
(Signature.check public_key signature bytes)
Invalid_signature
type validation_state = Updater.validation_result