From 9c1e7039901d948eae386184e7ad5644b62efa87 Mon Sep 17 00:00:00 2001 From: Hadrien Croubois Date: Mon, 8 Feb 2021 21:55:56 +0100 Subject: [PATCH] Add a Strings.toHexString function (#2504) Co-authored-by: Francisco Giordano --- CHANGELOG.md | 1 + contracts/mocks/StringsMock.sol | 6 +++++ contracts/utils/Strings.sol | 45 ++++++++++++++++++++++++++++----- test/utils/Strings.test.js | 38 ++++++++++++++++++++++++++-- 4 files changed, 82 insertions(+), 8 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 02dddae05..dede348fd 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -5,6 +5,7 @@ * Now targeting the 0.8.x line of Solidity compilers. For 0.6.x (resp 0.7.x) support, use version 3.4.0 (resp 3.4.0-solc-0.7) of OpenZeppelin. * `Context`: making `_msgData` return `bytes calldata` instead of `bytes memory` ([#2492](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2492)) * `ERC20`: Removed the `_setDecimals` function and the storage slot associated to decimals. ([#2502](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2502)) +* `Strings`: addition of a `toHexString` function. ([#2504](https://github.com/OpenZeppelin/openzeppelin-contracts/pull/2504)) ## 3.4.0 (2021-02-02) diff --git a/contracts/mocks/StringsMock.sol b/contracts/mocks/StringsMock.sol index f395831e3..3cc396bac 100644 --- a/contracts/mocks/StringsMock.sol +++ b/contracts/mocks/StringsMock.sol @@ -8,4 +8,10 @@ contract StringsMock { function fromUint256(uint256 value) public pure returns (string memory) { return Strings.toString(value); } + function fromUint256Hex(uint256 value) public pure returns (string memory) { + return Strings.toHexString(value); + } + function fromUint256HexFixed(uint256 value, uint256 length) public pure returns (string memory) { + return Strings.toHexString(value, length); + } } diff --git a/contracts/utils/Strings.sol b/contracts/utils/Strings.sol index 56c276111..dac2f35e7 100644 --- a/contracts/utils/Strings.sol +++ b/contracts/utils/Strings.sol @@ -6,8 +6,10 @@ pragma solidity ^0.8.0; * @dev String operations. */ library Strings { + bytes16 private constant alphabet = "0123456789abcdef"; + /** - * @dev Converts a `uint256` to its ASCII `string` representation. + * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence @@ -23,12 +25,43 @@ library Strings { temp /= 10; } bytes memory buffer = new bytes(digits); - uint256 index = digits; - temp = value; - while (temp != 0) { - buffer[--index] = bytes1(uint8(48 + uint256(temp % 10))); - temp /= 10; + while (value != 0) { + digits -= 1; + buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); + value /= 10; } return string(buffer); } + + /** + * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. + */ + function toHexString(uint256 value) internal pure returns (string memory) { + if (value == 0) { + return "0x00"; + } + uint256 temp = value; + uint256 length = 0; + while (temp != 0) { + length++; + temp >>= 8; + } + return toHexString(value, length); + } + + /** + * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. + */ + function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { + bytes memory buffer = new bytes(2 * length + 2); + buffer[0] = "0"; + buffer[1] = "x"; + for (uint256 i = 2 * length + 1; i > 1; --i) { + buffer[i] = alphabet[value & 0xf]; + value >>= 4; + } + require(value == 0, "Strings: hex length insufficient"); + return string(buffer); + } + } diff --git a/test/utils/Strings.test.js b/test/utils/Strings.test.js index 8c16378b1..5128ce577 100644 --- a/test/utils/Strings.test.js +++ b/test/utils/Strings.test.js @@ -1,4 +1,4 @@ -const { constants } = require('@openzeppelin/test-helpers'); +const { constants, expectRevert } = require('@openzeppelin/test-helpers'); const { expect } = require('chai'); @@ -9,7 +9,7 @@ contract('Strings', function (accounts) { this.strings = await StringsMock.new(); }); - describe('from uint256', function () { + describe('from uint256 - decimal format', function () { it('converts 0', async function () { expect(await this.strings.fromUint256(0)).to.equal('0'); }); @@ -22,4 +22,38 @@ contract('Strings', function (accounts) { expect(await this.strings.fromUint256(constants.MAX_UINT256)).to.equal(constants.MAX_UINT256.toString()); }); }); + + describe('from uint256 - hex format', function () { + it('converts 0', async function () { + expect(await this.strings.fromUint256Hex(0)).to.equal('0x00'); + }); + + it('converts a positive number', async function () { + expect(await this.strings.fromUint256Hex(0x4132)).to.equal('0x4132'); + }); + + it('converts MAX_UINT256', async function () { + expect(await this.strings.fromUint256Hex(constants.MAX_UINT256)) + .to.equal(web3.utils.toHex(constants.MAX_UINT256)); + }); + }); + + describe('from uint256 - fixed hex format', function () { + it('converts a positive number (long)', async function () { + expect(await this.strings.fromUint256HexFixed(0x4132, 32)) + .to.equal('0x0000000000000000000000000000000000000000000000000000000000004132'); + }); + + it('converts a positive number (short)', async function () { + await expectRevert( + this.strings.fromUint256HexFixed(0x4132, 1), + 'Strings: hex length insufficient', + ); + }); + + it('converts MAX_UINT256', async function () { + expect(await this.strings.fromUint256HexFixed(constants.MAX_UINT256, 32)) + .to.equal(web3.utils.toHex(constants.MAX_UINT256)); + }); + }); });