saepenatus
Version:
Web3-Onboard makes it simple to connect Ethereum hardware and software wallets to your dapp. Features standardised spec compliant web3 providers for all supported wallets, framework agnostic modern javascript UI with code splitting, CSS customization, mul
317 lines • 11.5 kB
JavaScript
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports._base16To36 = exports._base36To16 = exports.BigNumber = exports.isBigNumberish = void 0;
/**
* BigNumber
*
* A wrapper around the BN.js object. We use the BN.js library
* because it is used by elliptic, so it is required regardless.
*
*/
var bn_js_1 = __importDefault(require("bn.js"));
var BN = bn_js_1.default.BN;
var bytes_1 = require("@ethersproject/bytes");
var logger_1 = require("@ethersproject/logger");
var _version_1 = require("./_version");
var logger = new logger_1.Logger(_version_1.version);
var _constructorGuard = {};
var 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, bytes_1.isHexString)(value) ||
(typeof (value) === "bigint") ||
(0, bytes_1.isBytes)(value));
}
exports.isBigNumberish = isBigNumberish;
// Only warn about passing 10 into radix once
var _warnedToStringRadix = false;
var BigNumber = /** @class */ (function () {
function BigNumber(constructorGuard, hex) {
var _newTarget = this.constructor;
logger.checkNew(_newTarget, BigNumber);
if (constructorGuard !== _constructorGuard) {
logger.throwError("cannot call constructor directly; use BigNumber.from", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
operation: "new (BigNumber)"
});
}
this._hex = hex;
this._isBigNumber = true;
Object.freeze(this);
}
BigNumber.prototype.fromTwos = function (value) {
return toBigNumber(toBN(this).fromTwos(value));
};
BigNumber.prototype.toTwos = function (value) {
return toBigNumber(toBN(this).toTwos(value));
};
BigNumber.prototype.abs = function () {
if (this._hex[0] === "-") {
return BigNumber.from(this._hex.substring(1));
}
return this;
};
BigNumber.prototype.add = function (other) {
return toBigNumber(toBN(this).add(toBN(other)));
};
BigNumber.prototype.sub = function (other) {
return toBigNumber(toBN(this).sub(toBN(other)));
};
BigNumber.prototype.div = function (other) {
var o = BigNumber.from(other);
if (o.isZero()) {
throwFault("division by zero", "div");
}
return toBigNumber(toBN(this).div(toBN(other)));
};
BigNumber.prototype.mul = function (other) {
return toBigNumber(toBN(this).mul(toBN(other)));
};
BigNumber.prototype.mod = function (other) {
var value = toBN(other);
if (value.isNeg()) {
throwFault("cannot modulo negative values", "mod");
}
return toBigNumber(toBN(this).umod(value));
};
BigNumber.prototype.pow = function (other) {
var value = toBN(other);
if (value.isNeg()) {
throwFault("cannot raise to negative values", "pow");
}
return toBigNumber(toBN(this).pow(value));
};
BigNumber.prototype.and = function (other) {
var value = toBN(other);
if (this.isNegative() || value.isNeg()) {
throwFault("cannot 'and' negative values", "and");
}
return toBigNumber(toBN(this).and(value));
};
BigNumber.prototype.or = function (other) {
var value = toBN(other);
if (this.isNegative() || value.isNeg()) {
throwFault("cannot 'or' negative values", "or");
}
return toBigNumber(toBN(this).or(value));
};
BigNumber.prototype.xor = function (other) {
var value = toBN(other);
if (this.isNegative() || value.isNeg()) {
throwFault("cannot 'xor' negative values", "xor");
}
return toBigNumber(toBN(this).xor(value));
};
BigNumber.prototype.mask = function (value) {
if (this.isNegative() || value < 0) {
throwFault("cannot mask negative values", "mask");
}
return toBigNumber(toBN(this).maskn(value));
};
BigNumber.prototype.shl = function (value) {
if (this.isNegative() || value < 0) {
throwFault("cannot shift negative values", "shl");
}
return toBigNumber(toBN(this).shln(value));
};
BigNumber.prototype.shr = function (value) {
if (this.isNegative() || value < 0) {
throwFault("cannot shift negative values", "shr");
}
return toBigNumber(toBN(this).shrn(value));
};
BigNumber.prototype.eq = function (other) {
return toBN(this).eq(toBN(other));
};
BigNumber.prototype.lt = function (other) {
return toBN(this).lt(toBN(other));
};
BigNumber.prototype.lte = function (other) {
return toBN(this).lte(toBN(other));
};
BigNumber.prototype.gt = function (other) {
return toBN(this).gt(toBN(other));
};
BigNumber.prototype.gte = function (other) {
return toBN(this).gte(toBN(other));
};
BigNumber.prototype.isNegative = function () {
return (this._hex[0] === "-");
};
BigNumber.prototype.isZero = function () {
return toBN(this).isZero();
};
BigNumber.prototype.toNumber = function () {
try {
return toBN(this).toNumber();
}
catch (error) {
throwFault("overflow", "toNumber", this.toString());
}
return null;
};
BigNumber.prototype.toBigInt = function () {
try {
return BigInt(this.toString());
}
catch (e) { }
return logger.throwError("this platform does not support BigInt", logger_1.Logger.errors.UNSUPPORTED_OPERATION, {
value: this.toString()
});
};
BigNumber.prototype.toString = function () {
// Lots of people expect this, which we do not support, so check (See: #889)
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()", logger_1.Logger.errors.UNEXPECTED_ARGUMENT, {});
}
else {
logger.throwError("BigNumber.toString does not accept parameters", logger_1.Logger.errors.UNEXPECTED_ARGUMENT, {});
}
}
return toBN(this).toString(10);
};
BigNumber.prototype.toHexString = function () {
return this._hex;
};
BigNumber.prototype.toJSON = function (key) {
return { type: "BigNumber", hex: this.toHexString() };
};
BigNumber.from = function (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));
}
var anyValue = value;
if (typeof (anyValue) === "bigint") {
return BigNumber.from(anyValue.toString());
}
if ((0, bytes_1.isBytes)(anyValue)) {
return BigNumber.from((0, bytes_1.hexlify)(anyValue));
}
if (anyValue) {
// Hexable interface (takes priority)
if (anyValue.toHexString) {
var hex = anyValue.toHexString();
if (typeof (hex) === "string") {
return BigNumber.from(hex);
}
}
else {
// For now, handle legacy JSON-ified values (goes away in v6)
var hex = anyValue._hex;
// New-form JSON
if (hex == null && anyValue.type === "BigNumber") {
hex = anyValue.hex;
}
if (typeof (hex) === "string") {
if ((0, bytes_1.isHexString)(hex) || (hex[0] === "-" && (0, bytes_1.isHexString)(hex.substring(1)))) {
return BigNumber.from(hex);
}
}
}
}
return logger.throwArgumentError("invalid BigNumber value", "value", value);
};
BigNumber.isBigNumber = function (value) {
return !!(value && value._isBigNumber);
};
return BigNumber;
}());
exports.BigNumber = BigNumber;
// Normalize the hex string
function toHex(value) {
// For BN, call on the hex string
if (typeof (value) !== "string") {
return toHex(value.toString(16));
}
// If negative, prepend the negative sign to the normalized positive value
if (value[0] === "-") {
// Strip off the negative sign
value = value.substring(1);
// Cannot have multiple negative signs (e.g. "--0x04")
if (value[0] === "-") {
logger.throwArgumentError("invalid hex", "value", value);
}
// Call toHex on the positive component
value = toHex(value);
// Do not allow "-0x00"
if (value === "0x00") {
return value;
}
// Negate the value
return "-" + value;
}
// Add a "0x" prefix if missing
if (value.substring(0, 2) !== "0x") {
value = "0x" + value;
}
// Normalize zero
if (value === "0x") {
return "0x00";
}
// Make the string even length
if (value.length % 2) {
value = "0x0" + value.substring(2);
}
// Trim to smallest even-length string
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) {
var hex = BigNumber.from(value).toHexString();
if (hex[0] === "-") {
return (new BN("-" + hex.substring(3), 16));
}
return new BN(hex.substring(2), 16);
}
function throwFault(fault, operation, value) {
var params = { fault: fault, operation: operation };
if (value != null) {
params.value = value;
}
return logger.throwError(fault, logger_1.Logger.errors.NUMERIC_FAULT, params);
}
// value should have no prefix
function _base36To16(value) {
return (new BN(value, 36)).toString(16);
}
exports._base36To16 = _base36To16;
// value should have no prefix
function _base16To36(value) {
return (new BN(value, 16)).toString(36);
}
exports._base16To36 = _base16To36;
//# sourceMappingURL=bignumber.js.map