Squash

Author: Vectorized

README.md

@@ -60,6 +60,7 @@ tokens
 ├─ ERC721 — "Simple ERC721 implementation with storage hitchhiking"
 ├─ WETH — "Simple Wrapped Ether implementation"
 utils
+├─ Base58 — "Library for Base58 encoding and decoding"
 ├─ Base64 — "Library for Base64 encoding and decoding"
 ├─ CallContextChecker — "Call context checker mixin"
 ├─ CREATE3 — "Deterministic deployments agnostic to the initialization code"

docs/utils/base58.md

@@ -0,0 +1,44 @@
+# Base58
+
+Library to encode strings in Base58.
+
+
+
+
+
+
+<!-- customintro:start --><!-- customintro:end -->
+
+## Custom Errors
+
+### Base58DecodingError()
+
+```solidity
+error Base58DecodingError()
+```
+
+An unrecognized character was encountered or the carry has overflowed.
+
+## Encoding / Decoding
+
+### encode(bytes)
+
+```solidity
+function encode(bytes memory data)
+    internal
+    pure
+    returns (string memory result)
+```
+
+Encodes `data` into a Base58 string.
+
+### decode(string)
+
+```solidity
+function decode(string memory encoded)
+    internal
+    pure
+    returns (bytes memory result)
+```
+
+Decodes `encoded`, a Base58 string, into the original bytes.

src/Milady.sol

@@ -23,6 +23,7 @@ import "./tokens/ERC4626.sol";
 import "./tokens/ERC6909.sol";
 import "./tokens/ERC721.sol";
 import "./tokens/WETH.sol";
+import "./utils/Base58.sol";
 import "./utils/Base64.sol";
 import "./utils/CREATE3.sol";
 import "./utils/CallContextChecker.sol";

src/utils/Base58.sol

@@ -5,22 +5,35 @@ pragma solidity ^0.8.4;
 /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/Base58.sol)
 /// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Base58.sol)
 library Base58 {
-    /// @dev Encodes `data` into a base58 string.
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        CUSTOM ERRORS                       */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev An unrecognized character was encountered or the carry has overflowed.
+    error Base58DecodingError();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                    ENCODING / DECODING                     */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @dev Encodes `data` into a Base58 string.
     function encode(bytes memory data) internal pure returns (string memory result) {
+        uint256 l = data.length;
+        if (l == uint256(0)) return result;
         /// @solidity memory-safe-assembly
         assembly {
-            let l := mload(data) // `data.length`.
             let b := add(data, 0x20) // Start of `data` bytes.
             let z := 0 // Number of leading zero bytes in `data`.
+            // Count leading zero bytes.
             for {} lt(byte(0, mload(add(b, z))), lt(z, l)) {} { z := add(1, z) }
 
             // Start the output offset by an over-estimate of the length.
-            let o := add(add(mload(0x40), 0x21), add(z, div(mul(sub(l, z), 8351), 6115)))
+            let o := add(add(mload(0x40), 0x20), add(z, add(1, div(mul(sub(l, z), 8351), 6115))))
             let e := o
 
             let limbs := o
             let limbsEnd := limbs
-
+            // Populate the uint248 limbs.
             for {
                 let i := mod(l, 31)
                 if i {
@@ -32,44 +45,106 @@ library Base58 {
                 limbsEnd := add(limbsEnd, 0x20)
             }
 
-            // Use the scratch space for the lookup. We'll restore 0x40 later.
+            // Use the extended scratch space for the lookup. We'll restore 0x40 later.
             mstore(0x1f, "123456789ABCDEFGHJKLMNPQRSTUVWXY")
             mstore(0x3f, "Zabcdefghijkmnopqrstuvwxyz")
 
-            if iszero(eq(limbs, limbsEnd)) {
-                for {} 1 {} {
-                    let anyNonZero := 0
-                    for { let i := limbs } 1 {} {
-                        if mload(i) {
-                            anyNonZero := 1
-                            break
-                        }
-                        i := add(i, 0x20)
-                        if eq(i, limbsEnd) { break }
+            for {} 1 {} {
+                let anyNonZero := 0
+                for { let i := limbs } 1 {} {
+                    if mload(i) {
+                        anyNonZero := 1
+                        break
                     }
-                    if iszero(anyNonZero) { break }
-
-                    let carry := 0
-                    for { let i := limbs } 1 {} {
-                        let acc := add(shl(248, carry), mload(i))
-                        mstore(i, div(acc, 58))
-                        carry := mod(acc, 58)
-                        i := add(i, 0x20)
-                        if eq(i, limbsEnd) { break }
-                    }
-                    o := sub(o, 1)
-                    mstore8(o, mload(carry))
+                    i := add(i, 0x20)
+                    if eq(i, limbsEnd) { break }
                 }
-                for { let i := 0 } iszero(eq(i, z)) { i := add(i, 1) } {
-                    o := sub(o, 1)
-                    mstore8(o, 49) // '1' in ASCII.
+                if iszero(anyNonZero) { break }
+
+                let carry := 0
+                for { let i := limbs } 1 {} {
+                    let acc := add(shl(248, carry), mload(i))
+                    mstore(i, div(acc, 58))
+                    carry := mod(acc, 58)
+                    i := add(i, 0x20)
+                    if eq(i, limbsEnd) { break }
                 }
+                o := sub(o, 1)
+                mstore8(o, mload(carry))
+            }
+            // We probably can optimize this more by writing 32 bytes at a time.
+            for { let i := 0 } iszero(eq(i, z)) { i := add(i, 1) } {
+                o := sub(o, 1)
+                mstore8(o, 49) // '1' in ASCII.
             }
+
             let n := sub(e, o) // Compute the final length.
             result := sub(o, 0x20) // Move back one word for the length.
             mstore(result, n) // Store the length.
             mstore(add(add(result, 0x20), n), 0) // Zeroize the slot after the bytes.
             mstore(0x40, add(add(result, 0x40), n)) // Allocate memory.
         }
     }
+
+    /// @dev Decodes `encoded`, a Base58 string, into the original bytes.
+    function decode(string memory encoded) internal pure returns (bytes memory result) {
+        uint256 n = bytes(encoded).length;
+        if (n == uint256(0)) return result;
+        /// @solidity memory-safe-assembly
+        assembly {
+            let s := add(encoded, 0x20)
+            let z := 0 // Number of leading '1' in `data`.
+            // Count leading '1'.
+            for {} and(eq(49, byte(0, mload(add(s, z)))), lt(z, n)) {} { z := add(1, z) }
+
+            // Start the output offset by an over-estimate of the length.
+            let o := add(add(mload(0x40), 0x20), add(z, add(1, div(mul(sub(n, z), 7736), 10000))))
+            let e := o
+            let limbs := o
+            let limbsEnd := limbs
+            // Use the extended scratch space for the lookup. We'll restore 0x40 later.
+            mstore(0x2a, 0x30313233343536373839)
+            mstore(0x20, 0x1718191a1b1c1d1e1f20ffffffffffff2122232425262728292a2bff2c2d2e2f)
+            mstore(0x00, 0x000102030405060708ffffffffffffff090a0b0c0d0e0f10ff1112131415ff16)
+
+            for { let j := 0 } 1 {} {
+                let c := sub(byte(0, mload(add(s, j))), 49)
+                if iszero(and(shl(c, 1), 0x3fff7ff03ffbeff01ff)) {
+                    mstore(0x00, 0xe8fad793) // `Base58DecodingError()`.
+                    revert(0x1c, 0x04)
+                }
+                let carry := byte(0, mload(c))
+                for { let i := limbs } iszero(eq(i, limbsEnd)) { i := add(i, 0x20) } {
+                    let acc := add(carry, mul(58, mload(i)))
+                    mstore(i, shr(8, shl(8, acc)))
+                    carry := shr(248, acc)
+                }
+                if carry {
+                    if iszero(lt(carry, 58)) {
+                        mstore(0x00, 0xe8fad793) // `Base58DecodingError()`.
+                        revert(0x1c, 0x04)
+                    }
+                    mstore(limbsEnd, carry)
+                    limbsEnd := add(limbsEnd, 0x20)
+                }
+                j := add(j, 1)
+                if eq(j, n) { break }
+            }
+            // Copy and compact the uint248 limbs.
+            for { let i := limbs } iszero(eq(i, limbsEnd)) { i := add(i, 0x20) } {
+                o := sub(o, 31)
+                mstore(sub(o, 1), mload(i))
+            }
+            // Strip any leading zeros from the limbs.
+            for {} lt(byte(0, mload(o)), lt(o, e)) {} { o := add(o, 1) }
+            o := sub(o, z) // Move back for the leading zero bytes.
+            calldatacopy(o, calldatasize(), z) // Fill the leading zero bytes.
+
+            let l := sub(e, o) // Compute the final length.
+            result := sub(o, 0x20) // Move back one word for the length.
+            mstore(result, l) // Store the length.
+            mstore(add(add(result, 0x20), l), 0) // Zeroize the slot after the bytes.
+            mstore(0x40, add(add(result, 0x40), l)) // Allocate memory.
+        }
+    }
 }