Skip to content

Commit

Permalink
Update rust code for move to splintercommunity
Browse files Browse the repository at this point in the history 
 Signed-off-by: Andrea Gunderson <[email protected]>
  • Loading branch information
@agunde406
agunde406 committed Jan 25, 2024
1 parent 5da33fe commit 0d9abab
Show file tree
Hide file tree
Showing 3 changed files with 26 additions and 66 deletions.
3 changes: 2 additions & 1 deletion libsawtooth/Cargo.toml
View file
Original file line number Diff line number Diff line change
@@ -1,3 +1,4 @@
# Copyright 2024 Bitwise IO, Inc.
# Copyright 2019 Cargill Incorporated
#
# Licensed under the Apache License, Version 2.0 (the "License");
Expand All @@ -20,7 +21,7 @@ edition = "2018"
license = "Apache-2.0"
readme = "../README.md"
description = """\
Hyperledger Sawtooth is an enterprise blockchain platform for building \
Sawtooth is an enterprise blockchain platform for building \
distributed ledger applications and networks.
"""

Expand Down
83 changes: 21 additions & 62 deletions libsawtooth/src/transact/mod.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -16,50 +16,35 @@
* -----------------------------------------------------------------------------
*/

//! # Hyperledger Transact
//! # Transact
//!
//! Hyperledger Transact makes writing distributed ledger software easier by providing a shared
//! software library that handles the execution of smart contracts, including all aspects of
//! scheduling, transaction dispatch, and state management.
//! Transact makes writing distributed ledger software easier by providing a shared software
//! library that handles the execution of smart contracts, including all aspects of scheduling,
//! transaction dispatch, and state management.
//!
//! Hyperledger framework-level projects and custom distributed ledgers can use Transact's
//! advanced transaction execution and state management to simplify the transaction execution code
//! in their projects and to take advantage of Transact’s additional features.
//! Framework-level projects and custom distributed ledgers can use Transact's advanced transaction
//! execution and state management to simplify the transaction execution code in their projects and
//! to take advantage of Transact’s additional features.
//!
//! More specifically, Transact provides an extensible approach to implementing new smart contract
//! languages called “smart contract engines.” Each smart contract engine implements a virtual
//! machine or interpreter that processes smart contracts. Examples include
//! [Seth](https://sawtooth.hyperledger.org/docs/seth/nightly/master/introduction.html), which
//! processes Ethereum Virtual Machine (EVM) smart contracts, and
//! [Sabre](https://sawtooth.hyperledger.org/docs/sabre/nightly/master/sabre_transaction_family.html),
//! which handles WebAssembly smart contracts. Transact also provides SDKs for implementing smart
//! contracts and smart contract engines, which makes it easy to write smart contract business
//! logic in a variety of programming languages.
//!
//! Hyperledger Transact is inspired by Hyperledger Sawtooth and uses architectural elements from
//! Sawtooth's current transaction execution platform, including the approach to scheduling,
//! transaction isolation, and state management. Transact is further informed by requirements from
//! Hyperledger Fabric to support different database backends and joint experiences between
//! Sawtooth and Fabric for flexible models for execution adapters (e.g., lessons from integrating
//! Hyperledger Burrow).
//! machine or interpreter that processes smart contracts.
//!
//! ## Diving Deeper
//!
//! Transact is fundamentally a transaction processing system for state transitions. State data is
//! generally stored in a [Merkle-Radix
//! tree](https://sawtooth.hyperledger.org/docs/core/nightly/master/glossary.html#term-merkle-radix-tree),
//! a key-value database, or an SQL database. Given an initial state and a transaction, Transact
//! executes the transaction to produce a new state. These state transitions are considered “pure”
//! because only the initial state and the transaction are used as input. (In contrast, other
//! systems such as Ethereum combine state and block information to produce the new state.) As a
//! result, Transact is agnostic about framework features other than transaction execution and
//! state. Awesome, right?
//! generally stored in a Merkle-Radix tree a key-value database, or an SQL database. Given an
//! initial state and a transaction, Transact executes the transaction to produce a new state.
//! These state transitions are considered “pure” because only the initial state and the
//! transaction are used as input. (In contrast, other systems such as Ethereum combine state and
//! block information to produce the new state.) As a result, Transact is agnostic about framework
//! features other than transaction execution and state. Awesome, right?
//!
//! Transact deliberately omits other features such as consensus, blocks, chaining, and peering.
//! These features are the responsibility of the Hyperledger frameworks (such as Sawtooth and
//! Fabric) and other distributed ledger implementations. The focus on smart contract execution
//! means that Transact can be used for smart contract execution without conflicting with other
//! platform-level architectural design elements.
//! These features are the responsibility of the frameworks and other distributed ledger
//! implementations. The focus on smart contract execution means that Transact can be used for
//! smart contract execution without conflicting with other platform-level architectural design
//! elements.
//!
//! Transact includes the following components:
//!
Expand All @@ -81,37 +66,11 @@
//! interpreters that run the smart contracts. Examples of engines include WebAssembly, Ethereum
//! Virtual Machine, Sawtooth Transactions Processors, and Fabric Chain Code.
//!
//! ## Transact Features
//!
//! Hyperledger Transact includes the following current and upcoming features (not a complete
//! list):
//!
//! * Transaction execution adapters that allow different mechanisms of execution. For example,
//! Transact initially provides adapters that support both in-process and external transaction
//! execution. The in-process adapter allows creation of a single (custom) process that can execute
//! specific types of transactions. The external adapter allows execution to occur in a separate
//! process.
//! * Serial and parallel transaction scheduling that provides options for flexibility and
//! performance. Serial scheduling executes one transaction at a time, in order. Parallel
//! scheduling executes multiple transactions at a time, possibly out of order, with specific
//! constraints to guarantee a resulting state that matches the in-order execution that would occur
//! with serial scheduling. Parallel scheduling provides a substantial performance benefit.
//! * Pluggable state backends with initial support for a LMDB-backed Merkle-Radix tree
//! implementation and an in-memory Merkle-Radix tree (primarily useful for testing). Key-value
//! databases and SQL databases will also be supported in the future.
//! * Transaction receipts, which contain the resulting state changes and other information from
//! transaction execution.
//! * Events that can be generated by smart contracts. These events are captured and stored in the
//! transaction receipt.
//! * SDKs for the following languages: Rust, Python, Javascript, Go, Java (including Android),
//! Swift (iOS), C++, and .NET.
//! * Support for multiple styles of smart contracts including Sabre (WebAssembly smart contracts)
//! and Seth (EVM smart contracts).
//!
//! ## Sawtooth Compatibility Layer
//!
//! Hyperledger Transact provides optional support for smart contract engines implemented for
//! Hyperledger Sawtooth through the `sawtooth-compat` feature.
//! Transact provides optional support for smart contract engines implemented for Sawtooth through
//! the `sawtooth-compat` feature.


#[cfg(feature = "transact-context")]
mod collections;
Expand Down
6 changes: 3 additions & 3 deletions libsawtooth/src/transact/sawtooth.rs
View file
Original file line number Diff line number Diff line change
Expand Up @@ -14,8 +14,8 @@

//! Sawtooth Compatibility Layer
//!
//! This module provides a compatibility layer for use with [Hyperledger
//! Sawtooth](https://sawtooth.hyperledger.org) transaction families. It provides adapters to
//! This module provides a compatibility layer for use with
//! [Sawtooth](https://sawtooth.splinter.dev/) transaction families. It provides adapters to
//! allow the use of existing Sawtooth transaction families, implemented with the [Rust
//! SDK](https://crates.io/crates/sawtooth-sdk), in an application built with Transact.
//!
Expand All @@ -39,7 +39,7 @@ use crate::transact::protocol::transaction::{TransactionHeader, TransactionPair}
/// engines can then be compiled in to an application using Transact.
///
/// For example, the Sawtooth transaction handler for the [XO Transaction
/// Family](https://sawtooth.hyperledger.org/docs/core/releases/latest/transaction_family_specifications/xo_transaction_family.html)
/// Family](https://sawtooth.splinter.dev/docs/1.2/transaction_family_specifications/xo_transaction_family.html)
/// can be adapted as follows:
///
/// # use sawtooth_xo::handler::XoTransactionHandler;
Expand Down

0 comments on commit 0d9abab

Please sign in to comment.