essential-eth 0.5.10 → 0.5.12

package/lib/esm/utils/bytes.js

@@ -0,0 +1,245 @@
+import { logger } from '../logger/logger';
+function isHexable(value) {
+    return !!value.toHexString;
+}
+export function isBytesLike(value) {
+    return (isHexString(value) && !(value.length % 2)) || isBytes(value);
+}
+function isInteger(value) {
+    return typeof value === 'number' && value == value && value % 1 === 0;
+}
+export function isBytes(value) {
+    if (value == null) {
+        return false;
+    }
+    if (value.constructor === Uint8Array) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        return false;
+    }
+    if (!isInteger(value.length) || value.length < 0) {
+        return false;
+    }
+    for (let i = 0; i < value.length; i++) {
+        const v = value[i];
+        if (!isInteger(v) || v < 0 || v >= 256) {
+            return false;
+        }
+    }
+    return true;
+}
+export function arrayify(value, options) {
+    if (!options) {
+        options = {};
+    }
+    if (typeof value === 'number') {
+        logger.checkSafeUint53(value, 'invalid arrayify value');
+        const result = [];
+        while (value) {
+            result.unshift(value & 0xff);
+            value = parseInt(String(value / 256));
+        }
+        if (result.length === 0) {
+            result.push(0);
+        }
+        return new Uint8Array(result);
+    }
+    if (options.allowMissingPrefix &&
+        typeof value === 'string' &&
+        value.substring(0, 2) !== '0x') {
+        value = '0x' + value;
+    }
+    if (isHexable(value)) {
+        value = value.toHexString();
+    }
+    if (isHexString(value)) {
+        let hex = value.substring(2);
+        if (hex.length % 2) {
+            if (options.hexPad === 'left') {
+                hex = '0' + hex;
+            }
+            else if (options.hexPad === 'right') {
+                hex += '0';
+            }
+            else {
+                logger.throwArgumentError('hex data is odd-length', 'value', value);
+            }
+        }
+        const result = [];
+        for (let i = 0; i < hex.length; i += 2) {
+            result.push(parseInt(hex.substring(i, i + 2), 16));
+        }
+        return new Uint8Array(result);
+    }
+    if (isBytes(value)) {
+        return new Uint8Array(value);
+    }
+    return logger.throwArgumentError('invalid arrayify value', 'value', value);
+}
+export function concat(arrayOfBytesLike) {
+    const objects = arrayOfBytesLike.map((item) => arrayify(item));
+    const length = objects.reduce((accum, item) => accum + item.length, 0);
+    const result = new Uint8Array(length);
+    objects.reduce((offset, object) => {
+        result.set(object, offset);
+        return offset + object.length;
+    }, 0);
+    return result;
+}
+export function stripZeros(value) {
+    let result = arrayify(value);
+    if (result.length === 0) {
+        return result;
+    }
+    let start = 0;
+    while (start < result.length && result[start] === 0) {
+        start++;
+    }
+    if (start) {
+        result = result.slice(start);
+    }
+    return result;
+}
+export function zeroPad(value, length) {
+    value = arrayify(value);
+    if (value.length > length) {
+        logger.throwArgumentError('value out of range', 'value', value);
+    }
+    const result = new Uint8Array(length);
+    result.set(value, length - value.length);
+    return result;
+}
+export function isHexString(value, length) {
+    if (typeof value !== 'string' || !value.match(/^0x[0-9A-Fa-f]*$/)) {
+        return false;
+    }
+    if (length && value.length !== 2 + 2 * length) {
+        return false;
+    }
+    return true;
+}
+const HexCharacters = '0123456789abcdef';
+export function hexlify(value, options) {
+    if (!options) {
+        options = {};
+    }
+    if (typeof value === 'number') {
+        logger.checkSafeUint53(value, 'invalid hexlify value');
+        let hex = '';
+        while (value) {
+            hex = HexCharacters[value & 0xf] + hex;
+            value = Math.floor(value / 16);
+        }
+        if (hex.length) {
+            if (hex.length % 2) {
+                hex = '0' + hex;
+            }
+            return '0x' + hex;
+        }
+        return '0x00';
+    }
+    if (typeof value === 'bigint') {
+        value = value.toString(16);
+        if (value.length % 2) {
+            return '0x0' + value;
+        }
+        return '0x' + value;
+    }
+    if (options.allowMissingPrefix &&
+        typeof value === 'string' &&
+        value.substring(0, 2) !== '0x') {
+        value = '0x' + value;
+    }
+    if (isHexable(value)) {
+        return value.toHexString();
+    }
+    if (isHexString(value)) {
+        if (value.length % 2) {
+            if (options.hexPad === 'left') {
+                value = '0x0' + value.substring(2);
+            }
+            else if (options.hexPad === 'right') {
+                value += '0';
+            }
+            else {
+                logger.throwArgumentError('hex data is odd-length', 'value', value);
+            }
+        }
+        return value.toLowerCase();
+    }
+    if (isBytes(value)) {
+        let result = '0x';
+        for (let i = 0; i < value.length; i++) {
+            const v = value[i];
+            result += HexCharacters[(v & 0xf0) >> 4] + HexCharacters[v & 0x0f];
+        }
+        return result;
+    }
+    return logger.throwArgumentError('invalid hexlify value', 'value', value);
+}
+export function hexDataLength(data) {
+    if (typeof data !== 'string') {
+        data = hexlify(data);
+    }
+    else if (!isHexString(data) || data.length % 2) {
+        return null;
+    }
+    return (data.length - 2) / 2;
+}
+export function hexDataSlice(data, offset, endOffset) {
+    if (typeof data !== 'string') {
+        data = hexlify(data);
+    }
+    else if (!isHexString(data) || data.length % 2) {
+        logger.throwArgumentError('invalid hexData', 'value', data);
+    }
+    offset = 2 + 2 * offset;
+    if (endOffset != null) {
+        return '0x' + data.substring(offset, 2 + 2 * endOffset);
+    }
+    return '0x' + data.substring(offset);
+}
+export function hexConcat(items) {
+    let result = '0x';
+    items.forEach((item) => {
+        result += hexlify(item).substring(2);
+    });
+    return result;
+}
+export function hexValue(value) {
+    const trimmed = hexStripZeros(hexlify(value, { hexPad: 'left' }));
+    if (trimmed === '0x') {
+        return '0x0';
+    }
+    return trimmed;
+}
+export function hexStripZeros(value) {
+    if (typeof value !== 'string') {
+        value = hexlify(value);
+    }
+    if (!isHexString(value)) {
+        logger.throwArgumentError('invalid hex string', 'value', value);
+    }
+    value = value.substring(2);
+    let offset = 0;
+    while (offset < value.length && value[offset] === '0') {
+        offset++;
+    }
+    return '0x' + value.substring(offset);
+}
+export function hexZeroPad(value, length) {
+    if (typeof value !== 'string') {
+        value = hexlify(value);
+    }
+    else if (!isHexString(value)) {
+        logger.throwArgumentError('invalid hex string', 'value', value);
+    }
+    if (value.length > 2 * length + 2) {
+        logger.throwError('value out of range', { value, length });
+    }
+    while (value.length < 2 * length + 2) {
+        value = '0x0' + value.substring(2);
+    }
+    return value;
+}

package/{dist → lib/esm}/utils/compute-address.d.ts

@@ -1 +1 @@
-export declare function computeAddress(key: string): string;
+export declare function computeAddress(key: string): string;

package/lib/esm/utils/compute-address.js

@@ -0,0 +1,11 @@
+import { computePublicKey, toChecksumAddress } from '..';
+import { hexDataSlice } from './bytes';
+import { keccak256 } from './keccak256';
+export function computeAddress(key) {
+    if (!key.startsWith('0x04') &&
+        !key.startsWith('0x03') &&
+        !key.startsWith('0x02')) {
+        key = computePublicKey(key);
+    }
+    return toChecksumAddress(hexDataSlice(keccak256(hexDataSlice(key, 1)), 12));
+}

package/{dist → lib/esm}/utils/compute-public-key.d.ts

@@ -1,2 +1,2 @@
-import type { BytesLike } from './bytes';
-export declare function computePublicKey(privKey: BytesLike): string;
+import type { BytesLike } from './bytes';
+export declare function computePublicKey(privKey: BytesLike): string;

package/lib/esm/utils/compute-public-key.js

@@ -0,0 +1,6 @@
+import { Point } from '@noble/secp256k1';
+import { hexlify } from './bytes';
+export function computePublicKey(privKey) {
+    privKey = hexlify(privKey).slice(2);
+    return '0x' + Point.fromPrivateKey(privKey).toHex();
+}

package/{dist → lib/esm}/utils/ether-to-gwei.d.ts

@@ -1,3 +1,3 @@
-import type Big from 'big.js';
-import type { TinyBig } from '../shared/tiny-big/tiny-big';
-export declare function etherToGwei(etherQuantity: string | number | TinyBig | Big): TinyBig;
+import type Big from 'big.js';
+import type { TinyBig } from '../shared/tiny-big/tiny-big';
+export declare function etherToGwei(etherQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/esm/utils/ether-to-gwei.js

@@ -0,0 +1,7 @@
+import { tinyBig } from '../shared/tiny-big/tiny-big';
+import { validateType } from '../shared/validate-type';
+export function etherToGwei(etherQuantity) {
+    validateType(etherQuantity, ['string', 'number', 'object']);
+    const result = tinyBig(etherQuantity).times('1000000000');
+    return tinyBig(result);
+}

package/{dist → lib/esm}/utils/ether-to-wei.d.ts

@@ -1,3 +1,3 @@
-import type Big from 'big.js';
-import type { TinyBig } from '../shared/tiny-big/tiny-big';
-export declare function etherToWei(etherQuantity: string | number | TinyBig | Big): TinyBig;
+import type Big from 'big.js';
+import type { TinyBig } from '../shared/tiny-big/tiny-big';
+export declare function etherToWei(etherQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/esm/utils/ether-to-wei.js

@@ -0,0 +1,7 @@
+import { tinyBig } from '../shared/tiny-big/tiny-big';
+import { validateType } from '../shared/validate-type';
+export function etherToWei(etherQuantity) {
+    validateType(etherQuantity, ['string', 'number', 'object']);
+    const result = tinyBig(etherQuantity).times('1000000000000000000');
+    return tinyBig(result);
+}

package/{dist → lib/esm}/utils/gwei-to-ether.d.ts

@@ -1,3 +1,3 @@
-import type Big from 'big.js';
-import type { TinyBig } from './../shared/tiny-big/tiny-big';
-export declare function gweiToEther(gweiQuantity: string | number | TinyBig | Big): TinyBig;
+import type Big from 'big.js';
+import type { TinyBig } from './../shared/tiny-big/tiny-big';
+export declare function gweiToEther(gweiQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/esm/utils/gwei-to-ether.js

@@ -0,0 +1,7 @@
+import { tinyBig } from '../shared/tiny-big/tiny-big';
+import { validateType } from '../shared/validate-type';
+export function gweiToEther(gweiQuantity) {
+    validateType(gweiQuantity, ['string', 'number', 'object']);
+    const result = tinyBig(gweiQuantity).div('1000000000');
+    return tinyBig(result);
+}

package/{dist → lib/esm}/utils/hash-message.d.ts

@@ -1,2 +1,2 @@
-import type { Bytes } from '../index';
-export declare function hashMessage(message: Bytes | string): string;
+import type { Bytes } from '../index';
+export declare function hashMessage(message: Bytes | string): string;

package/lib/esm/utils/hash-message.js

@@ -0,0 +1,12 @@
+import { concat, keccak256, toUtf8Bytes } from '../index';
+const messagePrefix = '\x19Ethereum Signed Message:\n';
+export function hashMessage(message) {
+    if (typeof message === 'string') {
+        message = toUtf8Bytes(message);
+    }
+    return keccak256(concat([
+        toUtf8Bytes(messagePrefix),
+        toUtf8Bytes(String(message.length)),
+        message,
+    ]));
+}

package/{dist → lib/esm}/utils/is-address.d.ts

@@ -1 +1 @@
-export declare function isAddress(address: string): boolean;
+export declare function isAddress(address: string): boolean;

package/lib/esm/utils/is-address.js

@@ -0,0 +1,12 @@
+import { toChecksumAddress } from '..';
+import { validateType } from '../shared/validate-type';
+export function isAddress(address) {
+    validateType(address, ['string']);
+    try {
+        toChecksumAddress(address);
+        return true;
+    }
+    catch (error) {
+        return false;
+    }
+}

package/{dist → lib/esm}/utils/keccak256.d.ts

@@ -1,2 +1,2 @@
-import type { BytesLike } from './bytes';
-export declare function keccak256(data: BytesLike): string;
+import type { BytesLike } from './bytes';
+export declare function keccak256(data: BytesLike): string;

package/lib/esm/utils/keccak256.js

@@ -0,0 +1,13 @@
+import { Keccak } from 'sha3';
+export function keccak256(data) {
+    let bufferableData;
+    if (typeof data === 'string') {
+        bufferableData = Buffer.from(data.replace(/^0x/, ''), 'hex');
+    }
+    else {
+        bufferableData = Buffer.from(data);
+    }
+    const keccak = new Keccak(256);
+    const addressHash = '0x' + keccak.update(bufferableData).digest('hex');
+    return addressHash;
+}

package/{dist → lib/esm}/utils/solidity-keccak256.d.ts

@@ -1,2 +1,2 @@
-export declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
-export declare function solidityKeccak256(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
+export declare function pack(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;
+export declare function solidityKeccak256(types: ReadonlyArray<string>, values: ReadonlyArray<any>): string;

package/lib/esm/utils/solidity-keccak256.js

@@ -0,0 +1,85 @@
+import { Buffer } from 'buffer';
+import { hexFalse } from '../classes/utils/encode-decode-transaction';
+import { logger } from '../logger/logger';
+import { tinyBig } from '../shared/tiny-big/tiny-big';
+import { arrayify, concat, hexlify, zeroPad } from './bytes';
+import { keccak256 } from './keccak256';
+const regexBytes = new RegExp('^bytes([0-9]+)$');
+const regexNumber = new RegExp('^(u?int)([0-9]*)$');
+const regexArray = new RegExp('^(.*)\\[([0-9]*)\\]$');
+function _pack(type, value, isArray) {
+    switch (type) {
+        case 'address':
+            if (isArray) {
+                return zeroPad(value, 32);
+            }
+            return arrayify(value);
+        case 'string':
+            return Buffer.from(value);
+        case 'bytes':
+            return arrayify(value);
+        case 'bool':
+            value = value ? '0x01' : '0x00';
+            if (isArray) {
+                return zeroPad(value, 32);
+            }
+            return arrayify(value);
+    }
+    let match = type.match(regexNumber);
+    if (match) {
+        let size = parseInt(match[2] || '256');
+        if ((match[2] && String(size) !== match[2]) ||
+            size % 8 !== 0 ||
+            size === 0 ||
+            size > 256) {
+            logger.throwArgumentError('invalid number type', 'type', type);
+        }
+        if (isArray) {
+            size = 256;
+        }
+        value = tinyBig(value).toTwos(size).toNumber();
+        const hexValue = hexlify(value);
+        return zeroPad(hexValue, size / 8);
+    }
+    match = type.match(regexBytes);
+    if (match) {
+        const size = parseInt(match[1]);
+        if (String(size) !== match[1] || size === 0 || size > 32) {
+            logger.throwArgumentError('invalid bytes type', 'type', type);
+        }
+        if (arrayify(value).byteLength !== size) {
+            logger.throwArgumentError(`invalid value for ${type}`, 'value', value);
+        }
+        if (isArray) {
+            return arrayify((value + hexFalse).substring(0, 66));
+        }
+        return value;
+    }
+    match = type.match(regexArray);
+    if (match && Array.isArray(value)) {
+        const baseType = match[1];
+        const count = parseInt(match[2] || String(value.length));
+        if (count != value.length) {
+            logger.throwArgumentError(`invalid array length for ${type}`, 'value', value);
+        }
+        const result = [];
+        value.forEach(function (value) {
+            result.push(_pack(baseType, value, true));
+        });
+        return concat(result);
+    }
+    return logger.throwArgumentError('invalid type', 'type', type);
+}
+export function pack(types, values) {
+    if (types.length != values.length) {
+        logger.throwArgumentError('wrong number of values; expected ${ types.length }', 'values', values);
+    }
+    const tight = [];
+    types.forEach(function (type, index) {
+        tight.push(_pack(type, values[index]));
+    });
+    return hexlify(concat(tight));
+}
+export function solidityKeccak256(types, values) {
+    return keccak256(pack(types, values));
+}

package/{dist → lib/esm}/utils/split-signature.d.ts

@@ -1,2 +1,2 @@
-import type { Signature, SignatureLike } from './bytes';
-export declare function splitSignature(signature: SignatureLike): Signature;
+import type { Signature, SignatureLike } from './bytes';
+export declare function splitSignature(signature: SignatureLike): Signature;

package/lib/esm/utils/split-signature.js

@@ -0,0 +1,126 @@
+import { logger } from './../logger/logger';
+import { arrayify, hexlify, hexZeroPad, isBytesLike, isHexString, zeroPad, } from './bytes';
+export function splitSignature(signature) {
+    const result = {
+        r: '0x',
+        s: '0x',
+        _vs: '0x',
+        recoveryParam: 0,
+        v: 0,
+        yParityAndS: '0x',
+        compact: '0x',
+    };
+    if (isBytesLike(signature)) {
+        const bytes = arrayify(signature);
+        if (bytes.length === 64) {
+            result.v = 27 + (bytes[32] >> 7);
+            bytes[32] &= 0x7f;
+            result.r = hexlify(bytes.slice(0, 32));
+            result.s = hexlify(bytes.slice(32, 64));
+        }
+        else if (bytes.length === 65) {
+            result.r = hexlify(bytes.slice(0, 32));
+            result.s = hexlify(bytes.slice(32, 64));
+            result.v = bytes[64];
+        }
+        else {
+            logger.throwArgumentError('invalid signature string', 'signature', signature);
+        }
+        if (result.v < 27) {
+            if (result.v === 0 || result.v === 1) {
+                result.v += 27;
+            }
+            else {
+                logger.throwArgumentError('signature invalid v byte', 'signature', signature);
+            }
+        }
+        result.recoveryParam = 1 - (result.v % 2);
+        if (result.recoveryParam) {
+            bytes[32] |= 0x80;
+        }
+        result._vs = hexlify(bytes.slice(32, 64));
+    }
+    else {
+        result.r = signature.r;
+        result.s = signature.s;
+        result.v = signature.v;
+        result.recoveryParam = signature.recoveryParam;
+        result._vs = signature._vs;
+        if (result._vs != null) {
+            const vs_1 = zeroPad(arrayify(result._vs), 32);
+            result._vs = hexlify(vs_1);
+            const recoveryParam = vs_1[0] >= 128 ? 1 : 0;
+            if (result.recoveryParam == null) {
+                result.recoveryParam = recoveryParam;
+            }
+            else if (result.recoveryParam !== recoveryParam) {
+                logger.throwArgumentError('signature recoveryParam mismatch _vs', 'signature', signature);
+            }
+            vs_1[0] &= 0x7f;
+            const s = hexlify(vs_1);
+            if (result.s == null) {
+                result.s = s;
+            }
+            else if (result.s !== s) {
+                logger.throwArgumentError('signature v mismatch _vs', 'signature', signature);
+            }
+        }
+        if (result.recoveryParam == null) {
+            if (result.v == null) {
+                logger.throwArgumentError('signature missing v and recoveryParam', 'signature', signature);
+            }
+            else if (result.v === 0 || result.v === 1) {
+                result.recoveryParam = result.v;
+            }
+            else {
+                result.recoveryParam = 1 - (result.v % 2);
+            }
+        }
+        else {
+            if (result.v == null) {
+                result.v = 27 + result.recoveryParam;
+            }
+            else {
+                const recId = result.v === 0 || result.v === 1 ? result.v : 1 - (result.v % 2);
+                if (result.recoveryParam !== recId) {
+                    logger.throwArgumentError('signature recoveryParam mismatch v', 'signature', signature);
+                }
+            }
+        }
+        if (result.r == null || !isHexString(result.r)) {
+            logger.throwArgumentError('signature missing or invalid r', 'signature', signature);
+        }
+        else {
+            result.r = hexZeroPad(result.r, 32);
+        }
+        if (result.s == null || !isHexString(result.s)) {
+            logger.throwArgumentError('signature missing or invalid s', 'signature', signature);
+        }
+        else {
+            result.s = hexZeroPad(result.s, 32);
+        }
+        const vs = arrayify(result.s);
+        if (vs[0] >= 128) {
+            logger.throwArgumentError('signature s out of range', 'signature', signature);
+        }
+        if (result.recoveryParam) {
+            vs[0] |= 0x80;
+        }
+        const _vs = hexlify(vs);
+        if (result._vs) {
+            if (!isHexString(result._vs)) {
+                logger.throwArgumentError('signature invalid _vs', 'signature', signature);
+            }
+            result._vs = hexZeroPad(result._vs, 32);
+        }
+        if (result._vs == null) {
+            result._vs = _vs;
+        }
+        else if (result._vs !== _vs) {
+            logger.throwArgumentError('signature _vs mismatch v and s', 'signature', signature);
+        }
+    }
+    result.yParityAndS = result._vs;
+    result.compact = result.r + result.yParityAndS.substring(2);
+    return result;
+}

package/{dist → lib/esm}/utils/to-checksum-address.d.ts

@@ -1 +1 @@
-export declare function toChecksumAddress(address: string): string;
+export declare function toChecksumAddress(address: string): string;

package/lib/esm/utils/to-checksum-address.js

@@ -0,0 +1,25 @@
+import { Keccak } from 'sha3';
+import { validateType } from '../shared/validate-type';
+export function toChecksumAddress(address) {
+    validateType(address, ['string']);
+    if (!/^(0x)?[0-9a-f]{40}$/i.test(address)) {
+        throw new Error(`Invalid Ethereum address "${address}"`);
+    }
+    const _address = address.toLowerCase().replace(/^0x/i, '');
+    const keccak = new Keccak(256);
+    const addressHash = keccak.update(_address).digest('hex').replace(/^0x/i, '');
+    let checksumAddress = '0x';
+    for (let i = 0; i < _address.length; i++) {
+        if (parseInt(addressHash[i], 16) > 7) {
+            checksumAddress += _address[i].toUpperCase();
+        }
+        else {
+            checksumAddress += _address[i];
+        }
+    }
+    if (address.match(/([A-F].*[a-f])|([a-f].*[A-F])/) &&
+        checksumAddress !== address) {
+        throw new Error(`Invalid Checksum address for "${address}"`);
+    }
+    return checksumAddress;
+}

package/{dist → lib/esm}/utils/to-utf8-bytes.d.ts

@@ -1 +1 @@
-export declare function toUtf8Bytes(data: string): Uint8Array;
+export declare function toUtf8Bytes(data: string): Uint8Array;

package/lib/esm/utils/to-utf8-bytes.js

@@ -0,0 +1,3 @@
+export function toUtf8Bytes(data) {
+    return new Uint8Array(Buffer.from(data));
+}

package/{dist → lib/esm}/utils/wei-to-ether.d.ts

@@ -1,3 +1,3 @@
-import type Big from 'big.js';
-import type { TinyBig } from '../shared/tiny-big/tiny-big';
-export declare function weiToEther(weiQuantity: string | number | TinyBig | Big): TinyBig;
+import type Big from 'big.js';
+import type { TinyBig } from '../shared/tiny-big/tiny-big';
+export declare function weiToEther(weiQuantity: string | number | TinyBig | Big): TinyBig;

package/lib/esm/utils/wei-to-ether.js

@@ -0,0 +1,16 @@
+import { tinyBig } from '../shared/tiny-big/tiny-big';
+import { validateType } from '../shared/validate-type';
+export function weiToEther(weiQuantity) {
+    validateType(weiQuantity, ['string', 'number', 'object']);
+    try {
+        let _weiQuantity = weiQuantity;
+        if (typeof weiQuantity === 'string' && weiQuantity.slice(0, 2) === '0x') {
+            _weiQuantity = BigInt(weiQuantity).toString();
+        }
+        const result = tinyBig(_weiQuantity).div('1000000000000000000');
+        return tinyBig(result);
+    }
+    catch (error) {
+        throw error;
+    }
+}