Update ci.yml

.github/workflows/ci.yml

@@ -9,16 +9,18 @@ on:
     types:
       - opened
       - synchronize
+  create:
 
 jobs:
   build_wo_default_features:
     name: Build without default features
-    runs-on: ubuntu-latest
+    runs-on: self-hosted
     steps:
       - uses: actions/checkout@v2
       - uses: actions-rs/toolchain@v1
         with:
-          override: true
+          default: true
+          override: false
       - name: Build ergotree-ir
         uses: actions-rs/cargo@v1
         with:

Cargo.toml

@@ -98,6 +98,12 @@ proptest-derive = "0.3"
 pretty_assertions = "1.3"
 wasm-bindgen-test = "0.3.37"
 expect-test = "1.4.1"
+
+# TODO
+[profile.dev]
+incremental = true
+[profile.test]
+incremental = true
 [profile.release]
 # Tell `rustc` to optimize for small code size.
 opt-level = "z"

bindings/ergo-lib-c-core/src/box_builder.rs

@@ -161,7 +161,7 @@ pub unsafe fn ergo_box_candidate_builder_mint_token(
     let builder_mut = mut_ptr_as_mut(builder_mut, "builder_mut")?;
     let token = const_ptr_as_ref(token_ptr, "token_ptr")?;
     builder_mut.0.mint_token(
-        token.0.clone(),
+        token.0,
         token_name.into(),
         token_desc.into(),
         num_decimals,

bindings/ergo-lib-c-core/src/token.rs

@@ -119,7 +119,7 @@ pub unsafe fn token_get_amount(
 /// JSON representation according to EIP-12 <https://github.com/ergoplatform/eips/pull/23>
 pub unsafe fn token_to_json_eip12(token_ptr: ConstTokenPtr) -> Result<String, Error> {
     let token = const_ptr_as_ref(token_ptr, "token_ptr")?;
-    let t_dapp: TokenJsonEip12 = token.0.clone().into();
+    let t_dapp: TokenJsonEip12 = token.0.into();
     let s = serde_json::to_string(&t_dapp)?;
     Ok(s)
 }

bindings/ergo-lib-python/Cargo.toml

@@ -12,7 +12,11 @@ name = "ergo_lib_python"
 crate-type = ["cdylib"]
 
 [dependencies]
-pyo3 = "0.23.1"
+pyo3 = { version = "0.23.4", features = ["indexmap"] }
+base16 = { workspace = true }
 derive_more = { workspace = true }
+serde = { workspace = true }
 serde_json = { workspace = true }
 ergo-lib = { workspace = true, features = ["mnemonic_gen"] }
+sigma-ser = { workspace = true }
+serde-pyobject = "0.5.0"

bindings/ergo-lib-python/src/chain.rs

@@ -1,16 +1,41 @@
 pub mod address;
-mod ergo_box;
-mod token;
+pub mod constant;
+pub mod context_extension;
+pub mod ec_point;
+pub mod ergo_box;
+pub mod ergo_state_context;
+pub mod header;
+pub mod parameters;
+pub mod token;
 
 use address::{Address, NetworkPrefix};
-use ergo_box::ErgoBoxCandidate;
+use constant::{Constant, SType};
+use context_extension::ContextExtension;
+use ec_point::EcPoint;
+use ergo_box::{BoxId, ErgoBox, ErgoBoxCandidate, NonMandatoryRegisterId};
+use ergo_state_context::ErgoStateContext;
+use header::{BlockId, Header, PreHeader};
+use parameters::Parameters;
 use pyo3::prelude::*;
 use token::{Token, TokenId};
+
 pub fn register(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<NetworkPrefix>()?;
     m.add_class::<Address>()?;
+    m.add_class::<EcPoint>()?;
     m.add_class::<ErgoBoxCandidate>()?;
+    m.add_class::<ErgoBox>()?;
+    m.add_class::<BoxId>()?;
     m.add_class::<TokenId>()?;
     m.add_class::<Token>()?;
+    m.add_class::<NonMandatoryRegisterId>()?;
+    m.add_class::<Constant>()?;
+    m.add_class::<SType>()?;
+    m.add_class::<BlockId>()?;
+    m.add_class::<Header>()?;
+    m.add_class::<PreHeader>()?;
+    m.add_class::<ContextExtension>()?;
+    m.add_class::<Parameters>()?;
+    m.add_class::<ErgoStateContext>()?;
     Ok(())
 }

bindings/ergo-lib-python/src/chain/address.rs

@@ -1,9 +1,9 @@
-use derive_more::From;
+use derive_more::{From, Into};
 use ergo_lib::ergotree_ir::chain::address::{self, AddressEncoder};
-use pyo3::{exceptions::PyValueError, prelude::*, types::PyDict};
+use pyo3::{exceptions::PyValueError, prelude::*, types::PyType};
 
-use crate::to_value_error;
-#[pyclass(eq, frozen)]
+use crate::{ergo_tree::ErgoTree, sigma_boolean::ProveDlog, to_value_error};
+#[pyclass(eq, eq_int, frozen)]
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum NetworkPrefix {
     Mainnet = 0x00,
@@ -12,6 +12,7 @@ pub enum NetworkPrefix {
 
 impl From<NetworkPrefix> for address::NetworkPrefix {
     fn from(value: NetworkPrefix) -> Self {
+        #[allow(clippy::unwrap_used)] // All variants of python NetworkPrefix are valid
         address::NetworkPrefix::try_from(value as u8).unwrap()
     }
 }
@@ -52,28 +53,20 @@ impl From<NetworkPrefix> for address::NetworkPrefix {
  * ?  - P2S (4MQyML64GnzMxZgm, BxKBaHkvrTvLZrDcZjcsxsF7aSsrN73ijeFZXtbj4CXZHHcvBtqSxQ)
  */
 #[pyclass(eq, frozen)]
-#[derive(From, Clone, PartialEq, Eq)]
-pub struct Address(pub(crate) address::Address);
+#[derive(From, Into, Clone, PartialEq, Eq)]
+pub(crate) struct Address(pub(crate) address::Address);
 
 #[pymethods]
 impl Address {
     /// Build a new address from a str, ErgoTree or bytes
     #[new]
-    #[pyo3(signature = (**kwds))]
-    fn new(kwds: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
-        let kwds =
-            kwds.ok_or_else(|| PyValueError::new_err("No arguments given to Address.new"))?;
+    #[pyo3(signature = (arg, network_prefix=None))]
+    fn new(arg: &Bound<'_, PyAny>, network_prefix: Option<NetworkPrefix>) -> PyResult<Self> {
+        let encoder =
+            network_prefix.map(|prefix| AddressEncoder::new(address::NetworkPrefix::from(prefix)));
 
-        let encoder = if let Some(prefix) = kwds.get_item("network_prefix")? {
-            Some(AddressEncoder::new(address::NetworkPrefix::from(
-                prefix.extract::<NetworkPrefix>()?,
-            )))
-        } else {
-            None
-        };
-        match kwds.get_item("str")? {
-            Some(s) => {
-                let s = s.extract::<&str>()?;
+        match arg.extract::<&str>() {
+            Ok(s) => {
                 if let Some(encoder) = encoder {
                     encoder
                         .parse_address_from_str(s)
@@ -85,17 +78,31 @@ impl Address {
                         .map(Self)
                 }
             }
-            None => match kwds.get_item("bytes")? {
-                Some(bytes) => {
-                    AddressEncoder::unchecked_parse_address_from_bytes(bytes.extract::<&[u8]>()?)
-                        .map_err(to_value_error)
-                        .map(Self)
-                }
-                None => Err(PyValueError::new_err("expected str= or bytes= argument")),
+            Err(e) => match arg.extract::<&[u8]>() {
+                Ok(bytes) => AddressEncoder::unchecked_parse_address_from_bytes(bytes)
+                    .map_err(to_value_error)
+                    .map(Self),
+                Err(e) => Err(PyValueError::new_err("expected str or bytes argument")),
             },
         }
     }
-    #[pyo3(signature = (network_prefix=NetworkPrefix::Mainnet))]
+    #[classmethod]
+    fn p2pk(_: &Bound<'_, PyType>, prove_dlog: ProveDlog) -> Address {
+        address::Address::P2Pk(prove_dlog.into()).into()
+    }
+    /// Re-create the address from ErgoTree that was built from the address
+    /// This is the inverse of Address.ergo_tree()
+    #[classmethod]
+    fn recreate_from_ergo_tree(_: &Bound<'_, PyType>, tree: &ErgoTree) -> PyResult<Self> {
+        address::Address::recreate_from_ergo_tree(&tree.0)
+            .map(Self)
+            .map_err(to_value_error)
+    }
+    /// Create an ErgoTree script from the address
+    pub(crate) fn ergo_tree(&self) -> PyResult<ErgoTree> {
+        self.0.script().map(Into::into).map_err(to_value_error)
+    }
+
     fn to_str(&self, network_prefix: NetworkPrefix) -> String {
         AddressEncoder::new(network_prefix.into()).address_to_str(&self.0)
     }