add bytes32 fast-encode

Author: Amxx

contracts/utils/Base58.sol

@@ -31,13 +31,55 @@ library Base58 {
         return string(_encode(data));
     }
 
+    /**
+     * @dev Encode a `bytes32` as a Base58 `string`. This is an alternative to {encode-bytes} that is significantly
+     * faster when the input is known to be 32 bytes long.
+     *
+     * This is usefull to encode Solana addresses.
+     */
+    function encode(bytes32 data) internal pure returns (string memory) {
+        return string(_encode(data, 44));
+    }
+
     /**
      * @dev Decode a Base58 `string` into a `bytes` buffer.
+     *
+     * NOTE: This function reverts if the input string contains invalid characters.
      */
     function decode(string memory data) internal pure returns (bytes memory) {
         return _decode(bytes(data));
     }
 
+    /**
+     * @dev Internal encoding function that processes `bytes32` input. This is way faster than the generic (`bytes`)
+     * version, but is limited to 32 bytes of input (equivalent to 44 char outputs).
+     */
+    function _encode(bytes32 input, uint256 length) private pure returns (bytes memory encoded) {
+        assembly ("memory-safe") {
+            encoded := mload(0x40)
+
+            // Store the encoding table. This overlaps with the FMP that we are going to reset later anyway.
+            mstore(0x1f, "123456789ABCDEFGHJKLMNPQRSTUVWXY")
+            mstore(0x3f, "Zabcdefghijkmnopqrstuvwxyz")
+
+            for {
+                let i := length
+            } gt(i, 0) {
+                i := sub(i, 1)
+            } {
+                mstore8(add(add(encoded, 0x1f), i), mload(mod(input, 58)))
+                input := div(input, 58)
+            }
+
+            mstore(encoded, length)
+            mstore(0x40, add(add(encoded, 0x20), length))
+        }
+    }
+
+    /**
+     * @dev Internal encoding function that processes `bytes` input of arbitrary length and returns another (newly
+     * allocated) bytes object that contains the encoded base58 string.
+     */
     function _encode(bytes memory data) private pure returns (bytes memory encoded) {
         // For reference, solidity implementation
         // unchecked {
@@ -138,6 +180,12 @@ library Base58 {
         }
     }
 
+    /**
+     * @dev Internal decoding function that processes `bytes` input containing a base58 encoded string of arbitrary
+     * length and returns another (newly allocated) bytes object that contains the decoded buffer.
+     *
+     * NOTE: This function reverts if the input string contains invalid characters.
+     */
     function _decode(bytes memory data) private pure returns (bytes memory) {
         unchecked {
             uint256 b58Length = data.length;

test/utils/Base58.test.js

@@ -24,12 +24,23 @@ describe('Base58', function () {
             const hex = ethers.hexlify(buffer);
             const b58 = ethers.encodeBase58(buffer);
 
-            await expect(this.mock.$encode(hex)).to.eventually.equal(b58);
+            await expect(this.mock.$encode(ethers.Typed.bytes(hex))).to.eventually.equal(b58);
             await expect(this.mock.$decode(b58)).to.eventually.equal(hex);
           },
         );
     });
 
+    describe('encode bytes32 (solana addresses)', function () {
+      for (const buffer of Array.from({ length: 100 }).map(() => ethers.randomBytes(32))) {
+        const hex = ethers.hexlify(buffer);
+        const b58 = ethers.encodeBase58(hex).padStart(44, '1');
+
+        it(hex, async function () {
+          await expect(this.mock.$encode(ethers.Typed.bytes32(hex))).to.eventually.equal(b58, hex + ' ' + b58);
+        });
+      }
+    });
+
     // Tests case from section 5 of the (no longer active) Base58 Encoding Scheme RFC
     // https://datatracker.ietf.org/doc/html/draft-msporny-base58-03
     describe('test vectors', function () {
@@ -45,7 +56,7 @@ describe('Base58', function () {
           const buffer = (ethers.isHexString(raw) ? ethers.getBytes : ethers.toUtf8Bytes)(raw);
           const hex = ethers.hexlify(buffer);
 
-          await expect(this.mock.$encode(hex)).to.eventually.equal(b58);
+          await expect(this.mock.$encode(ethers.Typed.bytes(hex))).to.eventually.equal(b58);
           await expect(this.mock.$decode(b58)).to.eventually.equal(hex);
         });
     });