Solidity Standard Utilities
Solidity is still very primitive and doing basic operations can be quite tedious and off-putting to newer developers. I've put together a very basic library of functions to help improve this.
The easiest way to use this library is to install it with npm as
npm install willitscale/solidity-utilIn a project based on Truffle framework you may then import and bind the libraries to the appropriate data types as seen below:
pragma solidity ^0.5.0;
import "solidity-util/lib/Strings.sol";
import "solidity-util/lib/Integers.sol";
import "solidity-util/lib/Addresses.sol";
contract MyContract {
using Strings for string;
using Integers for uint;
using Addresses for address;
using Addresses for address payable;
}This will then allow the use of the functionality listed below.
Other frameworks may require slightly different approaches than the description above.
Addresses
The functionality of this library is to extend the existing functionality of an address:
isContract(address) : bool
Check to see if the subject address is a contract on the Ethereum network
function isContract(address _addr) public {
if (_addr.isContract()) {
// Do contract specific stuff
}
}Integers
The functionality of this library is based loosely around the Java implementation:
parseInt(string) : uint
Convert an ASCII string to its unsigned integer equivalent
function parseInt() {
if (321 == Integers.parseInt("321")) {
// Matches the uint value
}
}toString() : uint
Convert an unsigned integer to its ASCII string equivalent
function toString(uint _value) returns (string) {
return _value.toString();
}toBytes(uint) : bytes
Convert an unsigned integer to a bytes equivalent
function toString(uint _value) returns (bytes) {
return _value.toBytes();
}toByte(uint8) : byte
Convert an 8-bit unsigned integer to its byte equivalent
function toByte(uint8 _value) {
if (0x1 == Integer.toByte(_value)) {
// Matching byte
}
}Strings
Please be aware that some of these functions can be quite gas heavy so use appropriately!
The functionality of this library is based loosely around the Java implementation:
- concat(string) : string
- indexOf(string) : int
- length() : uint
- substring(uint) : string
- split(string) : string[]
- compareTo(string) : bool
- compareToIgnoreCase(string) : bool
- upper(string) : string
- lower(string) : string
concat(string) : string
Concatenate two strings together.
function concat() {
string memory myVal = "firstname";
myVal = myVal.concat(" ").concat("lastname");
}indexOf(string) : int
Find the position of a character.
function indexOf() {
string memory myVal = "haystack";
uint positionOfFirstA = myVal.indexOf("a");
uint positionOfSecondA = myVal._indexOf("a", positionOfFirstA+1);
}length() : uint
Get the length of a string.
function length() {
string memory myVal = "length";
if (myVal.length() == 6) {
// Length is 6!
}
}substring(uint) : string
Get a partial section of the string.
function substring() {
string memory myVal = "sub string example";
string memory firstWord = myVal.substring(3);
string memory secondWord = myVal._substring(6,4);
}split(string) : string[]
Splits a string into an array of smaller strings based off a delimiter.
function split() {
string memory myVal = "my example split";
string[] storage split = myVal.split(" ");
if (3 == split.length) {
if(split[1].compareTo("example")) {
// Valid split length and second word
}
}
}compareTo(string) : bool
Compare two strings.
function compareTo() {
string memory myVal = "my example split";
if(myVal.compareTo("my example split")) {
// They match!
}
}compareToIgnoreCase(string) : bool
Compare two strings discarding alphabetic case.
function compareToIgnoreCase() {
string memory myVal = "my example split";
if(myVal.compareTo("mY Example Split")) {
// They match regardless of case!
}
}upper(string) : string
Converts a string to use upper alphabetic case.
function upper() {
string memory myVal = "lower";
if(myVal.upper().compareTo("LOWER")) {
// It's now upper!
}
}lower(string) : string
Converts a string to use lower alphabetic case.
function lower() {
string memory myVal = "UPPER";
if (myVal.lower().compareTo("upper")) {
// It's now lower!
}
}Feel free to contribute!