Update repo for move to splintercommunity

README.md

@@ -1,10 +1,10 @@
 
-![Hyperledger Sawtooth](https://github.com/hyperledger/sawtooth-core/blob/master/images/sawtooth_logo_light_blue-small.png)
+![Sawtooth](https://github.com/splintercommunity/sawtooth-core/blob/main/images/sawtooth_logo_light_blue-small.png)
 
-Hyperledger Sawtooth
+Sawtooth
 -------------
 
-Hyperledger Sawtooth is an enterprise solution for building, deploying, and
+Sawtooth is an enterprise solution for building, deploying, and
 running distributed ledgers (also called blockchains). It provides an extremely
 modular and flexible platform for implementing transaction-based updates to
 shared state between untrusted parties coordinated by consensus algorithms.
@@ -13,28 +13,17 @@ Documentation
 -------------
 
 Documentation for how to run and extend Sawtooth is available here:
-https://sawtooth.hyperledger.org/docs/
+https://sawtooth.splinter.dev/docs/
 
-Hyperledger Sawtooth Core Developers Setup Guide can be found here: [BUILD.md](BUILD.md)
+Sawtooth Core Developers Setup Guide can be found here: [BUILD.md](https://github.com/splintercommunity/sawtooth-core/blob/main/BUILD.md)
 
-Running examples of Sawtooth blockchains can be found here:
-https://sawtooth.hyperledger.org/examples/
-
-
-Project Status
------------------
-
-This project is an _active_ Hyperledger project. It was proposed to the
-community and documented [here](https://docs.google.com/document/d/1j7YcGLJH6LkzvWdOYFIt2kpkVlLEmILErXL6t-Ky2zU/edit).
-Information on what _Active_ entails can be found in the
-[Hyperledger Project Lifecycle document](https://wiki.hyperledger.org/display/HYP/Project+Lifecycle).
 
 License
 -------
 
-Hyperledger Sawtooth software is licensed under the [Apache License Version 2.0](LICENSE) software license.
+Sawtooth software is licensed under the [Apache License Version 2.0](LICENSE) software license.
 
-Hyperledger Sawtooth documentation in the [docs](docs) subdirectory is licensed under
+Sawtooth documentation in the [docs](docs) subdirectory is licensed under
 a Creative Commons Attribution 4.0 International License.  You may obtain a copy of the
 license at: http://creativecommons.org/licenses/by/4.0/.
 

libsawtooth/Cargo.toml

@@ -1,3 +1,4 @@
+# Copyright 2024 Bitwise IO, Inc.
 # Copyright 2019 Cargill Incorporated
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -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.
 """
 

libsawtooth/src/transact/mod.rs

@@ -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:
 //!
@@ -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;

libsawtooth/src/transact/sawtooth.rs

@@ -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.
 //!
@@ -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;