feat: add client method to sign a transaction

canister/src/rpc_client/sol_rpc/mod.rs

@@ -13,8 +13,7 @@ use serde_json::{from_slice, Value};
 use sol_rpc_types::{PrioritizationFee, RoundingError};
 use solana_clock::Slot;
 use solana_transaction_status_client_types::TransactionStatus;
-use std::fmt::Debug;
-use std::num::NonZeroU8;
+use std::{fmt::Debug, num::NonZeroU8};
 
 /// Describes a payload transformation to execute before passing the HTTP response to consensus.
 /// The purpose of these transformations is to ensure that the response encoding is deterministic

end_to_end_tests/Cargo.toml

@@ -19,6 +19,7 @@ sol_rpc_types = { path = "../libs/types" }
 sol_rpc_int_tests = { path = "../integration_tests" }
 solana-commitment-config = { workspace = true }
 solana-hash = { workspace = true }
+solana-message = { workspace = true }
 solana-pubkey = { workspace = true }
 solana-signature = { workspace = true }
 solana-signer = { workspace = true }

end_to_end_tests/tests/end_to_end.rs

@@ -71,6 +71,7 @@ async fn should_send_transaction() {
         .expect("Block not found");
     let blockhash = Hash::from_str(&block.blockhash).expect("Failed to parse blockhash");
 
+    // TODO XC-317: Use tEDdSA
     let transaction = Transaction::new_signed_with_payer(
         &[set_cu_limit_ix, add_priority_fee_ix, transfer_ix],
         Some(&sender.pubkey()),

examples/basic_solana/Cargo.toml

@@ -19,7 +19,7 @@ ic-cdk = { workspace = true }
 ic-ed25519 = { workspace = true }
 num = { workspace = true }
 serde = { workspace = true, features = ["derive"] }
-sol_rpc_client = { path = "../../libs/client" }
+sol_rpc_client = { path = "../../libs/client", features = ["ed25519"] }
 sol_rpc_types = { path = "../../libs/types" }
 solana-account-decoder-client-types = { workspace = true }
 solana-hash = { workspace = true }
@@ -39,5 +39,5 @@ pocket-ic = { workspace = true }
 solana-client = { workspace = true }
 solana-commitment-config = { workspace = true }
 solana-keypair = { workspace = true }
-solana-rpc-client-nonce-utils = {workspace = true}
-solana-signer = {workspace = true}
+solana-rpc-client-nonce-utils = { workspace = true }
+solana-signer = { workspace = true }

examples/basic_solana/basic_solana.did

@@ -32,11 +32,11 @@ type CommitmentLevel = variant {
 
 type Ed25519KeyName = variant {
     // For local development with `dfx`.
-    TestKeyLocalDevelopment;
+    LocalDevelopment;
     // For testing with the Internet Computer's test key.
-    TestKey1;
+    MainnetTestKey1;
     // For running the canister in a production environment using the Internet Computer's production key.
-    ProductionKey1;
+    MainnetProdKey1;
 };
 
 // Atomic unit of SOL, i.e., 1 SOL = 10^9 Lamports

examples/basic_solana/src/ed25519.rs

@@ -1,25 +1,6 @@
 use crate::Ed25519KeyName;
-use ic_cdk::api::management_canister::schnorr::{
-    SchnorrAlgorithm, SchnorrKeyId, SchnorrPublicKeyArgument, SchnorrPublicKeyResponse,
-    SignWithSchnorrArgument, SignWithSchnorrResponse,
-};
 use ic_ed25519::PublicKey;
-
-#[derive(Clone, Debug, PartialEq, Eq, Default)]
-pub struct DerivationPath(Vec<Vec<u8>>);
-
-impl From<&[u8]> for DerivationPath {
-    fn from(bytes: &[u8]) -> Self {
-        const SCHEMA_V1: u8 = 1;
-        Self([vec![SCHEMA_V1], bytes.to_vec()].into_iter().collect())
-    }
-}
-
-impl From<&DerivationPath> for Vec<Vec<u8>> {
-    fn from(derivation_path: &DerivationPath) -> Self {
-        derivation_path.0.clone()
-    }
-}
+use sol_rpc_client::{ed25519::DerivationPath, IcRuntime};
 
 #[derive(Clone, Debug, PartialEq, Eq)]
 pub struct Ed25519ExtendedPublicKey {
@@ -28,7 +9,7 @@ pub struct Ed25519ExtendedPublicKey {
 }
 
 impl Ed25519ExtendedPublicKey {
-    pub fn derive_public_key(&self, derivation_path: &DerivationPath) -> Ed25519ExtendedPublicKey {
+    pub fn derive_public_key(&self, derivation_path: DerivationPath) -> Ed25519ExtendedPublicKey {
         let derivation_path = ic_ed25519::DerivationPath::new(
             <Vec<Vec<u8>>>::from(derivation_path)
                 .into_iter()
@@ -45,59 +26,20 @@ impl Ed25519ExtendedPublicKey {
     }
 }
 
-impl From<SchnorrPublicKeyResponse> for Ed25519ExtendedPublicKey {
-    fn from(value: SchnorrPublicKeyResponse) -> Self {
-        Ed25519ExtendedPublicKey {
-            public_key: PublicKey::deserialize_raw(value.public_key.as_slice()).unwrap(),
-            chain_code: <[u8; 32]>::try_from(value.chain_code).unwrap(),
-        }
-    }
-}
-
 pub async fn get_ed25519_public_key(
-    key_name: &Ed25519KeyName,
+    key_name: Ed25519KeyName,
     derivation_path: &DerivationPath,
 ) -> Ed25519ExtendedPublicKey {
-    let (response,): (SchnorrPublicKeyResponse,) =
-        ic_cdk::api::management_canister::schnorr::schnorr_public_key(SchnorrPublicKeyArgument {
-            canister_id: None,
-            derivation_path: derivation_path.into(),
-            key_id: SchnorrKeyId {
-                algorithm: SchnorrAlgorithm::Ed25519,
-                name: key_name.to_string(),
-            },
-        })
-        .await
-        .unwrap_or_else(|(error_code, message)| {
-            ic_cdk::trap(&format!(
-                "failed to get canister's public key: {} (error code = {:?})",
-                message, error_code,
-            ))
-        });
-    Ed25519ExtendedPublicKey::from(response)
-}
-
-pub async fn sign_with_ed25519(
-    message: Vec<u8>,
-    derivation_path: &DerivationPath,
-    key_name: &Ed25519KeyName,
-) -> [u8; 64] {
-    let (response,): (SignWithSchnorrResponse,) =
-        ic_cdk::api::management_canister::schnorr::sign_with_schnorr(SignWithSchnorrArgument {
-            message,
-            derivation_path: derivation_path.into(),
-            key_id: SchnorrKeyId {
-                algorithm: SchnorrAlgorithm::Ed25519,
-                name: key_name.to_string(),
-            },
-        })
-        .await
-        .expect("failed to sign with ed25519");
-    let signature_length = response.signature.len();
-    <[u8; 64]>::try_from(response.signature).unwrap_or_else(|_| {
-        panic!(
-            "BUG: invalid signature from management canister. Expected 64 bytes but got {} bytes",
-            signature_length
-        )
-    })
+    let (pubkey, chain_code) = sol_rpc_client::ed25519::get_pubkey(
+        &IcRuntime,
+        None,
+        Some(derivation_path),
+        key_name.into(),
+    )
+    .await
+    .expect("Failed to fetch EdDSA public key");
+    Ed25519ExtendedPublicKey {
+        public_key: PublicKey::deserialize_raw(&pubkey.to_bytes()).unwrap(),
+        chain_code,
+    }
 }

examples/basic_solana/src/lib.rs

@@ -5,10 +5,10 @@ pub mod state;
 
 use crate::state::{read_state, State};
 use candid::{CandidType, Deserialize, Principal};
-use sol_rpc_client::{IcRuntime, SolRpcClient};
+use sol_rpc_client::{ed25519::Ed25519KeyId, IcRuntime, SolRpcClient};
 use sol_rpc_types::{CommitmentLevel, MultiRpcResult, RpcSources, SolanaCluster};
 use solana_hash::Hash;
-use std::{fmt::Display, str::FromStr};
+use std::str::FromStr;
 
 // Fetch a recent blockhash using the Solana `getSlot` and `getBlock` methods.
 // Since the `getSlot` method might fail due to Solana's fast blocktime, and some slots do not
@@ -93,20 +93,18 @@ impl From<SolanaNetwork> for SolanaCluster {
 #[derive(CandidType, Deserialize, Debug, Default, PartialEq, Eq, Clone, Copy)]
 pub enum Ed25519KeyName {
     #[default]
-    TestKeyLocalDevelopment,
-    TestKey1,
-    ProductionKey1,
+    LocalDevelopment,
+    MainnetTestKey1,
+    MainnetProdKey1,
 }
 
-impl Display for Ed25519KeyName {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        let str = match self {
-            Ed25519KeyName::TestKeyLocalDevelopment => "dfx_test_key",
-            Ed25519KeyName::TestKey1 => "test_key_1",
-            Ed25519KeyName::ProductionKey1 => "key_1",
+impl From<Ed25519KeyName> for Ed25519KeyId {
+    fn from(key_id: Ed25519KeyName) -> Self {
+        match key_id {
+            Ed25519KeyName::LocalDevelopment => Self::LocalDevelopment,
+            Ed25519KeyName::MainnetTestKey1 => Self::MainnetTestKey1,
+            Ed25519KeyName::MainnetProdKey1 => Self::MainnetProdKey1,
         }
-        .to_string();
-        write!(f, "{}", str)
     }
 }
 

examples/basic_solana/src/main.rs

@@ -156,9 +156,10 @@ pub async fn create_nonce_account(owner: Option<Principal>) -> String {
     );
 
     let signatures = vec![
-        wallet.sign_with_ed25519(&message, &payer).await,
-        wallet.sign_with_ed25519(&message, &nonce_account).await,
+        payer.sign_message(&message).await,
+        nonce_account.sign_message(&message).await,
     ];
+
     let transaction = Transaction {
         message,
         signatures,
@@ -212,7 +213,7 @@ pub async fn create_associated_token_account(
         &get_recent_blockhash(&client).await,
     );
 
-    let signatures = vec![wallet.sign_with_ed25519(&message, &payer).await];
+    let signatures = vec![payer.sign_message(&message).await];
     let transaction = Transaction {
         message,
         signatures,
@@ -251,7 +252,7 @@ pub async fn send_sol(owner: Option<Principal>, to: String, amount: Nat) -> Stri
         Some(payer.as_ref()),
         &get_recent_blockhash(&client).await,
     );
-    let signatures = vec![wallet.sign_with_ed25519(&message, &payer).await];
+    let signatures = vec![payer.sign_message(&message).await];
     let transaction = Transaction {
         message,
         signatures,
@@ -290,7 +291,7 @@ pub async fn send_sol_with_durable_nonce(
     let blockhash = Hash::from(get_nonce(Some(nonce_account.as_ref().into())).await);
 
     let message = Message::new_with_blockhash(instructions, Some(payer.as_ref()), &blockhash);
-    let signatures = vec![wallet.sign_with_ed25519(&message, &payer).await];
+    let signatures = vec![payer.sign_message(&message).await];
     let transaction = Transaction {
         message,
         signatures,
@@ -332,7 +333,7 @@ pub async fn send_spl_token(
         Some(payer.as_ref()),
         &get_recent_blockhash(&client).await,
     );
-    let signatures = vec![wallet.sign_with_ed25519(&message, &payer).await];
+    let signatures = vec![payer.sign_message(&message).await];
     let transaction = Transaction {
         message,
         signatures,

examples/basic_solana/src/solana_wallet.rs

@@ -5,10 +5,14 @@
 //! such as error handling, access-control, caching, etc.
 
 use crate::{
-    ed25519::{sign_with_ed25519, DerivationPath, Ed25519ExtendedPublicKey},
+    ed25519::Ed25519ExtendedPublicKey,
     state::{lazy_call_ed25519_public_key, read_state},
 };
 use candid::Principal;
+use sol_rpc_client::{
+    ed25519::{sign_message, DerivationPath},
+    IcRuntime,
+};
 use solana_message::Message;
 use solana_pubkey::Pubkey;
 use solana_signature::Signature;
@@ -26,7 +30,7 @@ impl SolanaAccount {
         derivation_path: DerivationPath,
     ) -> Self {
         let ed25519_public_key = root_public_key
-            .derive_public_key(&derivation_path)
+            .derive_public_key(derivation_path.clone())
             .public_key
             .serialize_raw()
             .into();
@@ -35,6 +39,17 @@ impl SolanaAccount {
             derivation_path,
         }
     }
+
+    pub async fn sign_message(&self, message: &Message) -> Signature {
+        sign_message(
+            &IcRuntime,
+            message,
+            read_state(|s| s.ed25519_key_name()).into(),
+            Some(&self.derivation_path),
+        )
+        .await
+        .expect("Failed to sign transaction")
+    }
 }
 
 impl AsRef<Pubkey> for SolanaAccount {
@@ -84,11 +99,4 @@ impl SolanaWallet {
                 .into(),
         )
     }
-
-    pub async fn sign_with_ed25519(&self, message: &Message, signer: &SolanaAccount) -> Signature {
-        let message = message.serialize();
-        let derivation_path = &signer.derivation_path;
-        let key_name = &read_state(|s| s.ed25519_key_name());
-        Signature::from(sign_with_ed25519(message, derivation_path, key_name).await)
-    }
 }

examples/basic_solana/src/state.rs

@@ -72,7 +72,7 @@ pub async fn lazy_call_ed25519_public_key() -> Ed25519ExtendedPublicKey {
         return public_key;
     }
     let public_key =
-        get_ed25519_public_key(&read_state(|s| s.ed25519_key_name()), &Default::default()).await;
+        get_ed25519_public_key(read_state(|s| s.ed25519_key_name()), &Default::default()).await;
     mutate_state(|s| s.ed25519_public_key = Some(public_key.clone()));
     public_key
 }

examples/basic_solana/tests/tests.rs

@@ -292,7 +292,7 @@ impl Setup {
         let basic_solana_install_args = basic_solana::InitArg {
             sol_rpc_canister_id: Some(sol_rpc_canister_id),
             solana_network: Some(SolanaNetwork::Devnet),
-            ed25519_key_name: Some(Ed25519KeyName::ProductionKey1),
+            ed25519_key_name: Some(Ed25519KeyName::MainnetProdKey1),
             solana_commitment_level: Some(CommitmentLevel::Confirmed),
         };
         env.install_canister(

integration_tests/tests/solana_test_validator.rs

@@ -33,10 +33,10 @@ use solana_signature::Signature;
 use solana_signer::Signer;
 use solana_transaction::Transaction;
 use solana_transaction_status_client_types::UiTransactionEncoding;
-use std::num::NonZeroU8;
 use std::{
     future::Future,
     iter::zip,
+    num::NonZeroU8,
     str::FromStr,
     thread,
     thread::sleep,