sidan-gin 0.1.1__py3-none-any.whl → 0.1.5__py3-none-any.whl

sidan_gin/python_signing_module/src/lib.rs

@@ -0,0 +1,57 @@
+use whisky_wallet::{
+    derivation_indices::DerivationIndices, Account, MnemonicWallet, RootKeyWallet, Wallet,
+    WalletType,
+};
+
+#[cxx::bridge]
+mod ffi {
+    // Rust types and signatures exposed to C++.
+    extern "Rust" {
+        type Signer;
+        fn new_mnemonic_signer(mnemonic_phrase: &str, derivation_path: &str) -> Box<Signer>;
+        fn new_bech32_signer(root_private_key: &str, derivation_path: &str) -> Box<Signer>;
+        fn new_cli_signer(ed25519_key: &str) -> Box<Signer>;
+        fn sign_transaction(&mut self, tx_hex: &str) -> String;
+        fn get_public_key(&self) -> String;
+    }
+}
+
+fn new_mnemonic_signer(mnemonic_phrase: &str, derivation_path: &str) -> Box<Signer> {
+    let wallet = Wallet::new(WalletType::MnemonicWallet(MnemonicWallet {
+        mnemonic_phrase: mnemonic_phrase.to_string(),
+        derivation_indices: DerivationIndices::from_str(derivation_path),
+    }));
+    let account = wallet.get_account().unwrap();
+    Box::new(Signer { account })
+}
+
+fn new_bech32_signer(root_private_key: &str, derivation_path: &str) -> Box<Signer> {
+    let wallet = Wallet::new(WalletType::RootKeyWallet(RootKeyWallet {
+        root_key: root_private_key.to_string(),
+        derivation_indices: DerivationIndices::from_str(derivation_path),
+    }));
+    let account = wallet.get_account().unwrap();
+    Box::new(Signer { account })
+}
+
+fn new_cli_signer(ed25519_key: &str) -> Box<Signer> {
+    let wallet = Wallet::new_cli(ed25519_key);
+    let account = wallet.get_account().unwrap();
+    Box::new(Signer { account })
+}
+
+struct Signer {
+    account: Account,
+}
+
+impl Signer {
+    pub fn sign_transaction(&self, tx_hex: &str) -> String {
+        self.account.sign_transaction(tx_hex).unwrap_or_else(|_| {
+            panic!("Failed to sign transaction with the provided account");
+        })
+    }
+
+    pub fn get_public_key(&self) -> String {
+        self.account.public_key.to_hex()
+    }
+}

sidan_gin/python_signing_module/src/lib.rs.h

@@ -0,0 +1,403 @@
+#pragma once
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <new>
+#include <string>
+#include <type_traits>
+#include <utility>
+#if __cplusplus >= 201703L
+#include <string_view>
+#endif
+
+namespace rust {
+inline namespace cxxbridge1 {
+// #include "rust/cxx.h"
+
+struct unsafe_bitcopy_t;
+
+namespace {
+template <typename T>
+class impl;
+} // namespace
+
+#ifndef CXXBRIDGE1_RUST_STRING
+#define CXXBRIDGE1_RUST_STRING
+class String final {
+public:
+  String() noexcept;
+  String(const String &) noexcept;
+  String(String &&) noexcept;
+  ~String() noexcept;
+
+  String(const std::string &);
+  String(const char *);
+  String(const char *, std::size_t);
+  String(const char16_t *);
+  String(const char16_t *, std::size_t);
+#ifdef __cpp_char8_t
+  String(const char8_t *s);
+  String(const char8_t *s, std::size_t len);
+#endif
+
+  static String lossy(const std::string &) noexcept;
+  static String lossy(const char *) noexcept;
+  static String lossy(const char *, std::size_t) noexcept;
+  static String lossy(const char16_t *) noexcept;
+  static String lossy(const char16_t *, std::size_t) noexcept;
+
+  String &operator=(const String &) & noexcept;
+  String &operator=(String &&) & noexcept;
+
+  explicit operator std::string() const;
+
+  const char *data() const noexcept;
+  std::size_t size() const noexcept;
+  std::size_t length() const noexcept;
+  bool empty() const noexcept;
+
+  const char *c_str() noexcept;
+
+  std::size_t capacity() const noexcept;
+  void reserve(size_t new_cap) noexcept;
+
+  using iterator = char *;
+  iterator begin() noexcept;
+  iterator end() noexcept;
+
+  using const_iterator = const char *;
+  const_iterator begin() const noexcept;
+  const_iterator end() const noexcept;
+  const_iterator cbegin() const noexcept;
+  const_iterator cend() const noexcept;
+
+  bool operator==(const String &) const noexcept;
+  bool operator!=(const String &) const noexcept;
+  bool operator<(const String &) const noexcept;
+  bool operator<=(const String &) const noexcept;
+  bool operator>(const String &) const noexcept;
+  bool operator>=(const String &) const noexcept;
+
+  void swap(String &) noexcept;
+
+  String(unsafe_bitcopy_t, const String &) noexcept;
+
+private:
+  struct lossy_t;
+  String(lossy_t, const char *, std::size_t) noexcept;
+  String(lossy_t, const char16_t *, std::size_t) noexcept;
+  friend void swap(String &lhs, String &rhs) noexcept { lhs.swap(rhs); }
+
+  std::array<std::uintptr_t, 3> repr;
+};
+#endif // CXXBRIDGE1_RUST_STRING
+
+#ifndef CXXBRIDGE1_RUST_STR
+#define CXXBRIDGE1_RUST_STR
+class Str final {
+public:
+  Str() noexcept;
+  Str(const String &) noexcept;
+  Str(const std::string &);
+  Str(const char *);
+  Str(const char *, std::size_t);
+
+  Str &operator=(const Str &) & noexcept = default;
+
+  explicit operator std::string() const;
+#if __cplusplus >= 201703L
+  explicit operator std::string_view() const;
+#endif
+
+  const char *data() const noexcept;
+  std::size_t size() const noexcept;
+  std::size_t length() const noexcept;
+  bool empty() const noexcept;
+
+  Str(const Str &) noexcept = default;
+  ~Str() noexcept = default;
+
+  using iterator = const char *;
+  using const_iterator = const char *;
+  const_iterator begin() const noexcept;
+  const_iterator end() const noexcept;
+  const_iterator cbegin() const noexcept;
+  const_iterator cend() const noexcept;
+
+  bool operator==(const Str &) const noexcept;
+  bool operator!=(const Str &) const noexcept;
+  bool operator<(const Str &) const noexcept;
+  bool operator<=(const Str &) const noexcept;
+  bool operator>(const Str &) const noexcept;
+  bool operator>=(const Str &) const noexcept;
+
+  void swap(Str &) noexcept;
+
+private:
+  class uninit;
+  Str(uninit) noexcept;
+  friend impl<Str>;
+
+  std::array<std::uintptr_t, 2> repr;
+};
+#endif // CXXBRIDGE1_RUST_STR
+
+#ifndef CXXBRIDGE1_RUST_BOX
+#define CXXBRIDGE1_RUST_BOX
+template <typename T>
+class Box final {
+public:
+  using element_type = T;
+  using const_pointer =
+      typename std::add_pointer<typename std::add_const<T>::type>::type;
+  using pointer = typename std::add_pointer<T>::type;
+
+  Box() = delete;
+  Box(Box &&) noexcept;
+  ~Box() noexcept;
+
+  explicit Box(const T &);
+  explicit Box(T &&);
+
+  Box &operator=(Box &&) & noexcept;
+
+  const T *operator->() const noexcept;
+  const T &operator*() const noexcept;
+  T *operator->() noexcept;
+  T &operator*() noexcept;
+
+  template <typename... Fields>
+  static Box in_place(Fields &&...);
+
+  void swap(Box &) noexcept;
+
+  static Box from_raw(T *) noexcept;
+
+  T *into_raw() noexcept;
+
+  /* Deprecated */ using value_type = element_type;
+
+private:
+  class uninit;
+  class allocation;
+  Box(uninit) noexcept;
+  void drop() noexcept;
+
+  friend void swap(Box &lhs, Box &rhs) noexcept { lhs.swap(rhs); }
+
+  T *ptr;
+};
+
+template <typename T>
+class Box<T>::uninit {};
+
+template <typename T>
+class Box<T>::allocation {
+  static T *alloc() noexcept;
+  static void dealloc(T *) noexcept;
+
+public:
+  allocation() noexcept : ptr(alloc()) {}
+  ~allocation() noexcept {
+    if (this->ptr) {
+      dealloc(this->ptr);
+    }
+  }
+  T *ptr;
+};
+
+template <typename T>
+Box<T>::Box(Box &&other) noexcept : ptr(other.ptr) {
+  other.ptr = nullptr;
+}
+
+template <typename T>
+Box<T>::Box(const T &val) {
+  allocation alloc;
+  ::new (alloc.ptr) T(val);
+  this->ptr = alloc.ptr;
+  alloc.ptr = nullptr;
+}
+
+template <typename T>
+Box<T>::Box(T &&val) {
+  allocation alloc;
+  ::new (alloc.ptr) T(std::move(val));
+  this->ptr = alloc.ptr;
+  alloc.ptr = nullptr;
+}
+
+template <typename T>
+Box<T>::~Box() noexcept {
+  if (this->ptr) {
+    this->drop();
+  }
+}
+
+template <typename T>
+Box<T> &Box<T>::operator=(Box &&other) & noexcept {
+  if (this->ptr) {
+    this->drop();
+  }
+  this->ptr = other.ptr;
+  other.ptr = nullptr;
+  return *this;
+}
+
+template <typename T>
+const T *Box<T>::operator->() const noexcept {
+  return this->ptr;
+}
+
+template <typename T>
+const T &Box<T>::operator*() const noexcept {
+  return *this->ptr;
+}
+
+template <typename T>
+T *Box<T>::operator->() noexcept {
+  return this->ptr;
+}
+
+template <typename T>
+T &Box<T>::operator*() noexcept {
+  return *this->ptr;
+}
+
+template <typename T>
+template <typename... Fields>
+Box<T> Box<T>::in_place(Fields &&...fields) {
+  allocation alloc;
+  auto ptr = alloc.ptr;
+  ::new (ptr) T{std::forward<Fields>(fields)...};
+  alloc.ptr = nullptr;
+  return from_raw(ptr);
+}
+
+template <typename T>
+void Box<T>::swap(Box &rhs) noexcept {
+  using std::swap;
+  swap(this->ptr, rhs.ptr);
+}
+
+template <typename T>
+Box<T> Box<T>::from_raw(T *raw) noexcept {
+  Box box = uninit{};
+  box.ptr = raw;
+  return box;
+}
+
+template <typename T>
+T *Box<T>::into_raw() noexcept {
+  T *raw = this->ptr;
+  this->ptr = nullptr;
+  return raw;
+}
+
+template <typename T>
+Box<T>::Box(uninit) noexcept {}
+#endif // CXXBRIDGE1_RUST_BOX
+
+#ifndef CXXBRIDGE1_RUST_OPAQUE
+#define CXXBRIDGE1_RUST_OPAQUE
+class Opaque {
+public:
+  Opaque() = delete;
+  Opaque(const Opaque &) = delete;
+  ~Opaque() = delete;
+};
+#endif // CXXBRIDGE1_RUST_OPAQUE
+
+#ifndef CXXBRIDGE1_IS_COMPLETE
+#define CXXBRIDGE1_IS_COMPLETE
+namespace detail {
+namespace {
+template <typename T, typename = std::size_t>
+struct is_complete : std::false_type {};
+template <typename T>
+struct is_complete<T, decltype(sizeof(T))> : std::true_type {};
+} // namespace
+} // namespace detail
+#endif // CXXBRIDGE1_IS_COMPLETE
+
+#ifndef CXXBRIDGE1_LAYOUT
+#define CXXBRIDGE1_LAYOUT
+class layout {
+  template <typename T>
+  friend std::size_t size_of();
+  template <typename T>
+  friend std::size_t align_of();
+  template <typename T>
+  static typename std::enable_if<std::is_base_of<Opaque, T>::value,
+                                 std::size_t>::type
+  do_size_of() {
+    return T::layout::size();
+  }
+  template <typename T>
+  static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
+                                 std::size_t>::type
+  do_size_of() {
+    return sizeof(T);
+  }
+  template <typename T>
+  static
+      typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
+      size_of() {
+    return do_size_of<T>();
+  }
+  template <typename T>
+  static typename std::enable_if<std::is_base_of<Opaque, T>::value,
+                                 std::size_t>::type
+  do_align_of() {
+    return T::layout::align();
+  }
+  template <typename T>
+  static typename std::enable_if<!std::is_base_of<Opaque, T>::value,
+                                 std::size_t>::type
+  do_align_of() {
+    return alignof(T);
+  }
+  template <typename T>
+  static
+      typename std::enable_if<detail::is_complete<T>::value, std::size_t>::type
+      align_of() {
+    return do_align_of<T>();
+  }
+};
+
+template <typename T>
+std::size_t size_of() {
+  return layout::size_of<T>();
+}
+
+template <typename T>
+std::size_t align_of() {
+  return layout::align_of<T>();
+}
+#endif // CXXBRIDGE1_LAYOUT
+} // namespace cxxbridge1
+} // namespace rust
+
+struct Signer;
+
+#ifndef CXXBRIDGE1_STRUCT_Signer
+#define CXXBRIDGE1_STRUCT_Signer
+struct Signer final : public ::rust::Opaque {
+  ::rust::String sign_transaction(::rust::Str tx_hex) noexcept;
+  ::rust::String get_public_key() const noexcept;
+  ~Signer() = delete;
+
+private:
+  friend ::rust::layout;
+  struct layout {
+    static ::std::size_t size() noexcept;
+    static ::std::size_t align() noexcept;
+  };
+};
+#endif // CXXBRIDGE1_STRUCT_Signer
+
+::rust::Box<::Signer> new_mnemonic_signer(::rust::Str mnemonic_phrase, ::rust::Str derivation_path) noexcept;
+
+::rust::Box<::Signer> new_bech32_signer(::rust::Str root_private_key, ::rust::Str derivation_path) noexcept;
+
+::rust::Box<::Signer> new_cli_signer(::rust::Str ed25519_key) noexcept;

sidan_gin/python_signing_module/src/setup.py

@@ -0,0 +1,16 @@
+from setuptools import setup, Extension
+
+signer_module = Extension(
+   '_CardanoSigner',
+   sources=['signer_wrap.cxx', 'signer.cpp'], # signer_wrap.cxx is going to be generated by swig
+   extra_objects=["libsigner.a"] # this is the static library that we are going to link with
+)
+
+setup (
+	name        = 'CardanoSigner',
+	version     = '0.0',
+	author      = "YOUR_NAME",
+	description = "CardanoSigner swig",
+	ext_modules = [signer_module],
+	py_modules  = ["CardanoSigner"], # name of module that we're going import
+)

sidan_gin/python_signing_module/src/signer.cpp

@@ -0,0 +1,73 @@
+#include "lib.rs.h"
+
+#include <string>
+#include <vector>
+
+// class MnemonicSigner
+// {
+// public:
+//     MnemonicSigner(std::string mnemonic, std::uint32_t account_index, std::uint32_t key_index)
+//     {
+//         this->mnemonic_secret = mnemonic;
+//         this->account_index = account_index;
+//         this->key_index = key_index;
+//     };
+//     ~MnemonicSigner() = default;
+
+//     std::string sign_tx(std::string tx_hex)
+//     {
+//         auto signer = new_mnemonic_signer(mnemonic_secret, account_index, key_index);
+//         std::string signed_tx = signer->sign_transaction(tx_hex).c_str();
+//         return signed_tx;
+//     };
+
+// private:
+//     std::string mnemonic_secret;
+//     std::uint32_t account_index;
+//     std::uint32_t key_index;
+// };
+
+// class Bech32Signer
+// {
+// public:
+//     Bech32Signer(std::string bech32, std::uint32_t account_index, std::uint32_t key_index)
+//     {
+//         this->bech32_secret = bech32;
+//         this->account_index = account_index;
+//         this->key_index = key_index;
+//     };
+//     ~Bech32Signer() = default;
+
+//     std::string sign_tx(std::string tx_hex)
+//     {
+//         auto signer = new_bech32_signer(bech32_secret, account_index, key_index);
+//         std::string signed_tx = signer->sign_transaction(tx_hex).c_str();
+//         return signed_tx;
+//     };
+
+// private:
+//     std::string bech32_secret;
+//     std::uint32_t account_index;
+//     std::uint32_t key_index;
+// };
+
+std::string sign_mnemonic(std::string mnemonic, std::string derivation_path, std::string tx_hex)
+{
+    auto signer = new_mnemonic_signer(mnemonic, derivation_path);
+    std::string signed_tx = signer->sign_transaction(tx_hex).c_str();
+    return signed_tx;
+}
+
+std::string sign_bech32(std::string bech32, std::string derivation_path, std::string tx_hex)
+{
+    auto signer = new_bech32_signer(bech32, derivation_path);
+    std::string signed_tx = signer->sign_transaction(tx_hex).c_str();
+    return signed_tx;
+}
+
+std::string sign_cli(std::string ed25519_key, std::string tx_hex)
+{
+    auto signer = new_cli_signer(ed25519_key);
+    std::string signed_tx = signer->sign_transaction(tx_hex).c_str();
+    return signed_tx;
+}

sidan_gin/python_signing_module/src/signer.h

@@ -0,0 +1,37 @@
+#include "lib.rs.h"
+
+#include <string>
+
+// class MnemonicSigner
+// {
+// public:
+//     MnemonicSigner(std::string mnemonic, std::uint32_t account_index, std::uint32_t key_index);
+//     ~MnemonicSigner() = default;
+
+//     std::string sign_tx(std::string tx_hex);
+
+// private:
+//     std::string mnemonic_secret;
+//     std::uint32_t account_index;
+//     std::uint32_t key_index;
+// };
+
+// class Bech32Signer
+// {
+// public:
+//     Bech32Signer(std::string bech32, std::uint32_t account_index, std::uint32_t key_index);
+//     ~Bech32Signer() = default;
+
+//     std::string sign_tx(std::string tx_hex);
+
+// private:
+//     std::string bech32_secret;
+//     std::uint32_t account_index;
+//     std::uint32_t key_index;
+// };
+
+std::string sign_mnemonic(std::string mnemonic, std::string derivation_path, std::string tx_hex);
+
+std::string sign_bech32(std::string bech32, std::string derivation_path, std::string tx_hex);
+
+std::string sign_cli(std::string ed25519_key, std::string tx_hex);

sidan_gin/python_signing_module/src/signer.i

@@ -0,0 +1,16 @@
+%module CardanoSigner
+
+%include "std_string.i"
+
+%{
+#define SWIG_FILE_WITH_INIT
+#include "lib.rs.h"
+#include "signer.h"
+#include <string>
+%}
+
+std::string sign_mnemonic(std::string mnemonic, std::string derivation_path, std::string tx_hex);
+
+std::string sign_bech32(std::string bech32, std::string derivation_path, std::string tx_hex);
+
+std::string sign_cli(std::string ed25519_key, std::string tx_hex);