@bsv/sdk 1.10.4 → 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,8 +59,8 @@ 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)
-    - Please note [*Security Considerations*](#security-considerations-for-encrypted-messages).
 - [TOTP](./reference/totp.md)
 - [Compatibility](./reference/compat.md)
 
@@ -76,16 +77,3 @@ Finally, you can deep dive into the details of the interface and types in the re
 ## Performance Reports
 
 - [Benchmarks](./performance.md)
-
-## Security Considerations for Encrypted Messages
-
-The encrypted message protocol implemented in this SDK derives per-message encryption keys deterministically from the parties’ long-term keys and a caller-supplied invoice number (BRC-42 style derivation).
-
-This construction does not provide the guarantees of a standard authenticated key exchange (AKE). In particular:
-
-No forward secrecy: Compromise of a long-term private key compromises all past and future messages derived from it.
-No replay protection: Messages encrypted under the same invoice number and key pair can be replayed.
-Potential identity misbinding: Public keys alone do not guarantee peer identity without additional authentication or identity verification.
-This protocol is intended for lightweight, deterministic messaging between parties that already trust each other’s long-term public keys. It SHOULD NOT be used for high-security or high-value communications without additional protocol-layer protections.
-
-Applications requiring strong authentication, replay protection, or forward secrecy should use a formally analyzed protocol such as X3DH, Noise, or SIGMA.

package/docs/reference/auth.md

@@ -681,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 
@@ -728,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)
 
@@ -740,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
 
@@ -803,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)
 
@@ -817,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
 
@@ -888,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
@@ -897,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

@@ -4940,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 
@@ -4969,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
@@ -4988,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
@@ -5010,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 
@@ -5032,7 +5048,7 @@ export class Writer {
 }
 ```
 
-See also: [BigNumber](./primitives.md#class-bignumber), [toArray](./primitives.md#variable-toarray), [toUint8Array](./primitives.md#variable-touint8array)
+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)
 
@@ -6444,81 +6460,7 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 
 ```ts
 toUTF8 = (arr: number[]): string => {
-    let result = "";
-    const replacementChar = "\uFFFD";
-    for (let i = 0; i < arr.length; i++) {
-        const byte1 = arr[i];
-        if (byte1 <= 127) {
-            result += String.fromCharCode(byte1);
-            continue;
-        }
-        const emitReplacement = (): void => {
-            result += replacementChar;
-        };
-        if (byte1 >= 192 && byte1 <= 223) {
-            if (i + 1 >= arr.length) {
-                emitReplacement();
-                continue;
-            }
-            const byte2 = arr[i + 1];
-            if ((byte2 & 192) !== 128) {
-                emitReplacement();
-                i += 1;
-                continue;
-            }
-            const codePoint = ((byte1 & 31) << 6) | (byte2 & 63);
-            result += String.fromCharCode(codePoint);
-            i += 1;
-            continue;
-        }
-        if (byte1 >= 224 && byte1 <= 239) {
-            if (i + 2 >= arr.length) {
-                emitReplacement();
-                continue;
-            }
-            const byte2 = arr[i + 1];
-            const byte3 = arr[i + 2];
-            if ((byte2 & 192) !== 128 || (byte3 & 192) !== 128) {
-                emitReplacement();
-                i += 2;
-                continue;
-            }
-            const codePoint = ((byte1 & 15) << 12) |
-                ((byte2 & 63) << 6) |
-                (byte3 & 63);
-            result += String.fromCharCode(codePoint);
-            i += 2;
-            continue;
-        }
-        if (byte1 >= 240 && byte1 <= 247) {
-            if (i + 3 >= arr.length) {
-                emitReplacement();
-                continue;
-            }
-            const byte2 = arr[i + 1];
-            const byte3 = arr[i + 2];
-            const byte4 = arr[i + 3];
-            if ((byte2 & 192) !== 128 ||
-                (byte3 & 192) !== 128 ||
-                (byte4 & 192) !== 128) {
-                emitReplacement();
-                i += 3;
-                continue;
-            }
-            const codePoint = ((byte1 & 7) << 18) |
-                ((byte2 & 63) << 12) |
-                ((byte3 & 63) << 6) |
-                (byte4 & 63);
-            const offset = codePoint - 65536;
-            const highSurrogate = 55296 + (offset >> 10);
-            const lowSurrogate = 56320 + (offset & 1023);
-            result += String.fromCharCode(highSurrogate, lowSurrogate);
-            i += 3;
-            continue;
-        }
-        emitReplacement();
-    }
-    return result;
+    return new TextDecoder().decode(new Uint8Array(arr));
 }
 ```