@bsv/sdk 2.0.0-beta.0 → 2.0.0

package/docs/index.md

@@ -48,6 +48,7 @@ Finally, you can deep dive into the details of the interface and types in the re
 
 ## Reference Material
 
+- [Remittance Getting Started](./remittance-getting-started.md)
 - [Wallet](./reference/wallet.md)
 - [Primitives](./reference/primitives.md)
 - [Script](./reference/script.md)
@@ -58,6 +59,7 @@ Finally, you can deep dive into the details of the interface and types in the re
 - [Registry](./reference/registry.md)
 - [Storage](./reference/storage.md)
 - [KV Store](./reference/kvstore.md)
+- [Remittance](./reference/remittance.md)
 - [Messages](./reference/messages.md)
 - [TOTP](./reference/totp.md)
 - [Compatibility](./reference/compat.md)
@@ -74,4 +76,4 @@ Finally, you can deep dive into the details of the interface and types in the re
 
 ## Performance Reports
 
-- [Benchmarks](./performance.md)
+- [Benchmarks](./performance.md)

package/docs/reference/auth.md

@@ -47,6 +47,8 @@ export interface PeerSession {
     peerNonce?: string;
     peerIdentityKey?: string;
     lastUpdate: number;
+    certificatesRequired?: boolean;
+    certificatesValidated?: boolean;
 }
 ```
 
@@ -679,9 +681,9 @@ export class Peer {
     public sessionManager: SessionManager;
     certificatesToRequest: RequestedCertificateSet;
     constructor(wallet: WalletInterface, transport: Transport, certificatesToRequest?: RequestedCertificateSet, sessionManager?: SessionManager, autoPersistLastSession?: boolean, originator?: OriginatorDomainNameStringUnder250Bytes) 
-    async toPeer(message: number[], identityKey?: string, maxWaitTime?: number): Promise<void> 
-    async requestCertificates(certificatesToRequest: RequestedCertificateSet, identityKey?: string, maxWaitTime = 10000): Promise<void> 
-    async getAuthenticatedSession(identityKey?: string, maxWaitTime?: number): Promise<PeerSession> 
+    async toPeer(message: number[], identityKey?: string): Promise<void> 
+    async requestCertificates(certificatesToRequest: RequestedCertificateSet, identityKey?: string): Promise<void> 
+    async getAuthenticatedSession(identityKey?: string): Promise<PeerSession> 
     listenForGeneralMessages(callback: (senderPublicKey: string, payload: number[]) => void): number 
     stopListeningForGeneralMessages(callbackID: number): void 
     listenForCertificatesReceived(callback: (senderPublicKey: string, certs: VerifiableCertificate[]) => void): number 
@@ -726,7 +728,7 @@ or the session is not authenticated, initiates a handshake to create or authenti
 - If `identityKey` is not provided, but we have a `lastInteractedWithPeer`, we try that key.
 
 ```ts
-async getAuthenticatedSession(identityKey?: string, maxWaitTime?: number): Promise<PeerSession> 
+async getAuthenticatedSession(identityKey?: string): Promise<PeerSession> 
 ```
 See also: [PeerSession](./auth.md#interface-peersession)
 
@@ -738,8 +740,6 @@ Argument Details
 
 + **identityKey**
   + The identity public key of the peer.
-+ **maxWaitTime**
-  + The maximum time in milliseconds to wait for the handshake.
 
 #### Method listenForCertificatesReceived
 
@@ -801,7 +801,7 @@ This method allows a peer to dynamically request specific certificates after
 an initial handshake or message has been exchanged.
 
 ```ts
-async requestCertificates(certificatesToRequest: RequestedCertificateSet, identityKey?: string, maxWaitTime = 10000): Promise<void> 
+async requestCertificates(certificatesToRequest: RequestedCertificateSet, identityKey?: string): Promise<void> 
 ```
 See also: [RequestedCertificateSet](./auth.md#interface-requestedcertificateset)
 
@@ -815,8 +815,6 @@ Argument Details
   + Specifies the certifiers and types of certificates required from the peer.
 + **identityKey**
   + The identity public key of the peer. If not provided, the current or last session identity is used.
-+ **maxWaitTime**
-  + Maximum time in milliseconds to wait for the peer session to be authenticated.
 
 Throws
 
@@ -886,7 +884,7 @@ Argument Details
 Sends a general message to a peer, and initiates a handshake if necessary.
 
 ```ts
-async toPeer(message: number[], identityKey?: string, maxWaitTime?: number): Promise<void> 
+async toPeer(message: number[], identityKey?: string): Promise<void> 
 ```
 
 Argument Details
@@ -895,8 +893,6 @@ Argument Details
   + The message payload to send.
 + **identityKey**
   + The identity public key of the peer. If not provided, uses lastInteractedWithPeer (if any).
-+ **maxWaitTime**
-  + optional max wait time in ms
 
 Throws
 

package/docs/reference/primitives.md

@@ -44,16 +44,17 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 | | | |
 | --- | --- | --- |
-| [BasePoint](#class-basepoint) | [PointInFiniteField](#class-pointinfinitefield) | [SHA256HMAC](#class-sha256hmac) |
-| [BigNumber](#class-bignumber) | [Polynomial](#class-polynomial) | [SHA512](#class-sha512) |
-| [Curve](#class-curve) | [PrivateKey](#class-privatekey) | [SHA512HMAC](#class-sha512hmac) |
-| [DRBG](#class-drbg) | [PublicKey](#class-publickey) | [Schnorr](#class-schnorr) |
-| [JacobianPoint](#class-jacobianpoint) | [RIPEMD160](#class-ripemd160) | [Secp256r1](#class-secp256r1) |
-| [K256](#class-k256) | [Reader](#class-reader) | [Signature](#class-signature) |
-| [KeyShares](#class-keyshares) | [ReductionContext](#class-reductioncontext) | [SymmetricKey](#class-symmetrickey) |
-| [Mersenne](#class-mersenne) | [SHA1](#class-sha1) | [TransactionSignature](#class-transactionsignature) |
-| [MontgomoryMethod](#class-montgomorymethod) | [SHA1HMAC](#class-sha1hmac) | [Writer](#class-writer) |
+| [BasePoint](#class-basepoint) | [Polynomial](#class-polynomial) | [SHA512](#class-sha512) |
+| [BigNumber](#class-bignumber) | [PrivateKey](#class-privatekey) | [SHA512HMAC](#class-sha512hmac) |
+| [Curve](#class-curve) | [PublicKey](#class-publickey) | [Schnorr](#class-schnorr) |
+| [DRBG](#class-drbg) | [RIPEMD160](#class-ripemd160) | [Secp256r1](#class-secp256r1) |
+| [JacobianPoint](#class-jacobianpoint) | [Reader](#class-reader) | [Signature](#class-signature) |
+| [K256](#class-k256) | [ReaderUint8Array](#class-readeruint8array) | [SymmetricKey](#class-symmetrickey) |
+| [KeyShares](#class-keyshares) | [ReductionContext](#class-reductioncontext) | [TransactionSignature](#class-transactionsignature) |
+| [Mersenne](#class-mersenne) | [SHA1](#class-sha1) | [Writer](#class-writer) |
+| [MontgomoryMethod](#class-montgomorymethod) | [SHA1HMAC](#class-sha1hmac) | [WriterUint8Array](#class-writeruint8array) |
 | [Point](#class-point) | [SHA256](#class-sha256) |  |
+| [PointInFiniteField](#class-pointinfinitefield) | [SHA256HMAC](#class-sha256hmac) |  |
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
@@ -299,6 +300,13 @@ console.log(BigNumber.wordSize);  // output: 26
 Compute the multiplicative inverse of the current BigNumber in the modulus field specified by `p`.
 The multiplicative inverse is a number which when multiplied with the current BigNumber gives '1' in the modulus field.
 
+SECURITY NOTE:
+This implementation avoids variable-time extended Euclidean algorithms
+to reduce timing side-channel leakage. However, JavaScript BigInt arithmetic
+does not provide constant-time guarantees. This implementation is suitable
+for browser and single-tenant environments but is not hardened against
+high-resolution timing attacks in shared CPU contexts.
+
 ```ts
 _invmp(p: BigNumber): BigNumber 
 ```
@@ -1786,6 +1794,7 @@ export default class Point extends BasePoint {
     getX(): BigNumber 
     getY(): BigNumber 
     mul(k: BigNumber | number | number[] | string): Point 
+    mulCT(k: BigNumber | number | number[] | string): Point 
     mulAdd(k1: BigNumber, p2: Point, k2: BigNumber): Point 
     jmulAdd(k1: BigNumber, p2: Point, k2: BigNumber): JPoint 
     eq(p: Point): boolean 
@@ -2508,6 +2517,32 @@ Returns
 
 #### Method deriveChild
 
+SECURITY NOTE – DETERMINISTIC CHILD KEY DERIVATION
+
+This method derives child private keys deterministically from the caller’s
+long-term private key, the counterparty’s public key, and a caller-supplied
+invoice number using HMAC over an ECDH shared secret (BRC-42 style derivation).
+
+This construction does NOT implement a formally authenticated key exchange
+(AKE) and does NOT provide the following security properties:
+
+ - Forward secrecy: Compromise of a long-term private key compromises all
+   past and future child keys derived from it.
+ - Replay protection: Child keys are deterministic for a given invoice
+   number and key pair; previously observed messages can be replayed.
+ - Explicit authentication / identity binding: Possession of a public key
+   alone does not guarantee the intended peer identity, enabling potential
+   identity misbinding attacks if higher-level identity verification is absent.
+
+This derivation is intended for lightweight, deterministic key hierarchies
+where both parties already possess and trust each other’s long-term public
+keys. It SHOULD NOT be used as a drop-in replacement for a standard
+authenticated key exchange (e.g. X3DH, Noise, or SIGMA) in high-security or
+high-value contexts.
+
+Any future protocol providing forward secrecy, replay protection, or strong
+peer authentication will require a versioned, breaking change.
+
 Derives a child key with BRC-42.
 
 ```ts
@@ -3306,9 +3341,54 @@ See also: [BigNumber](./primitives.md#class-bignumber)
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
+---
+### Class: ReaderUint8Array
+
+Reader for serialized Uint8Array binary data.
+
+```ts
+export class ReaderUint8Array {
+    public bin: Uint8Array;
+    public pos: number;
+    static makeReader(bin: Uint8Array | number[], pos: number = 0): Reader | ReaderUint8Array 
+    constructor(bin: Uint8Array | number[] = new Uint8Array(0), pos: number = 0) 
+    public eof(): boolean 
+    public read(len = this.length): Uint8Array 
+    public readReverse(len = this.length): Uint8Array 
+    public readUInt8(): number 
+    public readInt8(): number 
+    public readUInt16BE(): number 
+    public readInt16BE(): number 
+    public readUInt16LE(): number 
+    public readInt16LE(): number 
+    public readUInt32BE(): number 
+    public readInt32BE(): number 
+    public readUInt32LE(): number 
+    public readInt32LE(): number 
+    public readUInt64BEBn(): BigNumber 
+    public readUInt64LEBn(): BigNumber 
+    public readInt64LEBn(): BigNumber 
+    public readVarIntNum(signed: boolean = true): number 
+    public readVarInt(): Uint8Array 
+    public readVarIntBn(): BigNumber 
+}
+```
+
+See also: [BigNumber](./primitives.md#class-bignumber), [Reader](./primitives.md#class-reader)
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
+
 ---
 ### Class: ReductionContext
 
+SECURITY NOTE:
+This reduction context avoids obvious variable-time constructs (such as
+sliding-window exponentiation and conditional modular reduction) to reduce
+timing side-channel leakage. However, JavaScript BigInt arithmetic does not
+provide constant-time guarantees. These mitigations improve resistance to
+coarse timing attacks but do not make the implementation suitable for
+hostile multi-tenant or shared-CPU environments.
+
 A base reduction engine that provides several arithmetic operations over
 big numbers under a modulus context. It's particularly suitable for
 calculations required in cryptography algorithms and encoding schemas.
@@ -4860,9 +4940,12 @@ export default class TransactionSignature extends Signature {
     public static readonly SIGHASH_ALL = 1;
     public static readonly SIGHASH_NONE = 2;
     public static readonly SIGHASH_SINGLE = 3;
+    public static readonly SIGHASH_CHRONICLE = 32;
     public static readonly SIGHASH_FORKID = 64;
     public static readonly SIGHASH_ANYONECANPAY = 128;
     scope: number;
+    static formatOTDA(params: TransactionSignatureFormatParams): Uint8Array 
+    static formatBip143(params: TransactionSignatureFormatParams): Uint8Array 
     static format(params: TransactionSignatureFormatParams): number[] 
     static formatBytes(params: TransactionSignatureFormatParams): Uint8Array 
     static fromChecksigFormat(buf: number[]): TransactionSignature 
@@ -4889,12 +4972,12 @@ Argument Details
 + **params.cache**
   + Optional cache storing previously computed `hashPrevouts`, `hashSequence`, or `hashOutputs*` values; it will be populated if present.
 
-#### Method formatBytes
+#### Method formatBip143
 
 Formats the same SIGHASH preimage bytes as `format`, supporting the optional cache for hash reuse.
 
 ```ts
-static formatBytes(params: TransactionSignatureFormatParams): Uint8Array 
+static formatBip143(params: TransactionSignatureFormatParams): Uint8Array 
 ```
 
 Returns
@@ -4908,6 +4991,18 @@ Argument Details
 + **params.cache**
   + Optional `SignatureHashCache` that may already contain hashed prefixes and is populated during formatting.
 
+#### Method formatOTDA
+
+Implements the original bitcoin transaction signature digest preimage algorithm (OTDA).
+
+```ts
+static formatOTDA(params: TransactionSignatureFormatParams): Uint8Array 
+```
+
+Returns
+
+preimage as a byte array
+
 #### Method hasLowS
 
 Compares to bitcoind's IsLowDERSignature
@@ -4930,6 +5025,7 @@ export class Writer {
     getLength(): number 
     toUint8Array(): Uint8Array 
     toArray(): number[] 
+    toHex(): string 
     write(buf: WriterChunk): this 
     writeReverse(buf: number[]): this 
     writeUInt8(n: number): this 
@@ -4952,7 +5048,91 @@ export class Writer {
 }
 ```
 
-See also: [BigNumber](./primitives.md#class-bignumber), [toArray](./primitives.md#variable-toarray)
+See also: [BigNumber](./primitives.md#class-bignumber), [toArray](./primitives.md#variable-toarray), [toHex](./primitives.md#variable-tohex), [toUint8Array](./primitives.md#variable-touint8array)
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
+
+---
+### Class: WriterUint8Array
+
+WriterUint8Array is a utility class for writing binary data into a dynamically
+growing Uint8Array buffer. It provides methods to write various integer types
+and variable-length integers, similar to the Writer class but optimized for
+Uint8Array usage.
+
+```ts
+export class WriterUint8Array {
+    constructor(bufs?: WriterChunk[], initialCapacity: number = 256) 
+    getLength(): number 
+    toUint8Array(): Uint8Array 
+    toArray(): number[] 
+    toUint8ArrayZeroCopy(): Uint8Array 
+    write(bytes: WriterChunk): this 
+    writeReverse(buf: WriterChunk): this 
+    writeUInt8(value: number): this 
+    writeInt8(value: number): this 
+    writeUInt16LE(value: number): this 
+    writeUInt16BE(value: number): this 
+    writeInt16LE(value: number): this 
+    writeInt16BE(value: number): this 
+    writeUInt32LE(value: number): this 
+    writeUInt32BE(value: number): this 
+    writeInt32LE(value: number): this 
+    writeInt32BE(value: number): this 
+    writeUInt64BEBn(bn: BigNumber): this 
+    writeUInt64LEBn(bn: BigNumber): this 
+    writeUInt64LE(n: number): this 
+    writeVarIntNum(n: number): this 
+    writeVarIntBn(bn: BigNumber): this 
+    reset(): void 
+}
+```
+
+See also: [BigNumber](./primitives.md#class-bignumber), [toArray](./primitives.md#variable-toarray), [toUint8Array](./primitives.md#variable-touint8array)
+
+#### Method getLength
+
+Returns the current length of written data
+
+```ts
+getLength(): number 
+```
+
+#### Method reset
+
+Resets the writer to empty state (reuses the buffer)
+
+```ts
+reset(): void 
+```
+
+#### Method toArray
+
+Legacy compatibility method – returns number[] (Byte[])
+
+```ts
+toArray(): number[] 
+```
+
+#### Method toUint8Array
+
+```ts
+toUint8Array(): Uint8Array 
+```
+
+Returns
+
+the written data as Uint8Array copy of the internal buffer
+
+#### Method toUint8ArrayZeroCopy
+
+```ts
+toUint8ArrayZeroCopy(): Uint8Array 
+```
+
+Returns
+
+the written data as Uint8Array. CAUTION: This is zero-copy subarray of the internal buffer).
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
@@ -5309,24 +5489,25 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 | | | |
 | --- | --- | --- |
-| [BI_EIGHT](#variable-bi_eight) | [biModSqrt](#variable-bimodsqrt) | [modN](#variable-modn) |
-| [BI_FOUR](#variable-bi_four) | [biModSub](#variable-bimodsub) | [multiply](#variable-multiply) |
-| [BI_ONE](#variable-bi_one) | [checkBit](#variable-checkbit) | [rightShift](#variable-rightshift) |
-| [BI_THREE](#variable-bi_three) | [encode](#variable-encode) | [ripemd160](#variable-ripemd160) |
-| [BI_TWO](#variable-bi_two) | [exclusiveOR](#variable-exclusiveor) | [scalarMultiplyWNAF](#variable-scalarmultiplywnaf) |
-| [BI_ZERO](#variable-bi_zero) | [fromBase58](#variable-frombase58) | [sha1](#variable-sha1) |
-| [GX_BIGINT](#variable-gx_bigint) | [fromBase58Check](#variable-frombase58check) | [sha256](#variable-sha256) |
-| [GY_BIGINT](#variable-gy_bigint) | [getBytes](#variable-getbytes) | [sha256hmac](#variable-sha256hmac) |
-| [MASK_256](#variable-mask_256) | [getBytes64](#variable-getbytes64) | [sha512](#variable-sha512) |
-| [N_BIGINT](#variable-n_bigint) | [hash160](#variable-hash160) | [sha512hmac](#variable-sha512hmac) |
-| [P_BIGINT](#variable-p_bigint) | [hash256](#variable-hash256) | [sign](#variable-sign) |
-| [P_PLUS1_DIV4](#variable-p_plus1_div4) | [incrementLeastSignificantThirtyTwoBits](#variable-incrementleastsignificantthirtytwobits) | [toArray](#variable-toarray) |
-| [biMod](#variable-bimod) | [jpAdd](#variable-jpadd) | [toBase58](#variable-tobase58) |
-| [biModAdd](#variable-bimodadd) | [jpDouble](#variable-jpdouble) | [toBase58Check](#variable-tobase58check) |
-| [biModInv](#variable-bimodinv) | [jpNeg](#variable-jpneg) | [toHex](#variable-tohex) |
-| [biModMul](#variable-bimodmul) | [minimallyEncode](#variable-minimallyencode) | [toUTF8](#variable-toutf8) |
-| [biModPow](#variable-bimodpow) | [modInvN](#variable-modinvn) | [verify](#variable-verify) |
-| [biModSqr](#variable-bimodsqr) | [modMulN](#variable-modmuln) | [zero2](#variable-zero2) |
+| [BI_EIGHT](#variable-bi_eight) | [biModSub](#variable-bimodsub) | [rightShift](#variable-rightshift) |
+| [BI_FOUR](#variable-bi_four) | [checkBit](#variable-checkbit) | [ripemd160](#variable-ripemd160) |
+| [BI_ONE](#variable-bi_one) | [encode](#variable-encode) | [scalarMultiplyWNAF](#variable-scalarmultiplywnaf) |
+| [BI_THREE](#variable-bi_three) | [exclusiveOR](#variable-exclusiveor) | [sha1](#variable-sha1) |
+| [BI_TWO](#variable-bi_two) | [fromBase58](#variable-frombase58) | [sha256](#variable-sha256) |
+| [BI_ZERO](#variable-bi_zero) | [fromBase58Check](#variable-frombase58check) | [sha256hmac](#variable-sha256hmac) |
+| [GX_BIGINT](#variable-gx_bigint) | [getBytes](#variable-getbytes) | [sha512](#variable-sha512) |
+| [GY_BIGINT](#variable-gy_bigint) | [getBytes64](#variable-getbytes64) | [sha512hmac](#variable-sha512hmac) |
+| [MASK_256](#variable-mask_256) | [hash160](#variable-hash160) | [sign](#variable-sign) |
+| [N_BIGINT](#variable-n_bigint) | [hash256](#variable-hash256) | [toArray](#variable-toarray) |
+| [P_BIGINT](#variable-p_bigint) | [incrementLeastSignificantThirtyTwoBits](#variable-incrementleastsignificantthirtytwobits) | [toBase58](#variable-tobase58) |
+| [P_PLUS1_DIV4](#variable-p_plus1_div4) | [jpAdd](#variable-jpadd) | [toBase58Check](#variable-tobase58check) |
+| [biMod](#variable-bimod) | [jpDouble](#variable-jpdouble) | [toHex](#variable-tohex) |
+| [biModAdd](#variable-bimodadd) | [jpNeg](#variable-jpneg) | [toUTF8](#variable-toutf8) |
+| [biModInv](#variable-bimodinv) | [minimallyEncode](#variable-minimallyencode) | [toUint8Array](#variable-touint8array) |
+| [biModMul](#variable-bimodmul) | [modInvN](#variable-modinvn) | [verify](#variable-verify) |
+| [biModPow](#variable-bimodpow) | [modMulN](#variable-modmuln) | [zero2](#variable-zero2) |
+| [biModSqr](#variable-bimodsqr) | [modN](#variable-modn) |  |
+| [biModSqrt](#variable-bimodsqrt) | [multiply](#variable-multiply) |  |
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
@@ -5923,16 +6104,18 @@ multiply = function (block0: Bytes, block1: Bytes): Bytes {
     const v = block1.slice();
     const z = createZeroBlock(16);
     for (let i = 0; i < 16; i++) {
+        const b = block0[i];
         for (let j = 7; j >= 0; j--) {
-            if ((block0[i] & (1 << j)) !== 0) {
-                xorInto(z, v);
+            const bit = (b >> j) & 1;
+            const mask = -bit & 255;
+            for (let k = 0; k < 16; k++) {
+                z[k] ^= v[k] & mask;
             }
-            if ((v[15] & 1) !== 0) {
-                rightShift(v);
-                xorInto(v, R);
-            }
-            else {
-                rightShift(v);
+            const lsb = v[15] & 1;
+            const rmask = -lsb & 255;
+            rightShift(v);
+            for (let k = 0; k < 16; k++) {
+                v[k] ^= R[k] & rmask;
             }
         }
     }
@@ -6109,9 +6292,13 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ```ts
 sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false, customK?: BigNumber | ((iter: number) => BigNumber)): Signature => {
+    const nBitLength = curve.n.bitLength();
+    if (msg.bitLength() > nBitLength) {
+        throw new Error(`ECDSA message is too large: expected <= ${nBitLength} bits. Callers must hash messages before signing.`);
+    }
     msg = truncateToN(msg);
-    const msgBig = BigInt("0x" + msg.toString(16));
-    const keyBig = BigInt("0x" + key.toString(16));
+    const msgBig = bnToBigInt(msg);
+    const keyBig = bnToBigInt(key);
     const bkey = key.toArray("be", bytes);
     const nonce = msg.toArray("be", bytes);
     const drbg = new DRBG(bkey, nonce);
@@ -6121,26 +6308,24 @@ sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false, customK?: Bi
             : BigNumber.isBN(customK)
                 ? customK
                 : new BigNumber(drbg.generate(bytes), 16);
-        if (kBN == null)
+        if (kBN == null) {
             throw new Error("k is undefined");
+        }
         kBN = truncateToN(kBN, true);
         if (kBN.cmpn(1) < 0 || kBN.cmp(ns1) > 0) {
             if (BigNumber.isBN(customK)) {
-                throw new Error("Invalid fixed custom K value (must be >1 and <N\u20111)");
+                throw new Error("Invalid fixed custom K value (must be >1 and <N-1)");
             }
             continue;
         }
-        const kBig = BigInt("0x" + kBN.toString(16));
-        const R = scalarMultiplyWNAF(kBig, { x: GX_BIGINT, y: GY_BIGINT });
-        if (R.Z === 0n) {
+        const R = curve.g.mulCT(kBN);
+        if (R.isInfinity()) {
             if (BigNumber.isBN(customK)) {
                 throw new Error("Invalid fixed custom K value (k\u00B7G at infinity)");
             }
             continue;
         }
-        const zInv = biModInv(R.Z);
-        const zInv2 = biModMul(zInv, zInv);
-        const xAff = biModMul(R.X, zInv2);
+        const xAff = BigInt("0x" + R.getX().toString(16));
         const rBig = modN(xAff);
         if (rBig === 0n) {
             if (BigNumber.isBN(customK)) {
@@ -6148,6 +6333,7 @@ sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false, customK?: Bi
             }
             continue;
         }
+        const kBig = BigInt("0x" + kBN.toString(16));
         const kInv = modInvN(kBig);
         const rTimesKey = modMulN(rBig, keyBig);
         const sum = modN(msgBig + rTimesKey);
@@ -6168,7 +6354,7 @@ sign = (msg: BigNumber, key: BigNumber, forceLowS: boolean = false, customK?: Bi
 }
 ```
 
-See also: [BigNumber](./primitives.md#class-bignumber), [DRBG](./primitives.md#class-drbg), [GX_BIGINT](./primitives.md#variable-gx_bigint), [GY_BIGINT](./primitives.md#variable-gy_bigint), [N_BIGINT](./primitives.md#variable-n_bigint), [Signature](./primitives.md#class-signature), [biModInv](./primitives.md#variable-bimodinv), [biModMul](./primitives.md#variable-bimodmul), [modInvN](./primitives.md#variable-modinvn), [modMulN](./primitives.md#variable-modmuln), [modN](./primitives.md#variable-modn), [scalarMultiplyWNAF](./primitives.md#variable-scalarmultiplywnaf), [toArray](./primitives.md#variable-toarray)
+See also: [BigNumber](./primitives.md#class-bignumber), [DRBG](./primitives.md#class-drbg), [N_BIGINT](./primitives.md#variable-n_bigint), [Signature](./primitives.md#class-signature), [modInvN](./primitives.md#variable-modinvn), [modMulN](./primitives.md#variable-modmuln), [modN](./primitives.md#variable-modn), [toArray](./primitives.md#variable-toarray)
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
@@ -6253,7 +6439,7 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 ### Variable: toHex
 
 ```ts
-toHex = (msg: number[]): string => {
+toHex = (msg: number[] | Uint8Array): string => {
     if (CAN_USE_BUFFER) {
         return BufferCtor.from(msg).toString("hex");
     }
@@ -6280,22 +6466,41 @@ toUTF8 = (arr: number[]): string => {
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
+---
+### Variable: toUint8Array
+
+```ts
+toUint8Array = (msg: any, enc?: "hex" | "utf8" | "base64"): Uint8Array => {
+    if (msg instanceof Uint8Array)
+        return msg;
+    return new Uint8Array(toArray(msg, enc));
+}
+```
+
+See also: [toArray](./primitives.md#variable-toarray)
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
+
 ---
 ### Variable: verify
 
 ```ts
 verify = (msg: BigNumber, sig: Signature, key: Point): boolean => {
-    const hash = BigInt("0x" + msg.toString(16));
+    const nBitLength = curve.n.bitLength();
+    if (msg.bitLength() > nBitLength) {
+        return false;
+    }
+    const hash = bnToBigInt(msg);
     if ((key.x == null) || (key.y == null)) {
         throw new Error("Invalid public key: missing coordinates.");
     }
     const publicKey = {
-        x: BigInt("0x" + key.x.toString(16)),
-        y: BigInt("0x" + key.y.toString(16))
+        x: bnToBigInt(key.x),
+        y: bnToBigInt(key.y)
     };
     const signature = {
-        r: BigInt("0x" + sig.r.toString(16)),
-        s: BigInt("0x" + sig.s.toString(16))
+        r: bnToBigInt(sig.r),
+        s: bnToBigInt(sig.s)
     };
     const { r, s } = signature;
     const z = hash;