Skip to content

v0.23.0
Compare
Choose a tag to compare
@xgreenx xgreenx released this 05 Mar 00:04
· 406 commits to master since this release
v0.23.0
a556d98
This commit was created on GitHub.com and signed with GitHub’s verified signature.
GPG key ID: B5690EEEBB952194
Verified
Learn about vigilant mode.

Version v0.23.0

Added

  • #1713: Added automatic impl of traits StorageWrite and StorageRead for StructuredStorage. Tables that use a Blueprint can be read and written using these interfaces provided by structured storage types.
  • #1671: Added a new Merklized blueprint that maintains the binary Merkle tree over the storage data. It supports only the insertion of the objects without removing them.
  • #1657: Moved ContractsInfo table from fuel-vm to on-chain tables, and created version-able ContractsInfoType to act as the table's data type.

Changed

  • #1723: Notify about imported blocks from the off-chain worker.
  • #1717: The fix for the #1657 to include the contract into ContractsInfo table.
  • #1657: Upgrade to fuel-vm 0.46.0.
  • #1671: The logic related to the FuelBlockIdsToHeights is moved to the off-chain worker.
  • #1663: Reduce the punishment criteria for mempool gossipping.
  • #1658: Removed Receipts table. Instead, receipts are part of the TransactionStatuses table.
  • #1640: Upgrade to fuel-vm 0.45.0.
  • #1635: Move updating of the owned messages and coins to off-chain worker.
  • #1650: Add api endpoint for getting estimates for future gas prices
  • #1649: Add api endpoint for getting latest gas price
  • #1600: Upgrade to fuel-vm 0.45.0
  • #1633: Notify services about importing of the genesis block.
  • #1625: Making relayer independent from the executor and preparation for the force transaction inclusion.
  • #1613: Add api endpoint to retrieve a message by its nonce.
  • #1612: Use AtomicView in all services for consistent results.
  • #1597: Unify namespacing for libp2p modules
  • #1591: Simplify libp2p dependencies and not depend on all sub modules directly.
  • #1590: Use AtomicView in the TxPool to read the state of the database during insertion of the transactions.
  • #1587: Use BlockHeight as a primary key for the FuelsBlock table.
  • #1585: Let NetworkBehaviour macro generate FuelBehaviorEvent in p2p
  • #1579: The change extracts the off-chain-related logic from the executor and moves it to the GraphQL off-chain worker. It creates two new concepts - Off-chain and On-chain databases where the GraphQL worker has exclusive ownership of the database and may modify it without intersecting with the On-chain database.
  • #1577: Moved insertion of sealed blocks into the BlockImporter instead of the executor.
  • #1574: Penalizes peers for sending invalid responses or for not replying at all.
  • #1601: Fix formatting in docs and check that cargo doc passes in the CI.
  • #1636: Add more docs to GraphQL DAP API.

Breaking

  • #1725: All API endpoints now are prefixed with /v1 version. New usage looks like: /v1/playground, /v1/graphql, /v1/graphql-sub, /v1/metrics, /v1/health.

  • #1722: Bugfix: Zero predicate_gas_used field during validation of the produced block.

  • #1714: The change bumps the fuel-vm to 0.47.1. It breaks several breaking changes into the protocol:

    • All malleable fields are zero during the execution and unavailable through the GTF getters. Accessing them via the memory directly is still possible, but they are zero.
    • The Transaction doesn't define the gas price anymore. The gas price is defined by the block producer and recorded in the Mint transaction at the end of the block. A price of future blocks can be fetched through a new API nedopoint and the price of the last block can be fetch or via the block or another API endpoint.
    • The GasPrice policy is replaced with the Tip policy. The user may specify in the native tokens how much he wants to pay the block producer to include his transaction in the block. It is the prioritization mechanism to incentivize the block producer to include users transactions earlier.
    • The MaxFee policy is mandatory to set. Without it, the transaction pool will reject the transaction. Since the block producer defines the gas price, the only way to control how much user agreed to pay can be done only through this policy.
    • The maturity field is removed from the Input::Coin. The same affect can be achieve with the Maturity policy on the transaction and predicate. This changes breaks how input coin is created and removes the passing of this argument.
    • The metadata of the Checked<Tx> doesn't contain max_fee and min_fee anymore. Only max_gas and min_gas. The max_fee is controlled by the user via the MaxFee policy.
    • Added automatic impl of traits StorageWrite and StorageRead for StructuredStorage. Tables that use a Blueprint can be read and written using these interfaces provided by structured storage types.

  • #1712: Make ContractUtxoInfo type a version-able enum for use in the ContractsLatestUtxotable.

  • #1657: Changed CROO gas price type from Word to DependentGasPrice. The dependent gas price values are dummy values while awaiting updated benchmarks.

  • #1671: The GraphQL API uses block height instead of the block id where it is possible. The transaction status contains block_height instead of the block_id.

  • #1675: Simplify GQL schema by disabling contract resolvers in most cases, and just return a ContractId scalar instead.

  • #1658: Receipts are part of the transaction status.
    Removed reason from the TransactionExecutionResult::Failed. It can be calculated based on the program state and receipts.
    Also, it is not possible to fetch receipts from the Transaction directly anymore. Instead, you need to fetch status and its receipts.

  • #1646: Remove redundant receipts from queries.

  • #1639: Make Merkle metadata, i.e. SparseMerkleMetadata and DenseMerkleMetadata type version-able enums

  • #1632: Make Message type a version-able enum

  • #1631: Modify api endpoint to dry run multiple transactions.

  • #1629: Use a separate database for each data domain. Each database has its own folder where data is stored.

  • #1628: Make CompressedCoin type a version-able enum

  • #1616: Make BlockHeader type a version-able enum

  • #1614: Use the default consensus key regardless of trigger mode. The change is breaking because it removes the --dev-keys argument. If the debug flag is set, the default consensus key will be used, regardless of the trigger mode.

  • #1596: Make Consensus type a version-able enum

  • #1593: Make Block type a version-able enum

  • #1576: The change moves the implementation of the storage traits for required tables from fuel-core to fuel-core-storage crate. The change also adds a more flexible configuration of the encoding/decoding per the table and allows the implementation of specific behaviors for the table in a much easier way. It unifies the encoding between database, SMTs, and iteration, preventing mismatching bytes representation on the Rust type system level. Plus, it increases the re-usage of the code by applying the same blueprint to other tables.

    It is a breaking PR because it changes database encoding/decoding for some tables.

    StructuredStorage

    The change adds a new type StructuredStorage. It is a wrapper around the key-value storage that implements the storage traits(StorageInspect, StorageMutate, StorageRead, etc) for the tables with blueprint. This blueprint works in tandem with the TableWithBlueprint trait. The table may implement TableWithBlueprint specifying the blueprint, as an example:

    impl TableWithBlueprint for ContractsRawCode {
    type Blueprint = Plain<Raw, Raw>;

    fn column() -> Column {
        Column::ContractsRawCode
    }
}

    It is a definition of the blueprint for the ContractsRawCode table. It has a plain blueprint meaning it simply encodes/decodes bytes and stores/loads them into/from the storage. As a key codec and value codec, it uses a Raw encoding/decoding that simplifies writing bytes and loads them back into the memory without applying any serialization or deserialization algorithm.

    If the table implements TableWithBlueprint and the selected codec satisfies all blueprint requirements, the corresponding storage traits for that table are implemented on the StructuredStorage type.

    Codecs

    Each blueprint allows customizing the key and value codecs. It allows the use of different codecs for different tables, taking into account the complexity and weight of the data and providing a way of more optimal implementation.

    That property may be very useful to perform migration in a more easier way. Plus, it also can be a no_std migration potentially allowing its fraud proving.

    An example of migration:

    /// Define the table for V1 value encoding/decoding.
impl TableWithBlueprint for ContractsRawCodeV1 {
    type Blueprint = Plain<Raw, Raw>;

    fn column() -> Column {
        Column::ContractsRawCode
    }
}

/// Define the table for V2 value encoding/decoding.
/// It uses `Postcard` codec for the value instead of `Raw` codec.
///
/// # Dev-note: The columns is the same.
impl TableWithBlueprint for ContractsRawCodeV2 {
    type Blueprint = Plain<Raw, Postcard>;

    fn column() -> Column {
        Column::ContractsRawCode
    }
}

fn migration(storage: &mut Database) {
    let mut iter = storage.iter_all::<ContractsRawCodeV1>(None);
    while let Ok((key, value)) = iter.next() {
        // Insert into the same table but with another codec.
        storage.storage::<ContractsRawCodeV2>().insert(key, value);
    }
}

    Structures

    The blueprint of the table defines its behavior. As an example, a Plain blueprint simply encodes/decodes bytes and stores/loads them into/from the storage. The SMT blueprint builds a sparse merkle tree on top of the key-value pairs.

    Implementing a blueprint one time, we can apply it to any table satisfying the requirements of this blueprint. It increases the re-usage of the code and minimizes duplication.

    It can be useful if we decide to create global roots for all required tables that are used in fraud proving.

    impl TableWithBlueprint for SpentMessages {
    type Blueprint = Plain<Raw, Postcard>;

    fn column() -> Column {
        Column::SpentMessages
    }
}
                 |
                 |
                \|/

impl TableWithBlueprint for SpentMessages {
    type Blueprint =
        Sparse<Raw, Postcard, SpentMessagesMerkleMetadata, SpentMessagesMerkleNodes>;

    fn column() -> Column {
        Column::SpentMessages
    }
}

    Side changes

    iter_all

    The iter_all functionality now accepts the table instead of K and V generics. It is done to use the correct codec during deserialization. Also, the table definition provides the column.

    Duplicated unit tests

    The fuel-core-storage crate provides macros that generate unit tests. Almost all tables had the same test like get, insert, remove, exist. All duplicated tests were moved to macros. The unique one still stays at the same place where it was before.

    StorageBatchMutate

    Added a new StorageBatchMutate trait that we can move to fuel-storage crate later. It allows batch operations on the storage. It may be more performant in some cases.

  • #1573: Remove nested p2p request/response encoding. Only breaks p2p networking compatibility with older fuel-core versions, but is otherwise fully internal.

What's Changed

New Contributors

Full Changelog: v0.22.0...v0.23.0

Contributors

liviudm, Voxelot, and 8 other contributors
Assets 6
Loading