ethers.js/lib.esm/wallet/utils.js

142 lines
4.0 KiB
JavaScript
Raw Normal View History

2022-11-30 23:44:23 +03:00
/**
* @_ignore
*/
import { getBytesCopy, assertArgument, toUtf8Bytes } from "../utils/index.js";
2022-09-05 23:57:11 +03:00
export function looseArrayify(hexString) {
2023-02-19 06:18:42 +03:00
if (typeof (hexString) === "string" && !hexString.startsWith("0x")) {
hexString = "0x" + hexString;
2022-09-05 23:57:11 +03:00
}
2022-09-16 05:58:45 +03:00
return getBytesCopy(hexString);
2022-09-05 23:57:11 +03:00
}
export function zpad(value, length) {
value = String(value);
while (value.length < length) {
value = '0' + value;
}
return value;
}
export function getPassword(password) {
if (typeof (password) === 'string') {
return toUtf8Bytes(password, "NFKC");
}
2022-09-16 05:58:45 +03:00
return getBytesCopy(password);
2022-09-05 23:57:11 +03:00
}
export function spelunk(object, _path) {
const match = _path.match(/^([a-z0-9$_.-]*)(:([a-z]+))?(!)?$/i);
2022-11-09 10:57:02 +03:00
assertArgument(match != null, "invalid path", "path", _path);
2022-09-05 23:57:11 +03:00
const path = match[1];
const type = match[3];
const reqd = (match[4] === "!");
let cur = object;
for (const comp of path.toLowerCase().split('.')) {
// Search for a child object with a case-insensitive matching key
if (Array.isArray(cur)) {
if (!comp.match(/^[0-9]+$/)) {
break;
}
cur = cur[parseInt(comp)];
}
else if (typeof (cur) === "object") {
let found = null;
for (const key in cur) {
if (key.toLowerCase() === comp) {
found = cur[key];
break;
}
}
cur = found;
}
else {
cur = null;
}
if (cur == null) {
break;
}
}
2022-11-09 10:57:02 +03:00
assertArgument(!reqd || cur != null, "missing required value", "path", path);
2022-09-05 23:57:11 +03:00
if (type && cur != null) {
if (type === "int") {
if (typeof (cur) === "string" && cur.match(/^-?[0-9]+$/)) {
return parseInt(cur);
}
else if (Number.isSafeInteger(cur)) {
return cur;
}
}
if (type === "number") {
if (typeof (cur) === "string" && cur.match(/^-?[0-9.]*$/)) {
return parseFloat(cur);
}
}
if (type === "data") {
if (typeof (cur) === "string") {
return looseArrayify(cur);
}
}
if (type === "array" && Array.isArray(cur)) {
return cur;
}
if (type === typeof (cur)) {
return cur;
}
2022-11-09 10:57:02 +03:00
assertArgument(false, `wrong type found for ${type} `, "path", path);
2022-09-05 23:57:11 +03:00
}
return cur;
}
/*
export function follow(object: any, path: string): null | string {
let currentChild = object;
for (const comp of path.toLowerCase().split('/')) {
// Search for a child object with a case-insensitive matching key
let matchingChild = null;
for (const key in currentChild) {
if (key.toLowerCase() === comp) {
matchingChild = currentChild[key];
break;
}
}
if (matchingChild === null) { return null; }
currentChild = matchingChild;
}
return currentChild;
}
// "path/to/something:type!"
export function followRequired(data: any, path: string): string {
const value = follow(data, path);
if (value != null) { return value; }
return logger.throwArgumentError("invalid value", `data:${ path }`,
JSON.stringify(data));
}
*/
// See: https://www.ietf.org/rfc/rfc4122.txt (Section 4.4)
2022-11-30 23:44:23 +03:00
/*
export function uuidV4(randomBytes: BytesLike): string {
2022-09-16 05:58:45 +03:00
const bytes = getBytes(randomBytes, "randomBytes");
2022-11-30 23:44:23 +03:00
2022-09-05 23:57:11 +03:00
// Section: 4.1.3:
// - time_hi_and_version[12:16] = 0b0100
bytes[6] = (bytes[6] & 0x0f) | 0x40;
2022-11-30 23:44:23 +03:00
2022-09-05 23:57:11 +03:00
// Section 4.4
// - clock_seq_hi_and_reserved[6] = 0b0
// - clock_seq_hi_and_reserved[7] = 0b1
bytes[8] = (bytes[8] & 0x3f) | 0x80;
2022-11-30 23:44:23 +03:00
2022-09-05 23:57:11 +03:00
const value = hexlify(bytes);
2022-11-30 23:44:23 +03:00
2022-09-05 23:57:11 +03:00
return [
2022-11-30 23:44:23 +03:00
value.substring(2, 10),
value.substring(10, 14),
value.substring(14, 18),
value.substring(18, 22),
value.substring(22, 34),
2022-09-05 23:57:11 +03:00
].join("-");
}
2022-11-30 23:44:23 +03:00
*/
2022-09-05 23:57:11 +03:00
//# sourceMappingURL=utils.js.map