Merge pull request #1224 from input-output-hk/owner_cert_jcli

Add owner stake deletagion cert creation tool to JCLI

Author: NicolasDP

doc/stake_pool/delegating_stake.md

@@ -2,10 +2,32 @@
 
 ## how to create the delegation certificate
 
-Stake is concentrated in accounts, and you will need your account public key to
-delegate its associated stake.
+Stake is concentrated in accounts, and you will need account public key to delegate its associated stake.
 
-You will need your:
+### for own account
+
+You will need:
+
+* the Stake Pool ID: an hexadecimal string identifying the stake pool you want
+  to delegate your stake to.
+
+```sh
+jcli certificate new owned-stake-delegation STAKE_POOL_ID > stake_delegation.cert
+```
+
+Note that the certificate is in blaco, there's no account key used for its creation.
+In order for delegation to work it must be submitted to a node inside a very specific transaction:
+
+* Transaction must have exactly 1 input
+* The input must be from account
+* The input value must be strictly equal to fee of the transaction
+* Transaction must have 0 outputs
+
+The account used for input will have its stake delegated to the stake pool
+
+### for any account
+
+You will need:
 
 * account public key: a bech32 string of a public key
 * the Stake Pool ID: an hexadecimal string identifying the stake pool you want

jcli/src/jcli_app/certificate/mod.rs

@@ -7,9 +7,11 @@ use std::path::{Path, PathBuf};
 use structopt::StructOpt;
 
 mod get_stake_pool_id;
+mod new_owner_stake_delegation;
 mod new_stake_delegation;
 mod new_stake_pool_registration;
 mod sign;
+mod weighted_pool_ids;
 
 pub(crate) use self::sign::{pool_owner_sign, stake_delegation_account_binding_sign};
 
@@ -73,6 +75,8 @@ pub enum NewArgs {
     StakePoolRegistration(new_stake_pool_registration::StakePoolRegistration),
     /// build a stake delegation certificate
     StakeDelegation(new_stake_delegation::StakeDelegation),
+    /// build an owner stake delegation certificate
+    OwnerStakeDelegation(new_owner_stake_delegation::OwnerStakeDelegation),
 }
 
 #[derive(StructOpt)]
@@ -98,6 +102,7 @@ impl NewArgs {
         match self {
             NewArgs::StakePoolRegistration(args) => args.exec()?,
             NewArgs::StakeDelegation(args) => args.exec()?,
+            NewArgs::OwnerStakeDelegation(args) => args.exec()?,
         }
         Ok(())
     }

jcli/src/jcli_app/certificate/new_owner_stake_delegation.rs

@@ -0,0 +1,29 @@
+use crate::jcli_app::certificate::{weighted_pool_ids::WeightedPoolIds, write_cert, Error};
+use chain_impl_mockchain::certificate::{Certificate, OwnerStakeDelegation as Delegation};
+use jormungandr_lib::interfaces::Certificate as CertificateType;
+use std::convert::TryInto;
+use std::ops::Deref;
+use std::path::PathBuf;
+use structopt::StructOpt;
+
+#[derive(StructOpt)]
+pub struct OwnerStakeDelegation {
+    #[structopt(flatten)]
+    pool_ids: WeightedPoolIds,
+
+    /// write the output to the given file or print it to the standard output if not defined
+    #[structopt(short = "o", long = "output")]
+    output: Option<PathBuf>,
+}
+
+impl OwnerStakeDelegation {
+    pub fn exec(self) -> Result<(), Error> {
+        let cert = Certificate::OwnerStakeDelegation(Delegation {
+            delegation: (&self.pool_ids).try_into()?,
+        });
+        write_cert(
+            self.output.as_ref().map(|x| x.deref()),
+            CertificateType(cert),
+        )
+    }
+}

jcli/src/jcli_app/certificate/new_stake_delegation.rs

@@ -1,16 +1,12 @@
-use crate::jcli_app::certificate::{write_cert, Error};
+use crate::jcli_app::certificate::{weighted_pool_ids::WeightedPoolIds, write_cert, Error};
 use crate::jcli_app::utils::key_parser::parse_pub_key;
-use chain_crypto::{Blake2b256, Ed25519, PublicKey};
-use chain_impl_mockchain::account::{DelegationRatio, DelegationType};
-use chain_impl_mockchain::accounting::account::DELEGATION_RATIO_MAX_DECLS;
+use chain_crypto::{Ed25519, PublicKey};
 use chain_impl_mockchain::certificate::{Certificate, StakeDelegation as Delegation};
 use chain_impl_mockchain::transaction::UnspecifiedAccountIdentifier;
 use jormungandr_lib::interfaces::Certificate as CertificateType;
-use std::convert::TryFrom;
-use std::error::Error as StdError;
+use std::convert::TryInto;
 use std::ops::Deref;
 use std::path::PathBuf;
-use std::str::FromStr;
 use structopt::StructOpt;
 
 #[derive(StructOpt)]
@@ -19,42 +15,19 @@ pub struct StakeDelegation {
     #[structopt(name = "STAKE_KEY", parse(try_from_str = "parse_pub_key"))]
     stake_id: PublicKey<Ed25519>,
 
-    /// hex-encoded stake pool IDs and their numeric weights in format "pool_id:weight".
-    /// If weight is not provided, it defaults to 1.
-    #[structopt(name = "STAKE_POOL_IDS", raw(required = "true"))]
-    pool_ids: Vec<WeightedPoolId>,
+    #[structopt(flatten)]
+    pool_ids: WeightedPoolIds,
 
     /// write the output to the given file or print it to the standard output if not defined
     #[structopt(short = "o", long = "output")]
     output: Option<PathBuf>,
 }
 
-struct WeightedPoolId {
-    pool_id: Blake2b256,
-    weight: u8,
-}
-
-impl FromStr for WeightedPoolId {
-    type Err = Box<dyn StdError>;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        let mut split = s.splitn(2, ':');
-        Ok(WeightedPoolId {
-            pool_id: split.next().unwrap().parse()?,
-            weight: split.next().map_or(Ok(1), str::parse)?,
-        })
-    }
-}
-
 impl StakeDelegation {
     pub fn exec(self) -> Result<(), Error> {
-        let delegation = match self.pool_ids.len() {
-            1 => DelegationType::Full(self.pool_ids[0].pool_id.into()),
-            _ => DelegationType::Ratio(delegation_ratio(&self.pool_ids)?),
-        };
         let content = Delegation {
             account_id: UnspecifiedAccountIdentifier::from_single_account(self.stake_id.into()),
-            delegation,
+            delegation: (&self.pool_ids).try_into()?,
         };
         let cert = Certificate::StakeDelegation(content);
         write_cert(
@@ -63,32 +36,3 @@ impl StakeDelegation {
         )
     }
 }
-
-fn delegation_ratio(pool_ids: &[WeightedPoolId]) -> Result<DelegationRatio, Error> {
-    if pool_ids.len() > DELEGATION_RATIO_MAX_DECLS {
-        return Err(Error::TooManyPoolDelegations {
-            actual: pool_ids.len(),
-            max: DELEGATION_RATIO_MAX_DECLS,
-        });
-    }
-    let parts = delegation_ratio_sum(pool_ids)?;
-    let pools = pool_ids
-        .iter()
-        .map(|pool_id| (pool_id.pool_id.into(), pool_id.weight))
-        .collect();
-    DelegationRatio::new(parts, pools).ok_or_else(|| Error::InvalidPoolDelegation)
-}
-
-fn delegation_ratio_sum(pool_ids: &[WeightedPoolId]) -> Result<u8, Error> {
-    let parts = pool_ids
-        .iter()
-        .map(|pool_id| match pool_id.weight {
-            0 => Err(Error::PoolDelegationWithZeroWeight),
-            weight => Ok(weight as u64),
-        })
-        .sum::<Result<_, _>>()?;
-    u8::try_from(parts).map_err(|_| Error::InvalidPoolDelegationWeights {
-        actual: parts,
-        max: u8::max_value() as u64,
-    })
-}

jcli/src/jcli_app/certificate/weighted_pool_ids.rs

@@ -0,0 +1,75 @@
+use crate::jcli_app::certificate::Error;
+use chain_crypto::Blake2b256;
+use chain_impl_mockchain::account::{DelegationRatio, DelegationType};
+use chain_impl_mockchain::accounting::account::DELEGATION_RATIO_MAX_DECLS;
+use std::convert::TryFrom;
+use std::error::Error as StdError;
+use std::str::FromStr;
+use structopt::StructOpt;
+
+#[derive(StructOpt)]
+pub struct WeightedPoolIds {
+    /// hex-encoded stake pool IDs and their numeric weights in format "pool_id:weight".
+    /// If weight is not provided, it defaults to 1.
+    #[structopt(name = "STAKE_POOL_IDS", raw(required = "true"))]
+    pool_ids: Vec<WeightedPoolId>,
+}
+
+struct WeightedPoolId {
+    pool_id: Blake2b256,
+    weight: u8,
+}
+
+impl<'a> TryFrom<&'a WeightedPoolIds> for DelegationType {
+    type Error = Error;
+
+    fn try_from(pool_ids: &'a WeightedPoolIds) -> Result<Self, Self::Error> {
+        let pool_ids = &pool_ids.pool_ids;
+        let delegation = match pool_ids.len() {
+            1 => DelegationType::Full(pool_ids[0].pool_id.into()),
+            _ => DelegationType::Ratio(delegation_ratio(pool_ids)?),
+        };
+        Ok(delegation)
+    }
+}
+
+fn delegation_ratio(pool_ids: &[WeightedPoolId]) -> Result<DelegationRatio, Error> {
+    if pool_ids.len() > DELEGATION_RATIO_MAX_DECLS {
+        return Err(Error::TooManyPoolDelegations {
+            actual: pool_ids.len(),
+            max: DELEGATION_RATIO_MAX_DECLS,
+        });
+    }
+    let parts = delegation_ratio_sum(pool_ids)?;
+    let pools = pool_ids
+        .iter()
+        .map(|pool_id| (pool_id.pool_id.into(), pool_id.weight))
+        .collect();
+    DelegationRatio::new(parts, pools).ok_or_else(|| Error::InvalidPoolDelegation)
+}
+
+fn delegation_ratio_sum(pool_ids: &[WeightedPoolId]) -> Result<u8, Error> {
+    let parts = pool_ids
+        .iter()
+        .map(|pool_id| match pool_id.weight {
+            0 => Err(Error::PoolDelegationWithZeroWeight),
+            weight => Ok(weight as u64),
+        })
+        .sum::<Result<_, _>>()?;
+    u8::try_from(parts).map_err(|_| Error::InvalidPoolDelegationWeights {
+        actual: parts,
+        max: u8::max_value() as u64,
+    })
+}
+
+impl FromStr for WeightedPoolId {
+    type Err = Box<dyn StdError>;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let mut split = s.splitn(2, ':');
+        Ok(WeightedPoolId {
+            pool_id: split.next().unwrap().parse()?,
+            weight: split.next().map_or(Ok(1), str::parse)?,
+        })
+    }
+}

jcli/src/jcli_app/transaction/add_certificate.rs

@@ -8,8 +8,7 @@ pub struct AddCertificate {
     #[structopt(flatten)]
     pub common: common::CommonTransaction,
 
-    /// the value
-    #[structopt(name = "VALUE", parse(try_from_str))]
+    /// bech32-encoded certificate
     pub certificate: Certificate,
 }
 

jcli/src/jcli_app/transaction/mod.rs

@@ -131,6 +131,11 @@ custom_error! { pub Error
     ExpectingOnlyOneSigningKey { got: usize }
         = "expecting only one signing keys but got {got}",
     CertificateError { error: certificate::Error } = "certificate error {error}",
+
+    TxWithOwnerStakeDelegationMultiInputs { inputs: usize }
+        = "transaction has owner stake delegation, but has {inputs} inputs, should have 1",
+    TxWithOwnerStakeDelegationHasUtxoInput = "transaction has owner stake delegation, but has UTxO input",
+    TxWithOwnerStakeDelegationHasOutputs = "transaction has owner stake delegation, but has outputs",
 }
 
 /*

jcli/src/jcli_app/transaction/staging.rs

@@ -192,7 +192,7 @@ impl Staging {
         payload: &P,
         fee_algorithm: &FA,
         output_policy: chain::transaction::OutputPolicy,
-    ) -> Result<chain::transaction::Balance, Error>
+    ) -> Result<Balance, Error>
     where
         FA: FeeAlgorithm,
         P: Payload,
@@ -215,7 +215,7 @@ impl Staging {
         &mut self,
         fee_algorithm: &FA,
         output_policy: chain::transaction::OutputPolicy,
-    ) -> Result<chain::transaction::Balance, Error>
+    ) -> Result<Balance, Error>
     where
         FA: FeeAlgorithm,
     {
@@ -241,7 +241,24 @@ impl Staging {
                     self.finalize_payload(&c, fee_algorithm, output_policy)
                 }
                 Certificate::OwnerStakeDelegation(c) => {
-                    self.finalize_payload(&c, fee_algorithm, output_policy)
+                    let balance = self.finalize_payload(&c, fee_algorithm, output_policy)?;
+                    match self.inputs() {
+                        [input] => match input.input {
+                            interfaces::TransactionInputType::Account(_) => (),
+                            interfaces::TransactionInputType::Utxo(_, _) => {
+                                return Err(Error::TxWithOwnerStakeDelegationHasUtxoInput)
+                            }
+                        },
+                        inputs @ _ => {
+                            return Err(Error::TxWithOwnerStakeDelegationMultiInputs {
+                                inputs: inputs.len(),
+                            })
+                        }
+                    };
+                    if self.outputs().is_empty() == false {
+                        return Err(Error::TxWithOwnerStakeDelegationHasOutputs);
+                    }
+                    Ok(balance)
                 }
             },
         }