@etherspot/data-utils
Version:
Etherspot Data Utils
419 lines (406 loc) • 12.9 kB
JavaScript
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __esm = (fn, res) => function __init() {
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
};
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// node_modules/viem/_esm/utils/data/isHex.js
function isHex(value, { strict = true } = {}) {
if (!value)
return false;
if (typeof value !== "string")
return false;
return strict ? /^0x[0-9a-fA-F]*$/.test(value) : value.startsWith("0x");
}
var init_isHex = __esm({
"node_modules/viem/_esm/utils/data/isHex.js"() {
}
});
// src/sdk/dto/validators/is-hex32.validator.ts
var is_hex32_validator_exports = {};
__export(is_hex32_validator_exports, {
IsHex32: () => IsHex32
});
module.exports = __toCommonJS(is_hex32_validator_exports);
// src/sdk/dto/validators/is-hex.validator.ts
var import_class_validator = require("class-validator");
// src/sdk/common/rxjs/distinct-unique-key.operator.ts
var import_operators = require("rxjs/operators");
// src/sdk/common/types/bignumber.ts
var import_bn = __toESM(require("bn.js"));
// node_modules/viem/_esm/index.js
init_isHex();
// src/sdk/common/types/bignumber-logger.ts
var _permanentCensorErrors = false;
var _censorErrors = false;
var LogLevels = { debug: 1, "default": 2, info: 2, warning: 3, error: 4, off: 5 };
var _logLevel = LogLevels["default"];
var version = "logger/5.7.0";
var _globalLogger = null;
function _checkNormalize() {
try {
const missing = [];
["NFD", "NFC", "NFKD", "NFKC"].forEach((form) => {
try {
if ("test".normalize(form) !== "test") {
throw new Error("bad normalize");
}
;
} catch (error) {
missing.push(form);
}
});
if (missing.length) {
throw new Error("missing " + missing.join(", "));
}
if (String.fromCharCode(233).normalize("NFD") !== String.fromCharCode(101, 769)) {
throw new Error("broken implementation");
}
} catch (error) {
return error.message;
}
return null;
}
var _normalizeError = _checkNormalize();
var LogLevel = /* @__PURE__ */ ((LogLevel2) => {
LogLevel2["DEBUG"] = "DEBUG";
LogLevel2["INFO"] = "INFO";
LogLevel2["WARNING"] = "WARNING";
LogLevel2["ERROR"] = "ERROR";
LogLevel2["OFF"] = "OFF";
return LogLevel2;
})(LogLevel || {});
var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
ErrorCode2["UNKNOWN_ERROR"] = "UNKNOWN_ERROR";
ErrorCode2["NOT_IMPLEMENTED"] = "NOT_IMPLEMENTED";
ErrorCode2["UNSUPPORTED_OPERATION"] = "UNSUPPORTED_OPERATION";
ErrorCode2["NETWORK_ERROR"] = "NETWORK_ERROR";
ErrorCode2["SERVER_ERROR"] = "SERVER_ERROR";
ErrorCode2["TIMEOUT"] = "TIMEOUT";
ErrorCode2["BUFFER_OVERRUN"] = "BUFFER_OVERRUN";
ErrorCode2["NUMERIC_FAULT"] = "NUMERIC_FAULT";
ErrorCode2["MISSING_NEW"] = "MISSING_NEW";
ErrorCode2["INVALID_ARGUMENT"] = "INVALID_ARGUMENT";
ErrorCode2["MISSING_ARGUMENT"] = "MISSING_ARGUMENT";
ErrorCode2["UNEXPECTED_ARGUMENT"] = "UNEXPECTED_ARGUMENT";
ErrorCode2["CALL_EXCEPTION"] = "CALL_EXCEPTION";
ErrorCode2["INSUFFICIENT_FUNDS"] = "INSUFFICIENT_FUNDS";
ErrorCode2["NONCE_EXPIRED"] = "NONCE_EXPIRED";
ErrorCode2["REPLACEMENT_UNDERPRICED"] = "REPLACEMENT_UNDERPRICED";
ErrorCode2["UNPREDICTABLE_GAS_LIMIT"] = "UNPREDICTABLE_GAS_LIMIT";
ErrorCode2["TRANSACTION_REPLACED"] = "TRANSACTION_REPLACED";
ErrorCode2["ACTION_REJECTED"] = "ACTION_REJECTED";
return ErrorCode2;
})(ErrorCode || {});
var HEX = "0123456789abcdef";
var Logger = class _Logger {
static {
this.errors = ErrorCode;
}
static {
this.levels = LogLevel;
}
constructor(version3) {
Object.defineProperty(this, "version", {
enumerable: true,
value: version3,
writable: false
});
}
_log(logLevel, args) {
const level = logLevel.toLowerCase();
if (LogLevels[level] == null) {
this.throwArgumentError("invalid log level name", "logLevel", logLevel);
}
if (_logLevel > LogLevels[level]) {
return;
}
console.log.apply(console, args);
}
debug(...args) {
this._log(_Logger.levels.DEBUG, args);
}
info(...args) {
this._log(_Logger.levels.INFO, args);
}
warn(...args) {
this._log(_Logger.levels.WARNING, args);
}
makeError(message, code, params) {
if (_censorErrors) {
return this.makeError("censored error", code, {});
}
if (!code) {
code = _Logger.errors.UNKNOWN_ERROR;
}
if (!params) {
params = {};
}
const messageDetails = [];
Object.keys(params).forEach((key) => {
const value = params[key];
try {
if (value instanceof Uint8Array) {
let hex = "";
for (let i = 0; i < value.length; i++) {
hex += HEX[value[i] >> 4];
hex += HEX[value[i] & 15];
}
messageDetails.push(key + "=Uint8Array(0x" + hex + ")");
} else {
messageDetails.push(key + "=" + JSON.stringify(value));
}
} catch (error2) {
messageDetails.push(key + "=" + JSON.stringify(params[key].toString()));
}
});
messageDetails.push(`code=${code}`);
messageDetails.push(`version=${this.version}`);
const reason = message;
let url = "";
switch (code) {
case "NUMERIC_FAULT" /* NUMERIC_FAULT */: {
url = "NUMERIC_FAULT";
const fault = message;
switch (fault) {
case "overflow":
case "underflow":
case "division-by-zero":
url += "-" + fault;
break;
case "negative-power":
case "negative-width":
url += "-unsupported";
break;
case "unbound-bitwise-result":
url += "-unbound-result";
break;
}
break;
}
case "CALL_EXCEPTION" /* CALL_EXCEPTION */:
case "INSUFFICIENT_FUNDS" /* INSUFFICIENT_FUNDS */:
case "MISSING_NEW" /* MISSING_NEW */:
case "NONCE_EXPIRED" /* NONCE_EXPIRED */:
case "REPLACEMENT_UNDERPRICED" /* REPLACEMENT_UNDERPRICED */:
case "TRANSACTION_REPLACED" /* TRANSACTION_REPLACED */:
case "UNPREDICTABLE_GAS_LIMIT" /* UNPREDICTABLE_GAS_LIMIT */:
url = code;
break;
}
if (url) {
message += " [ See: https://links.ethers.org/v5-errors-" + url + " ]";
}
if (messageDetails.length) {
message += " (" + messageDetails.join(", ") + ")";
}
const error = new Error(message);
error.reason = reason;
error.code = code;
Object.keys(params).forEach(function(key) {
error[key] = params[key];
});
return error;
}
throwError(message, code, params) {
throw this.makeError(message, code, params);
}
throwArgumentError(message, name, value) {
return this.throwError(message, _Logger.errors.INVALID_ARGUMENT, {
argument: name,
value
});
}
assert(condition, message, code, params) {
if (!!condition) {
return;
}
this.throwError(message, code, params);
}
assertArgument(condition, message, name, value) {
if (!!condition) {
return;
}
this.throwArgumentError(message, name, value);
}
checkNormalize(message) {
if (message == null) {
message = "platform missing String.prototype.normalize";
}
if (_normalizeError) {
this.throwError("platform missing String.prototype.normalize", _Logger.errors.UNSUPPORTED_OPERATION, {
operation: "String.prototype.normalize",
form: _normalizeError
});
}
}
checkSafeUint53(value, message) {
if (typeof value !== "number") {
return;
}
if (message == null) {
message = "value not safe";
}
if (value < 0 || value >= 9007199254740991) {
this.throwError(message, _Logger.errors.NUMERIC_FAULT, {
operation: "checkSafeInteger",
fault: "out-of-safe-range",
value
});
}
if (value % 1) {
this.throwError(message, _Logger.errors.NUMERIC_FAULT, {
operation: "checkSafeInteger",
fault: "non-integer",
value
});
}
}
checkArgumentCount(count, expectedCount, message) {
if (message) {
message = ": " + message;
} else {
message = "";
}
if (count < expectedCount) {
this.throwError("missing argument" + message, _Logger.errors.MISSING_ARGUMENT, {
count,
expectedCount
});
}
if (count > expectedCount) {
this.throwError("too many arguments" + message, _Logger.errors.UNEXPECTED_ARGUMENT, {
count,
expectedCount
});
}
}
checkNew(target, kind) {
if (target === Object || target == null) {
this.throwError("missing new", _Logger.errors.MISSING_NEW, { name: kind.name });
}
}
checkAbstract(target, kind) {
if (target === kind) {
this.throwError(
"cannot instantiate abstract class " + JSON.stringify(kind.name) + " directly; use a sub-class",
_Logger.errors.UNSUPPORTED_OPERATION,
{ name: target.name, operation: "new" }
);
} else if (target === Object || target == null) {
this.throwError("missing new", _Logger.errors.MISSING_NEW, { name: kind.name });
}
}
static globalLogger() {
if (!_globalLogger) {
_globalLogger = new _Logger(version);
}
return _globalLogger;
}
static setCensorship(censorship, permanent) {
if (!censorship && permanent) {
this.globalLogger().throwError("cannot permanently disable censorship", _Logger.errors.UNSUPPORTED_OPERATION, {
operation: "setCensorship"
});
}
if (_permanentCensorErrors) {
if (!censorship) {
return;
}
this.globalLogger().throwError("error censorship permanent", _Logger.errors.UNSUPPORTED_OPERATION, {
operation: "setCensorship"
});
}
_censorErrors = !!censorship;
_permanentCensorErrors = !!permanent;
}
static setLogLevel(logLevel) {
const level = LogLevels[logLevel.toLowerCase()];
if (level == null) {
_Logger.globalLogger().warn("invalid log level - " + logLevel);
return;
}
_logLevel = level;
}
static from(version3) {
return new _Logger(version3);
}
};
// src/sdk/common/types/bignumber.ts
var version2 = "logger/5.7.0";
var logger = new Logger(version2);
// src/sdk/common/utils/hashing-utils.ts
function isHex2(hex, size = 0) {
let result = isHex(hex);
if (result && size > 0) {
result = hex.length === size * 2 + 2;
}
return result;
}
// src/sdk/common/rxjs/object.subject.ts
var import_rxjs = require("rxjs");
// src/sdk/common/transformers/transform-big-number.ts
var import_class_transformer = require("class-transformer");
// src/sdk/dto/validators/is-hex.validator.ts
function IsHex(options = {}, validationOptions = {}) {
return (object, propertyName) => {
const { size } = options;
let message = `${propertyName} must be hex`;
if (size > 0) {
message = `${message} with ${size} size`;
}
(0, import_class_validator.registerDecorator)({
propertyName,
options: {
message,
...validationOptions
},
name: "isHex",
target: object.constructor,
constraints: [],
validator: {
validate(value) {
let result = isHex2(value);
if (result && size > 0) {
result = value.length === size * 2 + 2;
}
return result;
}
}
});
};
}
// src/sdk/dto/validators/is-hex32.validator.ts
function IsHex32(options = {}) {
return IsHex(
{
size: 32
},
options
);
}
//# sourceMappingURL=is-hex32.validator.js.map