From 7d61400ff30defec4f3e10c35f9dd5469ed41f4a Mon Sep 17 00:00:00 2001 From: optout <13562139+optout21@users.noreply.github.com> Date: Wed, 17 Dec 2025 09:04:31 +0100 Subject: [PATCH 1/3] Rename, remove _intern from public methods --- lib-py/src/lib.rs | 30 +++++++++++++++--------------- src/lib.rs | 38 +++++++++++++++++++------------------- src/test_lib.rs | 38 +++++++++++++++++++------------------- 3 files changed, 53 insertions(+), 53 deletions(-) diff --git a/lib-py/src/lib.rs b/lib-py/src/lib.rs index 9062261..63767fe 100644 --- a/lib-py/src/lib.rs +++ b/lib-py/src/lib.rs @@ -10,7 +10,7 @@ use pyo3::wrap_pyfunction; /// Initialize the library, load secret from encrypted file. Return the XPUB. #[pyfunction] pub fn init(path_for_secret_file: String, encryption_password: String) -> PyResult { - dlccryptlib::init_intern(&path_for_secret_file, &encryption_password, false) + dlccryptlib::init(&path_for_secret_file, &encryption_password, false) .map_err(|e| PyErr::new::(e)) } @@ -19,7 +19,7 @@ pub fn reinit_for_testing( path_for_secret_file: String, encryption_password: String, ) -> PyResult { - dlccryptlib::init_intern(&path_for_secret_file, &encryption_password, true) + dlccryptlib::init(&path_for_secret_file, &encryption_password, true) .map_err(|e| PyErr::new::(e)) } @@ -27,37 +27,37 @@ pub fn reinit_for_testing( // #[cfg(test)] #[pyfunction] pub fn init_with_entropy(entropy: String, network: String) -> PyResult { - dlccryptlib::init_with_entropy_intern(&entropy, &network).map_err(|e| PyErr::new::(e)) + dlccryptlib::init_with_entropy(&entropy, &network).map_err(|e| PyErr::new::(e)) } /// Return the XPUB #[pyfunction] pub fn get_xpub() -> PyResult { - dlccryptlib::get_xpub_intern().map_err(|e| PyErr::new::(e)) + dlccryptlib::get_xpub().map_err(|e| PyErr::new::(e)) } /// Return a child public key (specified by its index). #[pyfunction] pub fn get_public_key(index: u32) -> PyResult { - dlccryptlib::get_public_key_intern(index).map_err(|e| PyErr::new::(e)) + dlccryptlib::get_public_key(index).map_err(|e| PyErr::new::(e)) } /// Return a child address (specified by index). #[pyfunction] pub fn get_address(index: u32) -> PyResult { - dlccryptlib::get_address_intern(index).map_err(|e| PyErr::new::(e)) + dlccryptlib::get_address(index).map_err(|e| PyErr::new::(e)) } /// Verify a child public key. #[pyfunction] pub fn verify_public_key(index: u32, pubkey: String) -> PyResult { - dlccryptlib::verify_public_key_intern(index, &pubkey).map_err(|e| PyErr::new::(e)) + dlccryptlib::verify_public_key(index, &pubkey).map_err(|e| PyErr::new::(e)) } /// Sign a hash with a child private key (specified by index). #[pyfunction] pub fn sign_hash_ecdsa(hash: String, signer_index: u32, signer_pubkey: String) -> PyResult { - dlccryptlib::sign_hash_ecdsa_intern(&hash, signer_index, &signer_pubkey) + dlccryptlib::sign_hash_ecdsa(&hash, signer_index, &signer_pubkey) .map_err(|e| PyErr::new::(e)) } @@ -67,28 +67,28 @@ pub fn create_deterministic_nonce( event_id: String, nonce_index: u32, ) -> PyResult<(String, String)> { - dlccryptlib::create_deterministic_nonce_intern(&event_id, nonce_index) + dlccryptlib::create_deterministic_nonce(&event_id, nonce_index) .map_err(|e| PyErr::new::(e)) } /// Sign a message using Schnorr, with a nonce, using a child key #[pyfunction] pub fn sign_schnorr_with_nonce(msg: String, nonce_sec_hex: String, index: u32) -> PyResult { - dlccryptlib::sign_schnorr_with_nonce_intern(&msg, &nonce_sec_hex, index) + dlccryptlib::sign_schnorr_with_nonce(&msg, &nonce_sec_hex, index) .map_err(|e| PyErr::new::(e)) } /// Combine a number of public keys into one #[pyfunction] pub fn combine_pubkeys(keys_hex: String) -> PyResult { - dlccryptlib::combine_pubkeys_intern(&keys_hex).map_err(|e| PyErr::new::(e)) + dlccryptlib::combine_pubkeys(&keys_hex).map_err(|e| PyErr::new::(e)) } /// Combine a number of secret keys into one. /// Warning: Handle secret keys with caution! #[pyfunction] pub fn combine_seckeys(keys_hex: String) -> PyResult { - dlccryptlib::combine_seckeys_intern(&keys_hex).map_err(|e| PyErr::new::(e)) + dlccryptlib::combine_seckeys(&keys_hex).map_err(|e| PyErr::new::(e)) } /// Create adaptor signatures for a number of CETs @@ -104,7 +104,7 @@ pub fn create_cet_adaptor_sigs( interval_wildcards: String, sighashes: String, ) -> PyResult { - dlccryptlib::create_cet_adaptor_sigs_intern( + dlccryptlib::create_cet_adaptor_sigs( num_digits, num_cets, &digit_string_template, @@ -131,7 +131,7 @@ pub fn verify_cet_adaptor_sigs( sighashes: String, signatures: String, ) -> PyResult { - dlccryptlib::verify_cet_adaptor_sigs_intern( + dlccryptlib::verify_cet_adaptor_sigs( num_digits, num_cets, &digit_string_template, @@ -157,7 +157,7 @@ pub fn create_final_cet_sigs( cet_sighash: String, other_adaptor_signature: String, ) -> PyResult { - dlccryptlib::create_final_cet_sigs_intern( + dlccryptlib::create_final_cet_sigs( signing_key_index, &signing_pubkey, &other_pubkey, diff --git a/src/lib.rs b/src/lib.rs index 7bfc2f8..e096059 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -27,7 +27,7 @@ use std::os::raw::c_char; use std::str::FromStr; /// Initialize the library, load secret from encrypted file. Return the XPUB. -pub fn init_intern( +pub fn init( path_for_secret_file: &str, encryption_password: &str, allow_reinit: bool, @@ -43,7 +43,7 @@ pub fn init_intern( /// Initialize the library, provide the secret as parameter. Return the XPUB. // #[cfg(test)] -pub fn init_with_entropy_intern(entropy: &str, network: &str) -> Result { +pub fn init_with_entropy(entropy: &str, network: &str) -> Result { let entropy_bin = parse_entropy_hex(entropy)?; global_lib() .write() @@ -53,22 +53,22 @@ pub fn init_with_entropy_intern(entropy: &str, network: &str) -> Result Result { +pub fn get_xpub() -> Result { let xpub = global_lib().read().unwrap().get_xpub()?; Ok(xpub.to_string()) } -pub fn get_public_key_intern(index: u32) -> Result { +pub fn get_public_key(index: u32) -> Result { let pubkey = global_lib().read().unwrap().get_child_public_key(index)?; Ok(pubkey.to_string()) } -pub fn get_address_intern(index: u32) -> Result { +pub fn get_address(index: u32) -> Result { let address = global_lib().read().unwrap().get_address(index)?; Ok(address.to_string()) } -pub fn verify_public_key_intern(index: u32, pubkey_str: &str) -> Result { +pub fn verify_public_key(index: u32, pubkey_str: &str) -> Result { let pubkey = pubkey_from_hex(pubkey_str).map_err(|e| format!("Failed to parse pubkey {}", e))?; let verify_result = global_lib() @@ -78,7 +78,7 @@ pub fn verify_public_key_intern(index: u32, pubkey_str: &str) -> Result Result<(String, String), String> { @@ -106,7 +106,7 @@ pub fn create_deterministic_nonce_intern( } // Schnorr signing with nonce -pub fn sign_schnorr_with_nonce_intern( +pub fn sign_schnorr_with_nonce( msg: &str, nonce_sec_hex: &str, index: u32, @@ -120,7 +120,7 @@ pub fn sign_schnorr_with_nonce_intern( Ok(sig.to_string()) } -pub fn combine_pubkeys_intern(keys_hex: &str) -> Result { +pub fn combine_pubkeys(keys_hex: &str) -> Result { let keys_split: Vec<_> = keys_hex.split(" ").collect(); let mut keys = Vec::::with_capacity(keys_split.len()); for i in 0..keys_split.len() { @@ -135,7 +135,7 @@ pub fn combine_pubkeys_intern(keys_hex: &str) -> Result { Ok(combined_key.to_string()) } -pub fn combine_seckeys_intern(keys_hex: &str) -> Result { +pub fn combine_seckeys(keys_hex: &str) -> Result { let keys_split: Vec<_> = keys_hex.split(" ").collect(); let mut keys = Vec::::with_capacity(keys_split.len()); for i in 0..keys_split.len() { @@ -150,7 +150,7 @@ pub fn combine_seckeys_intern(keys_hex: &str) -> Result { Ok(combined_key.display_secret().to_string()) } -pub fn create_cet_adaptor_sigs_intern( +pub fn create_cet_adaptor_sigs( num_digits: u8, num_cets: u64, digit_string_template: &str, @@ -239,7 +239,7 @@ pub fn create_cet_adaptor_sigs_intern( Ok(sigs_str) } -pub fn verify_cet_adaptor_sigs_intern( +pub fn verify_cet_adaptor_sigs( num_digits: u8, num_cets: u64, digit_string_template: &str, @@ -339,7 +339,7 @@ pub fn verify_cet_adaptor_sigs_intern( Ok(res.is_ok()) } -pub fn create_final_cet_sigs_intern( +pub fn create_final_cet_sigs( signing_key_index: u32, signing_pubkey_str: &str, other_pubkey_str: &str, @@ -419,7 +419,7 @@ pub extern "C" fn init_with_entropy_c( .unwrap_or("Error in network parameter") }; - match init_with_entropy_intern(entropy_str, network_str) { + match init_with_entropy(entropy_str, network_str) { Ok(xpub) => { // Return as a C string CString::new(xpub).unwrap().into_raw() @@ -431,7 +431,7 @@ pub extern "C" fn init_with_entropy_c( /// Return a child public key (specified by its index). #[no_mangle] pub extern "C" fn get_public_key_c(index: u32) -> *mut c_char { - match get_public_key_intern(index) { + match get_public_key(index) { Ok(pubkey) => { // Return as a C string CString::new(pubkey).unwrap().into_raw() @@ -459,7 +459,7 @@ pub extern "C" fn sign_hash_ecdsa_c( .unwrap_or("Error in signer_pubkey parameter") }; - match sign_hash_ecdsa_intern(hash_str, signer_index, signer_pubkey_str) { + match sign_hash_ecdsa(hash_str, signer_index, signer_pubkey_str) { Ok(sig) => { // Return as a C string CString::new(sig).unwrap().into_raw() @@ -513,7 +513,7 @@ pub extern "C" fn create_cet_adaptor_sigs_c( .unwrap_or("Error in sighashes parameter") }; - match create_cet_adaptor_sigs_intern( + match create_cet_adaptor_sigs( num_digits, num_cets as u64, digit_string_template_str, @@ -542,7 +542,7 @@ pub extern "C" fn create_deterministic_nonce_c(event_id: *const c_char, index: u }; // Call your existing function that creates the nonce (assuming this is what you want) - match create_deterministic_nonce_intern(event_id_str, index) { + match create_deterministic_nonce(event_id_str, index) { Ok((sk, pk)) => { // Return as a C string CString::new(format!("{} {}", sk, pk)).unwrap().into_raw() diff --git a/src/test_lib.rs b/src/test_lib.rs index ca09689..f1c634e 100644 --- a/src/test_lib.rs +++ b/src/test_lib.rs @@ -4,9 +4,9 @@ use crate::adaptor_signature::verify_ecdsa_signature; use crate::{ - combine_pubkeys_intern, combine_seckeys_intern, create_deterministic_nonce_intern, - get_public_key_intern, init_with_entropy_intern, keypair_from_sec_key_hex, - sign_schnorr_with_nonce_intern, verify_public_key_intern, Lib, + combine_pubkeys, combine_seckeys, create_deterministic_nonce, + get_public_key, init_with_entropy, keypair_from_sec_key_hex, + sign_schnorr_with_nonce, verify_public_key, Lib, }; use bitcoin::hex::FromHex; use bitcoin::secp256k1::PublicKey; @@ -54,15 +54,15 @@ fn test_init_with_entropy_lib_mainnet() { #[test] fn test_get_public_key() { - let _xpub = init_with_entropy_intern(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); + let _xpub = init_with_entropy(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); - let pubkey0 = get_public_key_intern(0).unwrap(); + let pubkey0 = get_public_key(0).unwrap(); assert_eq!( pubkey0.to_string(), "0298720ece754e377af1b2716256e63c2e2427ff6ebdc66c2071c43ae80132ca32" ); - let pubkey3 = get_public_key_intern(3).unwrap(); + let pubkey3 = get_public_key(3).unwrap(); assert_eq!( pubkey3.to_string(), "03b74dc470965932fc976459096526b08a0f939a95e4b72db8f9aadce18a08a72e" @@ -71,21 +71,21 @@ fn test_get_public_key() { #[test] fn test_verify_public_key() { - let _xpub = init_with_entropy_intern(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); + let _xpub = init_with_entropy(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); - assert!(verify_public_key_intern( + assert!(verify_public_key( 0, "0298720ece754e377af1b2716256e63c2e2427ff6ebdc66c2071c43ae80132ca32" ) .unwrap()); - assert_eq!(verify_public_key_intern(0, "03b74dc470965932fc976459096526b08a0f939a95e4b72db8f9aadce18a08a72e").err().unwrap(), + assert_eq!(verify_public_key(0, "03b74dc470965932fc976459096526b08a0f939a95e4b72db8f9aadce18a08a72e").err().unwrap(), "Pubkey mismatch, index 0, 03b74dc470965932fc976459096526b08a0f939a95e4b72db8f9aadce18a08a72e vs. 0298720ece754e377af1b2716256e63c2e2427ff6ebdc66c2071c43ae80132ca32"); - assert!(verify_public_key_intern( + assert!(verify_public_key( 3, "03b74dc470965932fc976459096526b08a0f939a95e4b72db8f9aadce18a08a72e" ) .unwrap()); - assert_eq!(verify_public_key_intern(3, "0298720ece754e377af1b2716256e63c2e2427ff6ebdc66c2071c43ae80132ca32").err().unwrap(), + assert_eq!(verify_public_key(3, "0298720ece754e377af1b2716256e63c2e2427ff6ebdc66c2071c43ae80132ca32").err().unwrap(), "Pubkey mismatch, index 3, 0298720ece754e377af1b2716256e63c2e2427ff6ebdc66c2071c43ae80132ca32 vs. 03b74dc470965932fc976459096526b08a0f939a95e4b72db8f9aadce18a08a72e"); } @@ -115,33 +115,33 @@ fn test_sign_hash_ecdsa() { #[test] fn test_create_deterministic_nonce() { - let (sk1, pk1) = create_deterministic_nonce_intern("event01", 0).unwrap(); + let (sk1, pk1) = create_deterministic_nonce("event01", 0).unwrap(); assert_eq!(sk1.len(), 64); assert_eq!(pk1.len(), 66); assert_ne!(sk1, pk1); - let (sk2, pk2) = create_deterministic_nonce_intern("event01", 1).unwrap(); + let (sk2, pk2) = create_deterministic_nonce("event01", 1).unwrap(); assert_ne!(sk1, sk2); assert_ne!(pk1, pk2); } #[test] fn test_sign_schnorr_with_nonce() { - let _xpub = init_with_entropy_intern(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); + let _xpub = init_with_entropy(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); let msg = "This is a message"; let nonce = "0123450000000000006897528962743076432965432697856340567500000100"; - let sig = sign_schnorr_with_nonce_intern(msg, nonce, 0).unwrap(); + let sig = sign_schnorr_with_nonce(msg, nonce, 0).unwrap(); let expected_sig = "ff4cb99e0a9be8ec7dea1e51904cf22f71717c19fc3e7dcbc8346eb28bebffbb892c4c41e05c2383efda00f5acc9c7f3622d88a90630cd62d49db598c8ce10b9"; assert_eq!(sig.len(), 128); assert_eq!(sig.to_string(), expected_sig); // sign again - let sig2 = sign_schnorr_with_nonce_intern(msg, nonce, 0).unwrap(); + let sig2 = sign_schnorr_with_nonce(msg, nonce, 0).unwrap(); assert_eq!(sig2.to_string(), expected_sig); // sign with different nonce let nonce2 = "0123450000000000006897528962743076432965432697856340567500000199"; - let sig3 = sign_schnorr_with_nonce_intern(msg, nonce2, 0).unwrap(); + let sig3 = sign_schnorr_with_nonce(msg, nonce2, 0).unwrap(); assert_eq!(sig3.to_string(), "4578740620e7a2c56eabea07c835dba35e832115930d023d0a7778652fbbf7d97a9f4a207dcb1456f1b0f57c4856085c32c79f4efce81cd276c272190aab5e3c"); } @@ -161,7 +161,7 @@ fn test_combine_pubkeys() { for i in 0..3 { input_str += &(create_dummy_pubkey(i).to_string() + " "); } - let combined = combine_pubkeys_intern(&input_str).unwrap(); + let combined = combine_pubkeys(&input_str).unwrap(); assert_eq!( combined, "030d7a38fb6eab9933efd3149f7ce0c466e93eb0680442856acb664719b60ae977" @@ -173,7 +173,7 @@ fn test_combine_seckeys() { let input_str = "0123450000000000006897528962743076432965432697856340567500000100 \ 0123450000000000006897528962743076432965432697856340567500000200 \ 0123450000000000006897528962743076432965432697856340567500000300"; - let combined = combine_seckeys_intern(input_str).unwrap(); + let combined = combine_seckeys(input_str).unwrap(); assert_eq!( combined, "0369cf00000000000139c5f79c275c9162c97c2fc973c69029c1035f00000600" From fa1dfa71660641647ecd9602e8f7b6913dbdbbb2 Mon Sep 17 00:00:00 2001 From: optout <13562139+optout21@users.noreply.github.com> Date: Wed, 17 Dec 2025 09:08:07 +0100 Subject: [PATCH 2/3] Fix sample --- samples/rust/src/main.rs | 6 +++--- samples/rust/src/test_lib.rs | 16 ++++++++-------- 2 files changed, 11 insertions(+), 11 deletions(-) diff --git a/samples/rust/src/main.rs b/samples/rust/src/main.rs index 82ef91c..fb12f25 100644 --- a/samples/rust/src/main.rs +++ b/samples/rust/src/main.rs @@ -13,13 +13,13 @@ fn main() { let entropy_hex = "00000000000000000000000000000001"; // abandon x 11 actual let network = "signet"; - let xpub = dlccryptlib::init_with_entropy_intern(entropy_hex, network).unwrap(); + let xpub = dlccryptlib::init_with_entropy(entropy_hex, network).unwrap(); println!("xpub: {xpub}"); - let pubkey0 = dlccryptlib::get_public_key_intern(0).unwrap(); + let pubkey0 = dlccryptlib::get_public_key(0).unwrap(); println!("pubkey 0: {pubkey0}"); let hash = "0001020300000000000000000000000000000000000000000000000000010203"; - let sig = dlccryptlib::sign_hash_ecdsa_intern(hash, 0, &pubkey0).unwrap(); + let sig = dlccryptlib::sign_hash_ecdsa(hash, 0, &pubkey0).unwrap(); println!("signature: {sig}"); } diff --git a/samples/rust/src/test_lib.rs b/samples/rust/src/test_lib.rs index d81c3bc..44684c8 100644 --- a/samples/rust/src/test_lib.rs +++ b/samples/rust/src/test_lib.rs @@ -10,7 +10,7 @@ const DEFAULT_NETWORK: &str = NETWORK_SIGNET; #[test] fn test_init_with_entropy() { - let xpub = dlccryptlib::init_with_entropy_intern(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); + let xpub = dlccryptlib::init_with_entropy(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); assert_eq!( xpub, "tpubDCxVvuZwEu4oZypCT3pzos1MUoVJyjTHjfrhKFXNBkAEqBmkkzEb2dUgzpZmBWbd6wZnNmm3Ex2suMnEFUMmayH2a6S49R4pTnoQttGrxUm" @@ -19,15 +19,15 @@ fn test_init_with_entropy() { #[test] fn test_get_public_key() { - let _xpub = dlccryptlib::init_with_entropy_intern(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); + let _xpub = dlccryptlib::init_with_entropy(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); - let pubkey0 = dlccryptlib::get_public_key_intern(0).unwrap(); + let pubkey0 = dlccryptlib::get_public_key(0).unwrap(); assert_eq!( pubkey0.to_string(), "031941e84b8d111e094aefc46e7181757c93a1da87c93ab519a40d9d765176e704" ); - let pubkey3 = dlccryptlib::get_public_key_intern(3).unwrap(); + let pubkey3 = dlccryptlib::get_public_key(3).unwrap(); assert_eq!( pubkey3.to_string(), "02a9569875400df2b7af9360fc5025de31fcd48ca8b658d61e535c3ff2f55aa128" @@ -36,19 +36,19 @@ fn test_get_public_key() { #[test] fn test_sign_hash_ecdsa() { - let _xpub = dlccryptlib::init_with_entropy_intern(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); + let _xpub = dlccryptlib::init_with_entropy(DUMMY_ENTROPY_STR, DEFAULT_NETWORK).unwrap(); - let pubkey3 = dlccryptlib::get_public_key_intern(3).unwrap(); + let pubkey3 = dlccryptlib::get_public_key(3).unwrap(); assert_eq!( pubkey3.to_string(), "02a9569875400df2b7af9360fc5025de31fcd48ca8b658d61e535c3ff2f55aa128" ); let hash = DUMMY_HASH07_STR; - let sig = dlccryptlib::sign_hash_ecdsa_intern(&hash, 3, &pubkey3).unwrap(); + let sig = dlccryptlib::sign_hash_ecdsa(&hash, 3, &pubkey3).unwrap(); assert!(sig.len() >= 140 && sig.len() <= 146); // negative test, wrong index - assert!(dlccryptlib::sign_hash_ecdsa_intern(&hash, 31, &pubkey3).is_err()); + assert!(dlccryptlib::sign_hash_ecdsa(&hash, 31, &pubkey3).is_err()); } From ef8abf7bdd159846d2f914ad476cb5ea2e6f9233 Mon Sep 17 00:00:00 2001 From: optout <13562139+optout21@users.noreply.github.com> Date: Wed, 17 Dec 2025 09:09:40 +0100 Subject: [PATCH 3/3] v0.9.1 --- Cargo.toml | 2 +- lib-py/Cargo.toml | 4 ++-- samples/rust/Cargo.toml | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 1e81773..e46b372 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "dlccryptlib" -version = "0.9.0" +version = "0.9.1" edition = "2021" description = "Library for working with DLC's with adaptor signatures (Discrete Log Contracts), by Cadena Bitcoin" license = "MIT" diff --git a/lib-py/Cargo.toml b/lib-py/Cargo.toml index a92ac30..f40e494 100644 --- a/lib-py/Cargo.toml +++ b/lib-py/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "dlccryptlib-py" -version = "0.9.0" +version = "0.9.1" edition = "2021" description = "Python-wrapped library for working with DLC's with adaptor signatures (Discrete Log Contracts), by Cadena Bitcoin" license = "MIT" @@ -9,6 +9,6 @@ license = "MIT" name = "dlccryptlib_py" [dependencies] -#dlccryptlib = "0.9.0" +#dlccryptlib = "0.9.1" dlccryptlib = { path = "../" } pyo3 = { version = "0.23.1" } diff --git a/samples/rust/Cargo.toml b/samples/rust/Cargo.toml index 57767ab..6c159b2 100644 --- a/samples/rust/Cargo.toml +++ b/samples/rust/Cargo.toml @@ -4,5 +4,5 @@ version = "0.1.0" edition = "2021" [dependencies] -#dlccryptlib = "0.9.0" +#dlccryptlib = "0.9.1" dlccryptlib = { path = "../../" }