Add atomic module to bee-transaction

bee-transaction/Cargo.toml

@@ -13,4 +13,12 @@ homepage = "https://www.iota.org"
 [dependencies]
 bee-crypto = { git = "https://github.com/iotaledger/bee.git", branch = "dev" }
 bee-signing = { git = "https://github.com/iotaledger/bee.git", branch = "dev" }
+bee-signing-ext = { git ="https://github.com/wusyong/bee-p", branch = "sign-ext" }
 bee-ternary = { git = "https://github.com/iotaledger/bee.git", branch = "dev", features = ["serde1"] }
+
+bech32 = "0.7.2"
+bytemuck = "1.2.0"
+thiserror = "1.0"
+
+[dev-dependencies]
+hex-literal = "0.3.1"

bee-transaction/src/atomic/hash.rs

@@ -0,0 +1,27 @@
+// Copyright 2020 IOTA Stiftung
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and limitations under the License.
+
+pub const HASH_LENGTH: usize = 32;
+
+#[derive(Debug, Eq, PartialEq)]
+pub struct Hash([u8; HASH_LENGTH]);
+
+impl From<[u8; HASH_LENGTH]> for Hash {
+    fn from(bytes: [u8; HASH_LENGTH]) -> Self {
+        Self(bytes)
+    }
+}
+
+impl Hash {
+    pub fn new(bytes: [u8; HASH_LENGTH]) -> Self {
+        bytes.into()
+    }
+}

bee-transaction/src/atomic/message.rs

@@ -0,0 +1,95 @@
+// Copyright 2020 IOTA Stiftung
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and limitations under the License.
+
+use crate::{
+    atomic::{payload::Payload, Error, Hash},
+    Vertex,
+};
+
+#[derive(Debug)]
+pub struct Message {
+    parent1: Hash,
+    parent2: Hash,
+    payload: Payload,
+    nonce: u64,
+}
+
+impl Message {
+    pub fn builder() -> MessageBuilder {
+        MessageBuilder::new()
+    }
+
+    pub fn parent1(&self) -> &Hash {
+        &self.parent1
+    }
+
+    pub fn parent2(&self) -> &Hash {
+        &self.parent2
+    }
+
+    pub fn payload(&self) -> &Payload {
+        &self.payload
+    }
+
+    pub fn nonce(&self) -> u64 {
+        self.nonce
+    }
+}
+
+impl Vertex for Message {
+    type Hash = Hash;
+
+    fn trunk(&self) -> &Self::Hash {
+        &self.parent1
+    }
+
+    fn branch(&self) -> &Self::Hash {
+        &self.parent2
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct MessageBuilder {
+    parent1: Option<Hash>,
+    parent2: Option<Hash>,
+    payload: Option<Payload>,
+}
+
+impl MessageBuilder {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn parent1(mut self, parent1: Hash) -> Self {
+        self.parent1 = Some(parent1);
+        self
+    }
+
+    pub fn parent2(mut self, parent2: Hash) -> Self {
+        self.parent2 = Some(parent2);
+        self
+    }
+
+    pub fn payload(mut self, payload: Payload) -> Self {
+        self.payload = Some(payload);
+        self
+    }
+
+    pub fn build(self) -> Result<Message, Error> {
+        Ok(Message {
+            parent1: self.parent1.ok_or(Error::MissingField("parent1"))?,
+            parent2: self.parent2.ok_or(Error::MissingField("parent2"))?,
+            payload: self.payload.ok_or(Error::MissingField("payload"))?,
+            // TODO PoW
+            nonce: 0,
+        })
+    }
+}

bee-transaction/src/atomic/mod.rs

@@ -0,0 +1,72 @@
+// Copyright 2020 IOTA Stiftung
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and limitations under the License.
+
+mod hash;
+mod message;
+
+pub mod payload;
+
+pub use hash::{Hash, HASH_LENGTH};
+pub use message::{Message, MessageBuilder};
+
+use core::fmt;
+
+#[derive(Debug)]
+pub enum Error {
+    AmountError,
+    CountError,
+    NoInput,
+    NoOutput,
+    DuplicateError,
+    // TODO add index
+    InvalidIndex,
+    InvalidAddress,
+    InvalidSignature,
+    OrderError,
+    HashError,
+    PathError,
+    MissingField(&'static str),
+    SigningError(bee_signing_ext::binary::Error),
+    SignatureError(bee_signing_ext::SignatureError),
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::AmountError => write!(f, "Invalid amount provided."),
+            Error::CountError => write!(f, "Invalid count number provided."),
+            Error::NoInput => write!(f, "No input provided."),
+            Error::NoOutput => write!(f, "No output provided."),
+            Error::DuplicateError => write!(f, "The object in the set must be unique."),
+            Error::InvalidIndex => write!(f, "Invalid index provided."),
+            Error::InvalidAddress => write!(f, "Invalid address provided."),
+            Error::InvalidSignature => write!(f, "Invalid signature provided."),
+            Error::OrderError => write!(f, "The vector is not sorted by lexicographical order."),
+            Error::HashError => write!(f, "The format of provided hash is not correct."),
+            Error::PathError => write!(f, "The format of provided BIP32 path is not correct."),
+            Error::MissingField(s) => write!(f, "Missing required field: {}.", s),
+            Error::SigningError(e) => write!(f, "{}", e),
+            Error::SignatureError(e) => write!(f, "{}", e),
+        }
+    }
+}
+
+impl From<bee_signing_ext::binary::Error> for Error {
+    fn from(error: bee_signing_ext::binary::Error) -> Self {
+        Error::SigningError(error)
+    }
+}
+
+impl From<bee_signing_ext::SignatureError> for Error {
+    fn from(error: bee_signing_ext::SignatureError) -> Self {
+        Error::SignatureError(error)
+    }
+}

bee-transaction/src/atomic/payload/indexation.rs

@@ -0,0 +1,27 @@
+// Copyright 2020 IOTA Stiftung
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and limitations under the License.
+
+pub const TAG_LENGTH: usize = 16;
+
+#[derive(Debug)]
+pub struct Indexation([u8; TAG_LENGTH]);
+
+impl From<[u8; TAG_LENGTH]> for Indexation {
+    fn from(bytes: [u8; TAG_LENGTH]) -> Self {
+        Self(bytes)
+    }
+}
+
+impl Indexation {
+    pub fn new(bytes: [u8; TAG_LENGTH]) -> Self {
+        bytes.into()
+    }
+}

bee-transaction/src/atomic/payload/milestone.rs

@@ -0,0 +1,33 @@
+// Copyright 2020 IOTA Stiftung
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and limitations under the License.
+
+use alloc::{boxed::Box, vec::Vec};
+
+#[derive(Debug)]
+pub struct Milestone {
+    index: u32,
+    timestamp: u64,
+    // TODO length is 64, change to array when std::array::LengthAtMost32 disappears.
+    merkle_proof: Box<[u8]>,
+    // TODO length is 64, change to array when std::array::LengthAtMost32 disappears.
+    signatures: Vec<Box<[u8]>>,
+}
+
+impl Milestone {
+    pub fn new(index: u32, timestamp: u64, merkle_proof: Box<[u8]>, signatures: Vec<Box<[u8]>>) -> Self {
+        Self {
+            index,
+            timestamp,
+            merkle_proof,
+            signatures,
+        }
+    }
+}

bee-transaction/src/atomic/payload/mod.rs

@@ -0,0 +1,34 @@
+// Copyright 2020 IOTA Stiftung
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and limitations under the License.
+
+mod indexation;
+mod milestone;
+mod signed_data;
+mod unsigned_data;
+
+pub mod signed_transaction;
+
+pub use indexation::{Indexation, TAG_LENGTH};
+pub use milestone::Milestone;
+pub use signed_data::SignedData;
+pub use signed_transaction::SignedTransaction;
+pub use unsigned_data::UnsignedData;
+
+use alloc::boxed::Box;
+
+#[derive(Debug)]
+pub enum Payload {
+    SignedTransaction(Box<SignedTransaction>),
+    Milestone(Box<Milestone>),
+    Indexation(Box<Indexation>),
+    UnsignedData(Box<UnsignedData>),
+    SignedData(Box<SignedData>),
+}

bee-transaction/src/atomic/payload/signed_data.rs

@@ -0,0 +1,32 @@
+// Copyright 2020 IOTA Stiftung
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and limitations under the License.
+
+use alloc::{boxed::Box, vec::Vec};
+
+#[derive(Debug)]
+pub struct SignedData {
+    data: Vec<u8>,
+    // TODO Hash type ?
+    public_key: [u8; 32],
+    // TODO change back to array with length 64.
+    // TODO what kind of sig ?
+    signature: Box<[u8]>,
+}
+
+impl SignedData {
+    pub fn new(data: Vec<u8>, public_key: [u8; 32], signature: Box<[u8]>) -> Self {
+        Self {
+            data,
+            public_key,
+            signature,
+        }
+    }
+}

bee-transaction/src/atomic/payload/signed_transaction/constants.rs

@@ -0,0 +1,16 @@
+// Copyright 2020 IOTA Stiftung
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and limitations under the License.
+
+use core::ops::Range;
+
+const INPUT_OUTPUT_COUNT_MAX: usize = 127;
+pub(crate) const INPUT_OUTPUT_COUNT_RANGE: Range<usize> = 1..INPUT_OUTPUT_COUNT_MAX + 1;
+pub(crate) const INPUT_OUTPUT_INDEX_RANGE: Range<u8> = 0..INPUT_OUTPUT_COUNT_MAX as u8;

bee-transaction/src/atomic/payload/signed_transaction/input/mod.rs

@@ -0,0 +1,25 @@
+// Copyright 2020 IOTA Stiftung
+//
+// Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+// the License. You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+// an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and limitations under the License.
+
+mod utxo;
+
+pub use utxo::UTXOInput;
+
+#[derive(Debug, Eq, PartialEq)]
+pub enum Input {
+    UTXO(UTXOInput),
+}
+
+impl From<UTXOInput> for Input {
+    fn from(input: UTXOInput) -> Self {
+        Self::UTXO(input)
+    }
+}