@etherspot/modular-sdk
Version:
Etherspot Modular SDK - build with ERC-7579 smart accounts modules
287 lines • 9.4 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.BigNumber = exports.version = void 0;
exports.isBigNumberish = isBigNumberish;
exports._base36To16 = _base36To16;
exports._base16To36 = _base16To36;
exports.throwFault = throwFault;
const tslib_1 = require("tslib");
const bn_js_1 = tslib_1.__importDefault(require("bn.js"));
var BN = bn_js_1.default.BN;
exports.version = "logger/5.7.0";
const viem_1 = require("viem");
const bignumber_logger_js_1 = require("./bignumber-logger.js");
const index_js_1 = require("../common/index.js");
const logger = new bignumber_logger_js_1.Logger(exports.version);
const _constructorGuard = {};
const MAX_SAFE = 0x1fffffffffffff;
function isBigNumberish(value) {
return (value != null) && (BigNumber.isBigNumber(value) ||
(typeof (value) === "number" && (value % 1) === 0) ||
(typeof (value) === "string" && !!value.match(/^-?[0-9]+$/)) ||
(0, viem_1.isHex)(value) ||
(typeof (value) === "bigint") ||
(0, viem_1.isBytes)(value));
}
let _warnedToStringRadix = false;
class BigNumber {
constructor(constructorGuard, hex) {
if (constructorGuard !== _constructorGuard) {
logger.throwError("cannot call constructor directly; use BigNumber.from", bignumber_logger_js_1.Logger.errors.UNSUPPORTED_OPERATION, {
operation: "new (BigNumber)"
});
}
this._hex = hex;
this._isBigNumber = true;
Object.freeze(this);
}
fromTwos(value) {
return toBigNumber(toBN(this).fromTwos(value));
}
toTwos(value) {
return toBigNumber(toBN(this).toTwos(value));
}
abs() {
if (this._hex[0] === "-") {
return BigNumber.from(this._hex.substring(1));
}
return this;
}
add(other) {
return toBigNumber(toBN(this).add(toBN(other)));
}
sub(other) {
return toBigNumber(toBN(this).sub(toBN(other)));
}
div(other) {
const o = BigNumber.from(other);
if (o.isZero()) {
throwFault("division-by-zero", "div");
}
return toBigNumber(toBN(this).div(toBN(other)));
}
mul(other) {
return toBigNumber(toBN(this).mul(toBN(other)));
}
mod(other) {
const value = toBN(other);
if (value.isNeg()) {
throwFault("division-by-zero", "mod");
}
return toBigNumber(toBN(this).umod(value));
}
pow(other) {
const value = toBN(other);
if (value.isNeg()) {
throwFault("negative-power", "pow");
}
return toBigNumber(toBN(this).pow(value));
}
and(other) {
const value = toBN(other);
if (this.isNegative() || value.isNeg()) {
throwFault("unbound-bitwise-result", "and");
}
return toBigNumber(toBN(this).and(value));
}
or(other) {
const value = toBN(other);
if (this.isNegative() || value.isNeg()) {
throwFault("unbound-bitwise-result", "or");
}
return toBigNumber(toBN(this).or(value));
}
xor(other) {
const value = toBN(other);
if (this.isNegative() || value.isNeg()) {
throwFault("unbound-bitwise-result", "xor");
}
return toBigNumber(toBN(this).xor(value));
}
mask(value) {
if (this.isNegative() || value < 0) {
throwFault("negative-width", "mask");
}
return toBigNumber(toBN(this).maskn(value));
}
shl(value) {
if (this.isNegative() || value < 0) {
throwFault("negative-width", "shl");
}
return toBigNumber(toBN(this).shln(value));
}
shr(value) {
if (this.isNegative() || value < 0) {
throwFault("negative-width", "shr");
}
return toBigNumber(toBN(this).shrn(value));
}
eq(other) {
return toBN(this).eq(toBN(other));
}
lt(other) {
return toBN(this).lt(toBN(other));
}
lte(other) {
return toBN(this).lte(toBN(other));
}
gt(other) {
return toBN(this).gt(toBN(other));
}
gte(other) {
return toBN(this).gte(toBN(other));
}
isNegative() {
return (this._hex[0] === "-");
}
isZero() {
return toBN(this).isZero();
}
toNumber() {
try {
return toBN(this).toNumber();
}
catch (error) {
throwFault("overflow", "toNumber", this.toString());
}
}
toBigInt() {
try {
return BigInt(this.toString());
}
catch (e) { }
return logger.throwError("this platform does not support BigInt", bignumber_logger_js_1.Logger.errors.UNSUPPORTED_OPERATION, {
value: this.toString()
});
}
toString() {
if (arguments.length > 0) {
if (arguments[0] === 10) {
if (!_warnedToStringRadix) {
_warnedToStringRadix = true;
logger.warn("BigNumber.toString does not accept any parameters; base-10 is assumed");
}
}
else if (arguments[0] === 16) {
logger.throwError("BigNumber.toString does not accept any parameters; use bigNumber.toHexString()", bignumber_logger_js_1.Logger.errors.UNEXPECTED_ARGUMENT, {});
}
else {
logger.throwError("BigNumber.toString does not accept parameters", bignumber_logger_js_1.Logger.errors.UNEXPECTED_ARGUMENT, {});
}
}
return toBN(this).toString(10) ?? throwFault("invalid-big-number", "toString");
}
toHexString() {
return this._hex;
}
toJSON(key) {
return { type: "BigNumber", hex: this.toHexString() };
}
static from(value) {
if (value instanceof BigNumber) {
return value;
}
if (typeof (value) === "string") {
if (value.match(/^-?0x[0-9a-f]+$/i)) {
return new BigNumber(_constructorGuard, toHex(value));
}
if (value.match(/^-?[0-9]+$/)) {
return new BigNumber(_constructorGuard, toHex(new BN(value)));
}
return logger.throwArgumentError("invalid BigNumber string", "value", value);
}
if (typeof (value) === "number") {
if (value % 1) {
throwFault("underflow", "BigNumber.from", value);
}
if (value >= MAX_SAFE || value <= -MAX_SAFE) {
throwFault("overflow", "BigNumber.from", value);
}
return BigNumber.from(String(value));
}
const anyValue = value;
if (typeof (anyValue) === "bigint") {
return BigNumber.from(anyValue.toString());
}
if ((0, viem_1.isBytes)(anyValue)) {
return BigNumber.from((0, index_js_1.hexlifyValue)(anyValue));
}
if (anyValue) {
if (anyValue.toHexString) {
const hex = anyValue.toHexString();
if (typeof (hex) === "string") {
return BigNumber.from(hex);
}
}
else {
let hex = anyValue._hex;
if (hex == null && anyValue.type === "BigNumber") {
hex = anyValue.hex;
}
if (typeof (hex) === "string") {
if ((0, viem_1.isHex)(hex) || (hex[0] === "-" && (0, viem_1.isHex)(hex.substring(1)))) {
return BigNumber.from(hex);
}
}
}
}
return logger.throwArgumentError("invalid BigNumber value", "value", value);
}
static isBigNumber(value) {
return !!(value && value._isBigNumber);
}
}
exports.BigNumber = BigNumber;
function toHex(value) {
if (typeof (value) !== "string") {
return toHex(value.toString(16) ?? throwFault("toHex", "value failed to convert to string"));
}
if (value[0] === "-") {
value = value.substring(1);
if (value[0] === "-") {
throw new Error(`invalid hex value: ${value}`);
}
value = toHex(value);
if (value === "0x00") {
return value;
}
return "-" + value;
}
if (value.substring(0, 2) !== "0x") {
value = "0x" + value;
}
if (value === "0x") {
return "0x00";
}
if (value.length % 2) {
value = "0x0" + value.substring(2);
}
while (value.length > 4 && value.substring(0, 4) === "0x00") {
value = "0x" + value.substring(4);
}
return value;
}
function toBigNumber(value) {
return BigNumber.from(toHex(value));
}
function toBN(value) {
const hex = BigNumber.from(value).toHexString();
if (hex[0] === "-") {
return (new BN("-" + hex.substring(3), 16));
}
return new BN(hex.substring(2), 16);
}
function _base36To16(value) {
return (new BN(value, 36)).toString(16);
}
function _base16To36(value) {
return (new BN(value, 16)).toString(36);
}
function throwFault(fault, operation, value) {
const params = { fault: fault, operation: operation };
if (value != null) {
params.value = value;
}
return logger.throwError(fault, bignumber_logger_js_1.Logger.errors.NUMERIC_FAULT, params);
}
//# sourceMappingURL=bignumber.js.map