update contracts

Author: PowVT

README.md

@@ -1,24 +1,36 @@
-# Sova Network Contracts
+# Sova Contracts
 
-This repository contains the smart contracts for the Sova Network. Sova smart contracts can talk directly to Bitcoin and do things like broadcast BTC transactions, decode BTC payloads, and verify signatures. 
+This repository contains the predeploy contracts for the Sova Network.
+
+Sova smart contracts can communicate directly with Bitcoin and do things like broadcast transactions, decode payloads, verify signatures, get block height and more! 
 
 ## Details
 
-Sova Network provides direct chain interaction with Bitcoin through custom precompiles, with built-in safeguards against double-spending. Use these precompiles to add Bitcoin composability to your Sova smart contracts.
+The Sova Network provides direct communicate with Bitcoin through custom precompiles. The Sova Network uses these precompiles via predeploy contracts. These precompiles come with built-in safeguards against double-spending, payload verification, current block info, and more! These features can be witnessed in action in the `uBTC.sol` native Bitcoin wrapper contract or by importing `SovaBitcoin.sol` to add Bitcoin composability to your Sova smart contracts.
 
-### Precompile Contracts
-- **L1Block**: Provides Bitcoin block information
-- **uBTC**: Bitcoin representation on Sova Network
+## Predeploy Contracts
+- **SovaL1Block**: Provides Bitcoin block information
+- **uBTC**: Native Bitcoin wrapper on the Sova Network
 
 ### Libraries
-- **SovaBitcoin**: Integration utilities
+- **SovaBitcoin**: Sova network utilities
 
 ## Build and Test
 
 ```shell
 # Build the project
 forge build
 
-# Run all tests
-forge test
+```
+
+## Deployed Bytecode verification
+
+Generate the deployed byte code locally to verify the predeploy contract code used on the Sova Network.
+
+```shell
+# uBTC.sol
+forge inspect src/uBTC.sol:uBTC deployedBytecode
+
+# SovaL1Block.sol
+forge inspect src/SovaL1Block.sol:SovaL1Block deployedBytecode
 ```

script/Counter.s.sol

@@ -1,5 +1,5 @@
-// SPDX-License-Identifier: UNLICENSED
-pragma solidity 0.8.26;
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.15;
 
 // import {Script, console} from "forge-std/Script.sol";
 // import {Counter} from "../src/Counter.sol";

src/SovaL1Block.sol

@@ -1,13 +1,13 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.15;
 
 /**
  * @title SovaL1Block
  * @author Sova Labs
- * @notice The BitcoinBlock predeploy gives users access to information about the last known
- *         Bitcoin block. Values within this contract are updated once per Sova block and can
- *         only be set by the system account. State updates are made by the protocol at the
- *         beginning of each Sova block.
+ *
+ * SovaL1Block provides information about the last known Bitcoin block. Values
+ * within this contract are updated prior to Sova block execution and can
+ * only be set by the system account.
  *
  * @custom:predeploy 0x2100000000000000000000000000000000000015
  */
@@ -21,9 +21,9 @@ contract SovaL1Block {
     /// @notice Store the last sova block the values were updated.
     uint256 public lastUpdatedBlock;
 
-    /// @custom:semver 1.0.0
+    /// @custom:semver 0.1.0-beta.1
     function version() public pure virtual returns (string memory) {
-        return "1.0.0";
+        return "0.1.0-beta.1";
     }
 
     /// @notice Address of the special depositor account.

src/lib/SovaBitcoin.sol

@@ -1,25 +1,25 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.15;
 
 /**
- * @title Sova Bitcoin
+ * @title SovaBitcoin
  * @author Sova Labs
- * @notice A comprehensive library for integrating with Bitcoin on the Sova EVM.
+ *
+ * A library for integrating with native Bitcoin precompiles on Sova.
  */
 library SovaBitcoin {
     /// @notice Address of the Bitcoin precompile contract
     address private constant BTC_PRECOMPILE = address(0x999);
+    /// @notice Native Bitcoin wrapper address
+    address public constant UBTC_ADDRESS = 0x2100000000000000000000000000000000000020;
 
-    /// @notice Bitcoin functionality selectors
+    /// @notice Bitcoin precompile selectors
     bytes4 private constant BROADCAST_BYTES = 0x00000001;
     bytes4 private constant DECODE_BYTES = 0x00000002;
     bytes4 private constant CHECKSIG_BYTES = 0x00000003;
-    bytes4 private constant BTC_DEPOSIT_ADDR_BYTES = 0x00000004;
+    bytes4 private constant ADDRESS_CONVERT_LEADING_BYTES = 0x00000004;
     bytes4 private constant CREATE_AND_SIGN_BYTES = 0x00000005;
 
-    /// @notice Bitcoin deposit address for the current network
-    address public constant UBTC_ADDRESS = 0x2100000000000000000000000000000000000020;
-
     struct Output {
         string addr;
         uint256 value;
@@ -43,12 +43,20 @@ library SovaBitcoin {
     error PrecompileCallFailed();
     error InvalidOutput(string expected, string actual);
     error InsufficientDeposit();
+    error InvalidDeposit();
     error InsufficientInput();
     error InvalidLocktime();
 
+    /// @custom:semver 0.1.0-beta.1
+    function version() public pure returns (string memory) {
+        return "0.1.0-beta.1";
+    }
+
     /**
      * @notice Decodes a raw Bitcoin transaction into a structured format
+     *
      * @param signedTx          The raw signed Bitcoin transaction
+     *
      * @return BitcoinTx        Object containing the decoded transaction data
      */
     function decodeBitcoinTx(bytes memory signedTx) internal view returns (BitcoinTx memory) {
@@ -59,26 +67,32 @@ library SovaBitcoin {
 
     /**
      * @notice Verifies the signatures in a Bitcoin transaction
+     *
      * @param signedTx       The raw signed Bitcoin transaction
+     *
      * @return success       Boolean indicating if payload is valid
      */
     function checkSignature(bytes calldata signedTx) internal view returns (bool success) {
         (success,) = BTC_PRECOMPILE.staticcall(abi.encodePacked(CHECKSIG_BYTES, signedTx));
     }
 
     /**
-     * @notice Gets the Bitcoin deposit address for the current network
-     * @return returnData      The Bitcoin address where the network receives deposits
+     * @notice Retrieves the unique deposit address for the corresponding EVM address
+     *
+     * @param addr             The EVM address to convert
+     *
+     * @return returnData      The Bitcoin deposit address in bytes format
      */
-    function getBtcNetworkReceive() internal returns (bytes memory) {
-        (bool success, bytes memory returndata) =
-            BTC_PRECOMPILE.call(abi.encodePacked(BTC_DEPOSIT_ADDR_BYTES, UBTC_ADDRESS));
+    function convertToBtcAddress(address addr) internal returns (bytes memory) {
+        (bool success, bytes memory returnData) =
+            BTC_PRECOMPILE.call(abi.encodePacked(ADDRESS_CONVERT_LEADING_BYTES, addr));
         if (!success) revert PrecompileCallFailed();
-        return returndata;
+        return returnData;
     }
 
     /**
      * @notice Broadcasts a signed Bitcoin transaction to the Bitcoin network
+     *
      * @param signedTx         The raw signed Bitcoin transaction to broadcast
      */
     function broadcastBitcoinTx(bytes memory signedTx) internal {
@@ -88,11 +102,13 @@ library SovaBitcoin {
 
     /**
      * @notice Signs and broadcasts a Bitcoin transaction from the specified signer.
+     *
      * @param signer                 The address of the entity signing the transaction
      * @param amount                 The amount in satoshis to send
      * @param btcGasLimit            Specified gas limit for the Bitcoin transaction (in satoshis)
      * @param blockHeight            The current Bitcoin block height for indexing purposes
      * @param destinationAddress     Bitcoin address receiving the funds
+     *
      * @return txid                  Bitcoin transaction ID
      */
     function vaultSpend(
@@ -120,17 +136,22 @@ library SovaBitcoin {
      *      4. Validates the locktime is not in the future
      *      5. Checks that the first output address matches the network's receive address
      *
-     * @param signedTx The raw signed Bitcoin transaction
-     * @param amount The minimum expected amount in satoshis
-     * @return btcTx The decoded Bitcoin transaction if all validations pass
+     * @param signedTx          The raw signed Bitcoin transaction
+     * @param amount            The minimum expected amount in satoshis
+     *
+     * @return btcTx            The decoded Bitcoin transaction
      */
-    function isDepositBtc(bytes memory signedTx, uint256 amount) internal returns (BitcoinTx memory) {
+    function isValidDeposit(bytes memory signedTx, uint256 amount) internal returns (BitcoinTx memory) {
         BitcoinTx memory btcTx = decodeBitcoinTx(signedTx);
 
         if (btcTx.outputs.length < 1 || btcTx.outputs.length > 3 || btcTx.outputs[0].value < amount) {
             revert InsufficientDeposit();
         }
 
+        if (btcTx.outputs[0].value != amount) {
+            revert InvalidDeposit();
+        }
+
         if (btcTx.inputs.length < 1) {
             revert InsufficientInput();
         }
@@ -139,10 +160,11 @@ library SovaBitcoin {
             revert InvalidLocktime();
         }
 
-        bytes memory recipientBtcAddress = getBtcNetworkReceive();
+        // Recover the callers unique bitcoin deposit address
+        bytes memory convertedBtcAddress = SovaBitcoin.convertToBtcAddress(msg.sender);
 
-        if (keccak256(recipientBtcAddress) != keccak256(bytes(btcTx.outputs[0].addr))) {
-            revert InvalidOutput(btcTx.outputs[0].addr, string(recipientBtcAddress));
+        if (keccak256(convertedBtcAddress) != keccak256(bytes(btcTx.outputs[0].addr))) {
+            revert InvalidOutput(btcTx.outputs[0].addr, string(convertedBtcAddress));
         }
 
         return btcTx;

src/uBTC.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.15;
 
 import "solady/auth/Ownable.sol";
 import "solady/tokens/WETH.sol";
@@ -9,14 +9,12 @@ import "./lib/SovaBitcoin.sol";
 /**
  * @title Universal Bitcoin Token (uBTC)
  * @author Sova Labs
- * @notice Bitcoin meets ERC20. Bitcoin meets composability.
+ * 
+ * Bitcoin meets ERC20. Bitcoin meets composability.
  *
  * @custom:predeploy 0x2100000000000000000000000000000000000020
  */
 contract uBTC is WETH, Ownable {
-    /**
-     * @notice Error codes
-     */
     error InsufficientDeposit();
     error InsufficientInput();
     error InsufficientAmount();
@@ -74,7 +72,7 @@ contract uBTC is WETH, Ownable {
         }
 
         // Validate if the transaction is a network deposit and get the decoded tx
-        SovaBitcoin.BitcoinTx memory btcTx = SovaBitcoin.isDepositBtc(signedTx, amount);
+        SovaBitcoin.BitcoinTx memory btcTx = SovaBitcoin.isValidDeposit(signedTx, amount);
 
         // Check if signature is valid and the inputs are unspent
         if (!SovaBitcoin.checkSignature(signedTx)) {

test/Counter.t.sol

@@ -1,5 +1,5 @@
 // SPDX-License-Identifier: MIT
-pragma solidity 0.8.26;
+pragma solidity 0.8.15;
 
 import {Test, console} from "forge-std/Test.sol";
 import {uBTC} from "../src/uBTC.sol";