@norionsoft/hd-derivations 1.0.0-beta.0

package/build/browser/types-DRp_D8oF.js

@@ -0,0 +1,1021 @@
+import { b as bs58check } from './index-BHlS2yKt.js';
+import { B as Buffer } from './index-CjeBPB5t.js';
+import { w as writeUInt32, d as concat } from './browser-D9H9snNo.js';
+
+// src/actions/await/awaitAsync.ts
+
+// src/storages/globalConfig/globalConfig.ts
+var store;
+function getGlobalConfig(config2) {
+  return {
+    lang: config2?.lang ?? store?.lang,
+    message: config2?.message,
+    abortEarly: config2?.abortEarly ?? store?.abortEarly,
+    abortPipeEarly: config2?.abortPipeEarly ?? store?.abortPipeEarly
+  };
+}
+
+// src/storages/globalMessage/globalMessage.ts
+var store2;
+function getGlobalMessage(lang) {
+  return store2?.get(lang);
+}
+
+// src/storages/schemaMessage/schemaMessage.ts
+var store3;
+function getSchemaMessage(lang) {
+  return store3?.get(lang);
+}
+
+// src/storages/specificMessage/specificMessage.ts
+var store4;
+function getSpecificMessage(reference, lang) {
+  return store4?.get(reference)?.get(lang);
+}
+
+// src/utils/_stringify/_stringify.ts
+function _stringify(input) {
+  const type = typeof input;
+  if (type === "string") {
+    return `"${input}"`;
+  }
+  if (type === "number" || type === "bigint" || type === "boolean") {
+    return `${input}`;
+  }
+  if (type === "object" || type === "function") {
+    return (input && Object.getPrototypeOf(input)?.constructor?.name) ?? "null";
+  }
+  return type;
+}
+
+// src/utils/_addIssue/_addIssue.ts
+function _addIssue(context, label, dataset, config2, other) {
+  const input = other && "input" in other ? other.input : dataset.value;
+  const expected = other?.expected ?? context.expects ?? null;
+  const received = other?.received ?? _stringify(input);
+  const issue = {
+    kind: context.kind,
+    type: context.type,
+    input,
+    expected,
+    received,
+    message: `Invalid ${label}: ${expected ? `Expected ${expected} but r` : "R"}eceived ${received}`,
+    // @ts-expect-error
+    requirement: context.requirement,
+    path: other?.path,
+    issues: other?.issues,
+    lang: config2.lang,
+    abortEarly: config2.abortEarly,
+    abortPipeEarly: config2.abortPipeEarly
+  };
+  const isSchema = context.kind === "schema";
+  const message = other?.message ?? // @ts-expect-error
+  context.message ?? getSpecificMessage(context.reference, issue.lang) ?? (isSchema ? getSchemaMessage(issue.lang) : null) ?? config2.message ?? getGlobalMessage(issue.lang);
+  if (message) {
+    issue.message = typeof message === "function" ? message(issue) : message;
+  }
+  if (isSchema) {
+    dataset.typed = false;
+  }
+  if (dataset.issues) {
+    dataset.issues.push(issue);
+  } else {
+    dataset.issues = [issue];
+  }
+}
+
+// src/utils/ValiError/ValiError.ts
+var ValiError = class extends Error {
+  /**
+   * The error issues.
+   */
+  issues;
+  /**
+   * Creates a Valibot error with useful information.
+   *
+   * @param issues The error issues.
+   */
+  constructor(issues) {
+    super(issues[0].message);
+    this.name = "ValiError";
+    this.issues = issues;
+  }
+};
+
+// src/actions/integer/integer.ts
+function integer(message) {
+  return {
+    kind: "validation",
+    type: "integer",
+    reference: integer,
+    async: false,
+    expects: null,
+    requirement: Number.isInteger,
+    message,
+    _run(dataset, config2) {
+      if (dataset.typed && !this.requirement(dataset.value)) {
+        _addIssue(this, "integer", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/actions/length/length.ts
+function length(requirement, message) {
+  return {
+    kind: "validation",
+    type: "length",
+    reference: length,
+    async: false,
+    expects: `${requirement}`,
+    requirement,
+    message,
+    _run(dataset, config2) {
+      if (dataset.typed && dataset.value.length !== this.requirement) {
+        _addIssue(this, "length", dataset, config2, {
+          received: `${dataset.value.length}`
+        });
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/actions/maxValue/maxValue.ts
+function maxValue(requirement, message) {
+  return {
+    kind: "validation",
+    type: "max_value",
+    reference: maxValue,
+    async: false,
+    expects: `<=${requirement instanceof Date ? requirement.toJSON() : _stringify(requirement)}`,
+    requirement,
+    message,
+    _run(dataset, config2) {
+      if (dataset.typed && dataset.value > this.requirement) {
+        _addIssue(this, "value", dataset, config2, {
+          received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/actions/minValue/minValue.ts
+function minValue(requirement, message) {
+  return {
+    kind: "validation",
+    type: "min_value",
+    reference: minValue,
+    async: false,
+    expects: `>=${requirement instanceof Date ? requirement.toJSON() : _stringify(requirement)}`,
+    requirement,
+    message,
+    _run(dataset, config2) {
+      if (dataset.typed && dataset.value < this.requirement) {
+        _addIssue(this, "value", dataset, config2, {
+          received: dataset.value instanceof Date ? dataset.value.toJSON() : _stringify(dataset.value)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/actions/regex/regex.ts
+function regex(requirement, message) {
+  return {
+    kind: "validation",
+    type: "regex",
+    reference: regex,
+    async: false,
+    expects: `${requirement}`,
+    requirement,
+    message,
+    _run(dataset, config2) {
+      if (dataset.typed && !this.requirement.test(dataset.value)) {
+        _addIssue(this, "format", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/actions/transform/transform.ts
+function transform(operation) {
+  return {
+    kind: "transformation",
+    type: "transform",
+    reference: transform,
+    async: false,
+    operation,
+    _run(dataset) {
+      dataset.value = this.operation(dataset.value);
+      return dataset;
+    }
+  };
+}
+
+// src/methods/getDefault/getDefault.ts
+function getDefault(schema, dataset, config2) {
+  return typeof schema.default === "function" ? (
+    // @ts-expect-error
+    schema.default(dataset, config2)
+  ) : (
+    // @ts-expect-error
+    schema.default
+  );
+}
+
+// src/schemas/boolean/boolean.ts
+function boolean(message) {
+  return {
+    kind: "schema",
+    type: "boolean",
+    reference: boolean,
+    expects: "boolean",
+    async: false,
+    message,
+    _run(dataset, config2) {
+      if (typeof dataset.value === "boolean") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/schemas/instance/instance.ts
+function instance(class_, message) {
+  return {
+    kind: "schema",
+    type: "instance",
+    reference: instance,
+    expects: class_.name,
+    async: false,
+    class: class_,
+    message,
+    _run(dataset, config2) {
+      if (dataset.value instanceof this.class) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/schemas/number/number.ts
+function number(message) {
+  return {
+    kind: "schema",
+    type: "number",
+    reference: number,
+    expects: "number",
+    async: false,
+    message,
+    _run(dataset, config2) {
+      if (typeof dataset.value === "number" && !isNaN(dataset.value)) {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/schemas/object/object.ts
+function object(entries, message) {
+  return {
+    kind: "schema",
+    type: "object",
+    reference: object,
+    expects: "Object",
+    async: false,
+    entries,
+    message,
+    _run(dataset, config2) {
+      const input = dataset.value;
+      if (input && typeof input === "object") {
+        dataset.typed = true;
+        dataset.value = {};
+        for (const key in this.entries) {
+          const value2 = input[key];
+          const valueDataset = this.entries[key]._run(
+            { typed: false, value: value2 },
+            config2
+          );
+          if (valueDataset.issues) {
+            const pathItem = {
+              type: "object",
+              origin: "value",
+              input,
+              key,
+              value: value2
+            };
+            for (const issue of valueDataset.issues) {
+              if (issue.path) {
+                issue.path.unshift(pathItem);
+              } else {
+                issue.path = [pathItem];
+              }
+              dataset.issues?.push(issue);
+            }
+            if (!dataset.issues) {
+              dataset.issues = valueDataset.issues;
+            }
+            if (config2.abortEarly) {
+              dataset.typed = false;
+              break;
+            }
+          }
+          if (!valueDataset.typed) {
+            dataset.typed = false;
+          }
+          if (valueDataset.value !== void 0 || key in input) {
+            dataset.value[key] = valueDataset.value;
+          }
+        }
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/schemas/optional/optional.ts
+function optional(wrapped, ...args) {
+  const schema = {
+    kind: "schema",
+    type: "optional",
+    reference: optional,
+    expects: `${wrapped.expects} | undefined`,
+    async: false,
+    wrapped,
+    _run(dataset, config2) {
+      if (dataset.value === void 0) {
+        if ("default" in this) {
+          dataset.value = getDefault(
+            this,
+            dataset,
+            config2
+          );
+        }
+        if (dataset.value === void 0) {
+          dataset.typed = true;
+          return dataset;
+        }
+      }
+      return this.wrapped._run(dataset, config2);
+    }
+  };
+  if (0 in args) {
+    schema.default = args[0];
+  }
+  return schema;
+}
+
+// src/schemas/string/string.ts
+function string(message) {
+  return {
+    kind: "schema",
+    type: "string",
+    reference: string,
+    expects: "string",
+    async: false,
+    message,
+    _run(dataset, config2) {
+      if (typeof dataset.value === "string") {
+        dataset.typed = true;
+      } else {
+        _addIssue(this, "type", dataset, config2);
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/schemas/union/utils/_subIssues/_subIssues.ts
+function _subIssues(datasets) {
+  let issues;
+  if (datasets) {
+    for (const dataset of datasets) {
+      if (issues) {
+        issues.push(...dataset.issues);
+      } else {
+        issues = dataset.issues;
+      }
+    }
+  }
+  return issues;
+}
+
+// src/schemas/union/union.ts
+function union(options, message) {
+  return {
+    kind: "schema",
+    type: "union",
+    reference: union,
+    expects: [...new Set(options.map((option) => option.expects))].join(" | ") || "never",
+    async: false,
+    options,
+    message,
+    _run(dataset, config2) {
+      let validDataset;
+      let typedDatasets;
+      let untypedDatasets;
+      for (const schema of this.options) {
+        const optionDataset = schema._run(
+          { typed: false, value: dataset.value },
+          config2
+        );
+        if (optionDataset.typed) {
+          if (optionDataset.issues) {
+            if (typedDatasets) {
+              typedDatasets.push(optionDataset);
+            } else {
+              typedDatasets = [optionDataset];
+            }
+          } else {
+            validDataset = optionDataset;
+            break;
+          }
+        } else {
+          if (untypedDatasets) {
+            untypedDatasets.push(optionDataset);
+          } else {
+            untypedDatasets = [optionDataset];
+          }
+        }
+      }
+      if (validDataset) {
+        return validDataset;
+      }
+      if (typedDatasets) {
+        if (typedDatasets.length === 1) {
+          return typedDatasets[0];
+        }
+        _addIssue(this, "type", dataset, config2, {
+          issues: _subIssues(typedDatasets)
+        });
+        dataset.typed = true;
+      } else if (untypedDatasets?.length === 1) {
+        return untypedDatasets[0];
+      } else {
+        _addIssue(this, "type", dataset, config2, {
+          issues: _subIssues(untypedDatasets)
+        });
+      }
+      return dataset;
+    }
+  };
+}
+
+// src/methods/parse/parse.ts
+function parse(schema, input, config2) {
+  const dataset = schema._run(
+    { typed: false, value: input },
+    getGlobalConfig(config2)
+  );
+  if (dataset.issues) {
+    throw new ValiError(dataset.issues);
+  }
+  return dataset.value;
+}
+
+// src/methods/pipe/pipe.ts
+function pipe(...pipe2) {
+  return {
+    ...pipe2[0],
+    pipe: pipe2,
+    _run(dataset, config2) {
+      for (const item of pipe2) {
+        if (item.kind !== "metadata") {
+          if (dataset.issues && (item.kind === "schema" || item.kind === "transformation")) {
+            dataset.typed = false;
+            break;
+          }
+          if (!dataset.issues || !config2.abortEarly && !config2.abortPipeEarly) {
+            dataset = item._run(dataset, config2);
+          }
+        }
+      }
+      return dataset;
+    }
+  };
+}
+
+function decodeRaw(buffer, version) {
+    // uncompressed
+    if (buffer.length === 33) {
+        return {
+            version: buffer[0],
+            privateKey: buffer.slice(1, 33),
+            compressed: false
+        };
+    }
+    // invalid length
+    if (buffer.length !== 34)
+        throw new Error('Invalid WIF length');
+    // invalid compression flag
+    if (buffer[33] !== 0x01)
+        throw new Error('Invalid compression flag');
+    return {
+        version: buffer[0],
+        privateKey: buffer.slice(1, 33),
+        compressed: true
+    };
+}
+function encodeRaw(version, privateKey, compressed) {
+    if (privateKey.length !== 32)
+        throw new TypeError('Invalid privateKey length');
+    var result = new Uint8Array(compressed ? 34 : 33);
+    var view = new DataView(result.buffer);
+    view.setUint8(0, version);
+    result.set(privateKey, 1);
+    if (compressed) {
+        result[33] = 0x01;
+    }
+    return result;
+}
+function decode(str, version) {
+    return decodeRaw(bs58check.decode(str));
+}
+function encode(wif) {
+    return bs58check.encode(encodeRaw(wif.version, wif.privateKey, wif.compressed));
+}
+
+const bitcoin = {
+  messagePrefix: '\x18Bitcoin Signed Message:\n',
+  bech32: 'bc',
+  bip32: {
+    public: 0x0488b21e,
+    private: 0x0488ade4,
+  },
+  pubKeyHash: 0x00,
+  scriptHash: 0x05,
+  wif: 0x80,
+};
+
+const Uint32Schema = pipe(
+  number(),
+  integer(),
+  minValue(0),
+  maxValue(0xffffffff),
+);
+const Uint8Schema = pipe(
+  number(),
+  integer(),
+  minValue(0),
+  maxValue(0xff),
+);
+const NetworkSchema = object({
+  messagePrefix: union([string(), instance(Uint8Array)]),
+  bech32: string(),
+  bip32: object({
+    public: Uint32Schema,
+    private: Uint32Schema,
+  }),
+  pubKeyHash: Uint8Schema,
+  scriptHash: Uint8Schema,
+  wif: Uint8Schema,
+});
+const Buffer256Bit = pipe(instance(Uint8Array), length(32));
+
+const h = (hex) => Buffer.from(hex, 'hex');
+function testEcc(ecc) {
+  assert(
+    ecc.isPoint(
+      h('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+    ),
+  );
+  assert(
+    !ecc.isPoint(
+      h('030000000000000000000000000000000000000000000000000000000000000005'),
+    ),
+  );
+  assert(
+    ecc.isPrivate(
+      h('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+    ),
+  );
+  // order - 1
+  assert(
+    ecc.isPrivate(
+      h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140'),
+    ),
+  );
+  // 0
+  assert(
+    !ecc.isPrivate(
+      h('0000000000000000000000000000000000000000000000000000000000000000'),
+    ),
+  );
+  // order
+  assert(
+    !ecc.isPrivate(
+      h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),
+    ),
+  );
+  // order + 1
+  assert(
+    !ecc.isPrivate(
+      h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364142'),
+    ),
+  );
+  // 1 + 0 == 1
+  assert(
+    Buffer.from(
+      ecc.privateAdd(
+        h('0000000000000000000000000000000000000000000000000000000000000001'),
+        h('0000000000000000000000000000000000000000000000000000000000000000'),
+      ),
+    ).equals(
+      h('0000000000000000000000000000000000000000000000000000000000000001'),
+    ),
+  );
+  // -3 + 3 == 0
+  assert(
+    ecc.privateAdd(
+      h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413e'),
+      h('0000000000000000000000000000000000000000000000000000000000000003'),
+    ) === null,
+  );
+  assert(
+    Buffer.from(
+      ecc.privateAdd(
+        h('e211078564db65c3ce7704f08262b1f38f1ef412ad15b5ac2d76657a63b2c500'),
+        h('b51fbb69051255d1becbd683de5848242a89c229348dd72896a87ada94ae8665'),
+      ),
+    ).equals(
+      h('9730c2ee69edbb958d42db7460bafa18fef9d955325aec99044c81c8282b0a24'),
+    ),
+  );
+  assert(
+    Buffer.from(
+      ecc.privateNegate(
+        h('0000000000000000000000000000000000000000000000000000000000000001'),
+      ),
+    ).equals(
+      h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140'),
+    ),
+  );
+  assert(
+    Buffer.from(
+      ecc.privateNegate(
+        h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd036413e'),
+      ),
+    ).equals(
+      h('0000000000000000000000000000000000000000000000000000000000000003'),
+    ),
+  );
+  assert(
+    Buffer.from(
+      ecc.privateNegate(
+        h('b1121e4088a66a28f5b6b0f5844943ecd9f610196d7bb83b25214b60452c09af'),
+      ),
+    ).equals(
+      h('4eede1bf775995d70a494f0a7bb6bc11e0b8cccd41cce8009ab1132c8b0a3792'),
+    ),
+  );
+  assert(
+    Buffer.from(
+      ecc.pointCompress(
+        h(
+          '0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
+        ),
+        true,
+      ),
+    ).equals(
+      h('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+    ),
+  );
+  assert(
+    Buffer.from(
+      ecc.pointCompress(
+        h(
+          '0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
+        ),
+        false,
+      ),
+    ).equals(
+      h(
+        '0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
+      ),
+    ),
+  );
+  assert(
+    Buffer.from(
+      ecc.pointCompress(
+        h('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+        true,
+      ),
+    ).equals(
+      h('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+    ),
+  );
+  assert(
+    Buffer.from(
+      ecc.pointCompress(
+        h('0279be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+        false,
+      ),
+    ).equals(
+      h(
+        '0479be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798483ada7726a3c4655da4fbfc0e1108a8fd17b448a68554199c47d08ffb10d4b8',
+      ),
+    ),
+  );
+  assert(
+    Buffer.from(
+      ecc.pointFromScalar(
+        h('b1121e4088a66a28f5b6b0f5844943ecd9f610196d7bb83b25214b60452c09af'),
+      ),
+    ).equals(
+      h('02b07ba9dca9523b7ef4bd97703d43d20399eb698e194704791a25ce77a400df99'),
+    ),
+  );
+  assert(
+    ecc.xOnlyPointAddTweak(
+      h('79be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+      h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140'),
+    ) === null,
+  );
+  let xOnlyRes = ecc.xOnlyPointAddTweak(
+    h('1617d38ed8d8657da4d4761e8057bc396ea9e4b9d29776d4be096016dbd2509b'),
+    h('a8397a935f0dfceba6ba9618f6451ef4d80637abf4e6af2669fbc9de6a8fd2ac'),
+  );
+  assert(
+    Buffer.from(xOnlyRes.xOnlyPubkey).equals(
+      h('e478f99dab91052ab39a33ea35fd5e6e4933f4d28023cd597c9a1f6760346adf'),
+    ) && xOnlyRes.parity === 1,
+  );
+  xOnlyRes = ecc.xOnlyPointAddTweak(
+    h('2c0b7cf95324a07d05398b240174dc0c2be444d96b159aa6c7f7b1e668680991'),
+    h('823c3cd2142744b075a87eade7e1b8678ba308d566226a0056ca2b7a76f86b47'),
+  );
+  assert(
+    Buffer.from(xOnlyRes.xOnlyPubkey).equals(
+      h('9534f8dc8c6deda2dc007655981c78b49c5d96c778fbf363462a11ec9dfd948c'),
+    ) && xOnlyRes.parity === 0,
+  );
+  assert(
+    Buffer.from(
+      ecc.sign(
+        h('5e9f0a0d593efdcf78ac923bc3313e4e7d408d574354ee2b3288c0da9fbba6ed'),
+        h('fffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364140'),
+      ),
+    ).equals(
+      h(
+        '54c4a33c6423d689378f160a7ff8b61330444abb58fb470f96ea16d99d4a2fed07082304410efa6b2943111b6a4e0aaa7b7db55a07e9861d1fb3cb1f421044a5',
+      ),
+    ),
+  );
+  assert(
+    ecc.verify(
+      h('5e9f0a0d593efdcf78ac923bc3313e4e7d408d574354ee2b3288c0da9fbba6ed'),
+      h('0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798'),
+      h(
+        '54c4a33c6423d689378f160a7ff8b61330444abb58fb470f96ea16d99d4a2fed07082304410efa6b2943111b6a4e0aaa7b7db55a07e9861d1fb3cb1f421044a5',
+      ),
+    ),
+  );
+  if (ecc.signSchnorr) {
+    assert(
+      Buffer.from(
+        ecc.signSchnorr(
+          h('7e2d58d8b3bcdf1abadec7829054f90dda9805aab56c77333024b9d0a508b75c'),
+          h('c90fdaa22168c234c4c6628b80dc1cd129024e088a67cc74020bbea63b14e5c9'),
+          h('c87aa53824b4d7ae2eb035a2b5bbbccc080e76cdc6d1692c4b0b62d798e6d906'),
+        ),
+      ).equals(
+        h(
+          '5831aaeed7b44bb74e5eab94ba9d4294c49bcf2a60728d8b4c200f50dd313c1bab745879a5ad954a72c45a91c3a51d3c7adea98d82f8481e0e1e03674a6f3fb7',
+        ),
+      ),
+    );
+  }
+  if (ecc.verifySchnorr) {
+    assert(
+      ecc.verifySchnorr(
+        h('7e2d58d8b3bcdf1abadec7829054f90dda9805aab56c77333024b9d0a508b75c'),
+        h('dd308afec5777e13121fa72b9cc1b7cc0139715309b086c960e18fd969774eb8'),
+        h(
+          '5831aaeed7b44bb74e5eab94ba9d4294c49bcf2a60728d8b4c200f50dd313c1bab745879a5ad954a72c45a91c3a51d3c7adea98d82f8481e0e1e03674a6f3fb7',
+        ),
+      ),
+    );
+  }
+}
+function assert(bool) {
+  if (!bool) throw new Error('ecc library invalid');
+}
+
+const ECPairOptionsSchema = optional(
+  object({
+    compressed: optional(boolean()),
+    network: optional(NetworkSchema),
+    // https://github.com/fabian-hiller/valibot/issues/243#issuecomment-2182514063
+    rng: optional(
+      pipe(
+        instance(Function),
+        transform((func) => {
+          return (arg) => {
+            const parsedArg = parse(optional(number()), arg);
+            const returnedValue = func(parsedArg);
+            const parsedReturn = parse(instance(Uint8Array), returnedValue);
+            return parsedReturn;
+          };
+        }),
+      ),
+    ),
+  }),
+);
+const toXOnly = (pubKey) =>
+  pubKey.length === 32 ? pubKey : pubKey.subarray(1, 33);
+function ECPairFactory(ecc) {
+  testEcc(ecc);
+  function isPoint(maybePoint) {
+    return ecc.isPoint(maybePoint);
+  }
+  function fromPrivateKey(buffer, options) {
+    parse(Buffer256Bit, buffer);
+    if (!ecc.isPrivate(buffer))
+      throw new TypeError('Private key not in range [1, n)');
+    parse(ECPairOptionsSchema, options);
+    return new ECPair(buffer, undefined, options);
+  }
+  function fromPublicKey(buffer, options) {
+    if (!ecc.isPoint(buffer)) {
+      throw new Error('Point not on the curve');
+    }
+    parse(ECPairOptionsSchema, options);
+    return new ECPair(undefined, buffer, options);
+  }
+  function fromWIF(wifString, network) {
+    const decoded = decode(wifString);
+    const version = decoded.version;
+    // list of networks?
+    if (Array.isArray(network)) {
+      network = network
+        .filter((x) => {
+          return version === x.wif;
+        })
+        .pop();
+      if (!network) throw new Error('Unknown network version');
+      // otherwise, assume a network object (or default to bitcoin)
+    } else {
+      network = network || bitcoin;
+      if (version !== network.wif) throw new Error('Invalid network version');
+    }
+    return fromPrivateKey(decoded.privateKey, {
+      compressed: decoded.compressed,
+      network: network,
+    });
+  }
+  /**
+   * Generates a random ECPairInterface.
+   *
+   * Uses `crypto.getRandomValues` under the hood for options.rng function, which is still an experimental feature as of Node.js 18.19.0. To work around this you can do one of the following:
+   * 1. Use a polyfill for crypto.getRandomValues()
+   * 2. Use the `--experimental-global-webcrypto` flag when running node.js.
+   * 3. Pass in a custom rng function to generate random values.
+   *
+   * @param {ECPairOptions} options - Options for the ECPairInterface.
+   * @return {ECPairInterface} A random ECPairInterface.
+   */
+  function makeRandom(options) {
+    parse(ECPairOptionsSchema, options);
+    if (options === undefined) options = {};
+    const rng =
+      options.rng || ((size) => crypto.getRandomValues(new Uint8Array(size)));
+    let d;
+    do {
+      d = rng(32);
+      parse(Buffer256Bit, d);
+    } while (!ecc.isPrivate(d));
+    return fromPrivateKey(d, options);
+  }
+  class ECPair {
+    __D;
+    __Q;
+    compressed;
+    network;
+    lowR;
+    constructor(__D, __Q, options) {
+      this.__D = __D;
+      this.__Q = __Q;
+      this.lowR = false;
+      if (options === undefined) options = {};
+      this.compressed =
+        options.compressed === undefined ? true : options.compressed;
+      this.network = options.network || bitcoin;
+      if (__Q !== undefined) this.__Q = ecc.pointCompress(__Q, this.compressed);
+    }
+    get privateKey() {
+      return this.__D;
+    }
+    get publicKey() {
+      if (!this.__Q) {
+        // It is not possible for both `__Q` and `__D` to be `undefined` at the same time.
+        // The factory methods guard for this.
+        const p = ecc.pointFromScalar(this.__D, this.compressed);
+        // It is not possible for `p` to be null.
+        // `fromPrivateKey()` checks that `__D` is a valid scalar.
+        this.__Q = p;
+      }
+      return this.__Q;
+    }
+    toWIF() {
+      if (!this.__D) throw new Error('Missing private key');
+      return encode({
+        compressed: this.compressed,
+        privateKey: this.__D,
+        version: this.network.wif,
+      });
+    }
+    tweak(t) {
+      if (this.privateKey) return this.tweakFromPrivateKey(t);
+      return this.tweakFromPublicKey(t);
+    }
+    sign(hash, lowR) {
+      if (!this.__D) throw new Error('Missing private key');
+      if (lowR === undefined) lowR = this.lowR;
+      if (lowR === false) {
+        return ecc.sign(hash, this.__D);
+      } else {
+        let sig = ecc.sign(hash, this.__D);
+        const extraData = new Uint8Array(32);
+        let counter = 0;
+        // if first try is lowR, skip the loop
+        // for second try and on, add extra entropy counting up
+        while (sig[0] > 0x7f) {
+          counter++;
+          writeUInt32(extraData, 0, counter, 'LE');
+          sig = ecc.sign(hash, this.__D, extraData);
+        }
+        return sig;
+      }
+    }
+    signSchnorr(hash) {
+      if (!this.privateKey) throw new Error('Missing private key');
+      if (!ecc.signSchnorr)
+        throw new Error('signSchnorr not supported by ecc library');
+      return ecc.signSchnorr(hash, this.privateKey);
+    }
+    verify(hash, signature) {
+      return ecc.verify(hash, this.publicKey, signature);
+    }
+    verifySchnorr(hash, signature) {
+      if (!ecc.verifySchnorr)
+        throw new Error('verifySchnorr not supported by ecc library');
+      return ecc.verifySchnorr(hash, this.publicKey.subarray(1, 33), signature);
+    }
+    tweakFromPublicKey(t) {
+      const xOnlyPubKey = toXOnly(this.publicKey);
+      const tweakedPublicKey = ecc.xOnlyPointAddTweak(xOnlyPubKey, t);
+      if (!tweakedPublicKey || tweakedPublicKey.xOnlyPubkey === null)
+        throw new Error('Cannot tweak public key!');
+      const parityByte = Uint8Array.from([
+        tweakedPublicKey.parity === 0 ? 0x02 : 0x03,
+      ]);
+      return fromPublicKey(
+        concat([parityByte, tweakedPublicKey.xOnlyPubkey]),
+        {
+          network: this.network,
+          compressed: this.compressed,
+        },
+      );
+    }
+    tweakFromPrivateKey(t) {
+      const hasOddY =
+        this.publicKey[0] === 3 ||
+        (this.publicKey[0] === 4 && (this.publicKey[64] & 1) === 1);
+      const privateKey = hasOddY
+        ? ecc.privateNegate(this.privateKey)
+        : this.privateKey;
+      const tweakedPrivateKey = ecc.privateAdd(privateKey, t);
+      if (!tweakedPrivateKey) throw new Error('Invalid tweaked private key!');
+      return fromPrivateKey(tweakedPrivateKey, {
+        network: this.network,
+        compressed: this.compressed,
+      });
+    }
+  }
+  return {
+    isPoint,
+    fromPrivateKey,
+    fromPublicKey,
+    fromWIF,
+    makeRandom,
+  };
+}
+
+export { ECPairFactory as E, minValue as a, instance as b, parse as c, encode as e, integer as i, length as l, maxValue as m, number as n, object as o, pipe as p, regex as r, string as s };