@bsv/sdk 1.4.23 → 1.5.0

package/docs/wallet.md

@@ -1528,20 +1528,15 @@ Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](
 ---
 ## Classes
 
-| |
-| --- |
-| [CachedKeyDeriver](#class-cachedkeyderiver) |
-| [HTTPWalletJSON](#class-httpwalletjson) |
-| [HTTPWalletWire](#class-httpwalletwire) |
-| [KeyDeriver](#class-keyderiver) |
-| [ProtoWallet](#class-protowallet) |
-| [WERR_REVIEW_ACTIONS](#class-werr_review_actions) |
-| [WalletClient](#class-walletclient) |
-| [WalletError](#class-walleterror) |
-| [WalletWireProcessor](#class-walletwireprocessor) |
-| [WalletWireTransceiver](#class-walletwiretransceiver) |
-| [WindowCWISubstrate](#class-windowcwisubstrate) |
-| [XDMSubstrate](#class-xdmsubstrate) |
+| | |
+| --- | --- |
+| [CachedKeyDeriver](#class-cachedkeyderiver) | [WalletClient](#class-walletclient) |
+| [HTTPWalletJSON](#class-httpwalletjson) | [WalletError](#class-walleterror) |
+| [HTTPWalletWire](#class-httpwalletwire) | [WalletWireProcessor](#class-walletwireprocessor) |
+| [KeyDeriver](#class-keyderiver) | [WalletWireTransceiver](#class-walletwiretransceiver) |
+| [ProtoWallet](#class-protowallet) | [WindowCWISubstrate](#class-windowcwisubstrate) |
+| [ReactNativeWebView](#class-reactnativewebview) | [XDMSubstrate](#class-xdmsubstrate) |
+| [WERR_REVIEW_ACTIONS](#class-werr_review_actions) |  |
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
@@ -2132,6 +2127,450 @@ See also: [CreateHmacArgs](./wallet.md#interface-createhmacargs), [CreateHmacRes
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 
+---
+### Class: ReactNativeWebView
+
+Facilitates wallet operations over cross-document messaging.
+
+```ts
+export default class ReactNativeWebView implements WalletInterface {
+    constructor(domain: string = "*") 
+    async invoke(call: CallType, args: any): Promise<any> 
+    async createAction(args: {
+        description: DescriptionString5to50Bytes;
+        inputs?: Array<{
+            tx?: BEEF;
+            outpoint: OutpointString;
+            unlockingScript?: HexString;
+            unlockingScriptLength?: PositiveInteger;
+            inputDescription: DescriptionString5to50Bytes;
+            sequenceNumber?: PositiveIntegerOrZero;
+        }>;
+        outputs?: Array<{
+            lockingScript: HexString;
+            satoshis: SatoshiValue;
+            outputDescription: DescriptionString5to50Bytes;
+            basket?: BasketStringUnder300Bytes;
+            customInstructions?: string;
+            tags?: OutputTagStringUnder300Bytes[];
+        }>;
+        lockTime?: PositiveIntegerOrZero;
+        version?: PositiveIntegerOrZero;
+        labels?: LabelStringUnder300Bytes[];
+        options?: {
+            signAndProcess?: BooleanDefaultTrue;
+            acceptDelayedBroadcast?: BooleanDefaultTrue;
+            trustSelf?: "known";
+            knownTxids?: TXIDHexString[];
+            returnTXIDOnly?: BooleanDefaultFalse;
+            noSend?: BooleanDefaultFalse;
+            noSendChange?: OutpointString[];
+            sendWith?: TXIDHexString[];
+        };
+    }): Promise<{
+        txid?: TXIDHexString;
+        tx?: BEEF;
+        noSendChange?: OutpointString[];
+        sendWithResults?: Array<{
+            txid: TXIDHexString;
+            status: "unproven" | "sending" | "failed";
+        }>;
+        signableTransaction?: {
+            tx: BEEF;
+            reference: Base64String;
+        };
+    }> 
+    async signAction(args: {
+        spends: Record<PositiveIntegerOrZero, {
+            unlockingScript: HexString;
+            sequenceNumber?: PositiveIntegerOrZero;
+        }>;
+        reference: Base64String;
+        options?: {
+            acceptDelayedBroadcast?: BooleanDefaultTrue;
+            returnTXIDOnly?: BooleanDefaultFalse;
+            noSend?: BooleanDefaultFalse;
+            noSendChange?: OutpointString[];
+            sendWith: TXIDHexString[];
+        };
+    }): Promise<{
+        txid?: TXIDHexString;
+        tx?: BEEF;
+        noSendChange?: OutpointString[];
+        sendWithResults?: Array<{
+            txid: TXIDHexString;
+            status: "unproven" | "sending" | "failed";
+        }>;
+    }> 
+    async abortAction(args: {
+        reference: Base64String;
+    }): Promise<{
+        aborted: true;
+    }> 
+    async listActions(args: {
+        labels: LabelStringUnder300Bytes[];
+        labelQueryMode?: "any" | "all";
+        includeLabels?: BooleanDefaultFalse;
+        includeInputs?: BooleanDefaultFalse;
+        includeInputSourceLockingScripts?: BooleanDefaultFalse;
+        includeInputUnlockingScripts?: BooleanDefaultFalse;
+        includeOutputs?: BooleanDefaultFalse;
+        includeOutputLockingScripts?: BooleanDefaultFalse;
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+    }): Promise<{
+        totalActions: PositiveIntegerOrZero;
+        actions: Array<{
+            txid: TXIDHexString;
+            satoshis: SatoshiValue;
+            status: "completed" | "unprocessed" | "sending" | "unproven" | "unsigned" | "nosend" | "nonfinal";
+            isOutgoing: boolean;
+            description: DescriptionString5to50Bytes;
+            labels?: LabelStringUnder300Bytes[];
+            version: PositiveIntegerOrZero;
+            lockTime: PositiveIntegerOrZero;
+            inputs?: Array<{
+                sourceOutpoint: OutpointString;
+                sourceSatoshis: SatoshiValue;
+                sourceLockingScript?: HexString;
+                unlockingScript?: HexString;
+                inputDescription: DescriptionString5to50Bytes;
+                sequenceNumber: PositiveIntegerOrZero;
+            }>;
+            outputs?: Array<{
+                outputIndex: PositiveIntegerOrZero;
+                satoshis: SatoshiValue;
+                lockingScript?: HexString;
+                spendable: boolean;
+                outputDescription: DescriptionString5to50Bytes;
+                basket: BasketStringUnder300Bytes;
+                tags: OutputTagStringUnder300Bytes[];
+                customInstructions?: string;
+            }>;
+        }>;
+    }> 
+    async internalizeAction(args: {
+        tx: BEEF;
+        outputs: Array<{
+            outputIndex: PositiveIntegerOrZero;
+            protocol: "wallet payment" | "basket insertion";
+            paymentRemittance?: {
+                derivationPrefix: Base64String;
+                derivationSuffix: Base64String;
+                senderIdentityKey: PubKeyHex;
+            };
+            insertionRemittance?: {
+                basket: BasketStringUnder300Bytes;
+                customInstructions?: string;
+                tags?: OutputTagStringUnder300Bytes[];
+            };
+        }>;
+        description: DescriptionString5to50Bytes;
+        labels?: LabelStringUnder300Bytes[];
+    }): Promise<{
+        accepted: true;
+    }> 
+    async listOutputs(args: {
+        basket: BasketStringUnder300Bytes;
+        tags?: OutputTagStringUnder300Bytes[];
+        tagQueryMode?: "all" | "any";
+        include?: "locking scripts" | "entire transactions";
+        includeCustomInstructions?: BooleanDefaultFalse;
+        includeTags?: BooleanDefaultFalse;
+        includeLabels?: BooleanDefaultFalse;
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+    }): Promise<{
+        totalOutputs: PositiveIntegerOrZero;
+        outputs: Array<{
+            outpoint: OutpointString;
+            satoshis: SatoshiValue;
+            lockingScript?: HexString;
+            tx?: BEEF;
+            spendable: boolean;
+            customInstructions?: string;
+            tags?: OutputTagStringUnder300Bytes[];
+            labels?: LabelStringUnder300Bytes[];
+        }>;
+    }> 
+    async relinquishOutput(args: {
+        basket: BasketStringUnder300Bytes;
+        output: OutpointString;
+    }): Promise<{
+        relinquished: true;
+    }> 
+    async getPublicKey(args: {
+        identityKey?: true;
+        protocolID?: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID?: KeyIDStringUnder800Bytes;
+        privileged?: BooleanDefaultFalse;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        forSelf?: BooleanDefaultFalse;
+    }): Promise<{
+        publicKey: PubKeyHex;
+    }> 
+    async revealCounterpartyKeyLinkage(args: {
+        counterparty: PubKeyHex;
+        verifier: PubKeyHex;
+        privilegedReason?: DescriptionString5to50Bytes;
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        prover: PubKeyHex;
+        verifier: PubKeyHex;
+        counterparty: PubKeyHex;
+        revelationTime: ISOTimestampString;
+        encryptedLinkage: Byte[];
+        encryptedLinkageProof: Byte[];
+    }> 
+    async revealSpecificKeyLinkage(args: {
+        counterparty: PubKeyHex;
+        verifier: PubKeyHex;
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        prover: PubKeyHex;
+        verifier: PubKeyHex;
+        counterparty: PubKeyHex;
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        encryptedLinkage: Byte[];
+        encryptedLinkageProof: Byte[];
+        proofType: Byte;
+    }> 
+    async encrypt(args: {
+        plaintext: Byte[];
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        ciphertext: Byte[];
+    }> 
+    async decrypt(args: {
+        ciphertext: Byte[];
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        plaintext: Byte[];
+    }> 
+    async createHmac(args: {
+        data: Byte[];
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        hmac: Byte[];
+    }> 
+    async verifyHmac(args: {
+        data: Byte[];
+        hmac: Byte[];
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        valid: true;
+    }> 
+    async createSignature(args: {
+        data?: Byte[];
+        hashToDirectlySign?: Byte[];
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        signature: Byte[];
+    }> 
+    async verifySignature(args: {
+        data?: Byte[];
+        hashToDirectlyVerify?: Byte[];
+        signature: Byte[];
+        protocolID: [
+            SecurityLevel,
+            ProtocolString5To400Bytes
+        ];
+        keyID: KeyIDStringUnder800Bytes;
+        privilegedReason?: DescriptionString5to50Bytes;
+        counterparty?: PubKeyHex | "self" | "anyone";
+        forSelf?: BooleanDefaultFalse;
+        privileged?: BooleanDefaultFalse;
+    }): Promise<{
+        valid: true;
+    }> 
+    async acquireCertificate(args: {
+        type: Base64String;
+        subject: PubKeyHex;
+        serialNumber: Base64String;
+        revocationOutpoint: OutpointString;
+        signature: HexString;
+        fields: Record<CertificateFieldNameUnder50Bytes, string>;
+        certifier: PubKeyHex;
+        keyringRevealer: PubKeyHex | "certifier";
+        keyringForSubject: Record<CertificateFieldNameUnder50Bytes, Base64String>;
+        acquisitionProtocol: "direct" | "issuance";
+        certifierUrl?: string;
+    }): Promise<{
+        type: Base64String;
+        subject: PubKeyHex;
+        serialNumber: Base64String;
+        certifier: PubKeyHex;
+        revocationOutpoint: OutpointString;
+        signature: HexString;
+        fields: Record<CertificateFieldNameUnder50Bytes, string>;
+    }> 
+    async listCertificates(args: {
+        certifiers: PubKeyHex[];
+        types: Base64String[];
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+        privileged?: BooleanDefaultFalse;
+        privilegedReason?: DescriptionString5to50Bytes;
+    }): Promise<{
+        totalCertificates: PositiveIntegerOrZero;
+        certificates: Array<{
+            type: Base64String;
+            subject: PubKeyHex;
+            serialNumber: Base64String;
+            certifier: PubKeyHex;
+            revocationOutpoint: OutpointString;
+            signature: HexString;
+            fields: Record<CertificateFieldNameUnder50Bytes, string>;
+        }>;
+    }> 
+    async proveCertificate(args: {
+        certificate: {
+            type: Base64String;
+            subject: PubKeyHex;
+            serialNumber: Base64String;
+            certifier: PubKeyHex;
+            revocationOutpoint: OutpointString;
+            signature: HexString;
+            fields: Record<CertificateFieldNameUnder50Bytes, string>;
+        };
+        fieldsToReveal: CertificateFieldNameUnder50Bytes[];
+        verifier: PubKeyHex;
+        privileged?: BooleanDefaultFalse;
+        privilegedReason?: DescriptionString5to50Bytes;
+    }): Promise<{
+        keyringForVerifier: Record<CertificateFieldNameUnder50Bytes, Base64String>;
+    }> 
+    async relinquishCertificate(args: {
+        type: Base64String;
+        serialNumber: Base64String;
+        certifier: PubKeyHex;
+    }): Promise<{
+        relinquished: true;
+    }> 
+    async discoverByIdentityKey(args: {
+        identityKey: PubKeyHex;
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+    }): Promise<{
+        totalCertificates: PositiveIntegerOrZero;
+        certificates: Array<{
+            type: Base64String;
+            subject: PubKeyHex;
+            serialNumber: Base64String;
+            certifier: PubKeyHex;
+            revocationOutpoint: OutpointString;
+            signature: HexString;
+            fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
+            certifierInfo: {
+                name: EntityNameStringMax100Bytes;
+                iconUrl: EntityIconURLStringMax500Bytes;
+                description: DescriptionString5to50Bytes;
+                trust: PositiveIntegerMax10;
+            };
+            publiclyRevealedKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>;
+            decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
+        }>;
+    }> 
+    async discoverByAttributes(args: {
+        attributes: Record<CertificateFieldNameUnder50Bytes, string>;
+        limit?: PositiveIntegerDefault10Max10000;
+        offset?: PositiveIntegerOrZero;
+    }): Promise<{
+        totalCertificates: PositiveIntegerOrZero;
+        certificates: Array<{
+            type: Base64String;
+            subject: PubKeyHex;
+            serialNumber: Base64String;
+            certifier: PubKeyHex;
+            revocationOutpoint: OutpointString;
+            signature: HexString;
+            fields: Record<CertificateFieldNameUnder50Bytes, Base64String>;
+            certifierInfo: {
+                name: EntityNameStringMax100Bytes;
+                iconUrl: EntityIconURLStringMax500Bytes;
+                description: DescriptionString5to50Bytes;
+                trust: PositiveIntegerMax10;
+            };
+            publiclyRevealedKeyring: Record<CertificateFieldNameUnder50Bytes, Base64String>;
+            decryptedFields: Record<CertificateFieldNameUnder50Bytes, string>;
+        }>;
+    }> 
+    async isAuthenticated(args: {}): Promise<{
+        authenticated: true;
+    }> 
+    async waitForAuthentication(args: {}): Promise<{
+        authenticated: true;
+    }> 
+    async getHeight(args: {}): Promise<{
+        height: PositiveInteger;
+    }> 
+    async getHeaderForHeight(args: {
+        height: PositiveInteger;
+    }): Promise<{
+        header: HexString;
+    }> 
+    async getNetwork(args: {}): Promise<{
+        network: "mainnet" | "testnet";
+    }> 
+    async getVersion(args: {}): Promise<{
+        version: VersionString7To30Bytes;
+    }> 
+}
+```
+
+See also: [BEEF](./wallet.md#type-beef), [Base64String](./wallet.md#type-base64string), [BasketStringUnder300Bytes](./wallet.md#type-basketstringunder300bytes), [BooleanDefaultFalse](./wallet.md#type-booleandefaultfalse), [BooleanDefaultTrue](./wallet.md#type-booleandefaulttrue), [Byte](./wallet.md#type-byte), [CallType](./wallet.md#type-calltype), [CertificateFieldNameUnder50Bytes](./wallet.md#type-certificatefieldnameunder50bytes), [DescriptionString5to50Bytes](./wallet.md#type-descriptionstring5to50bytes), [EntityIconURLStringMax500Bytes](./wallet.md#type-entityiconurlstringmax500bytes), [EntityNameStringMax100Bytes](./wallet.md#type-entitynamestringmax100bytes), [HexString](./wallet.md#type-hexstring), [ISOTimestampString](./wallet.md#type-isotimestampstring), [KeyIDStringUnder800Bytes](./wallet.md#type-keyidstringunder800bytes), [LabelStringUnder300Bytes](./wallet.md#type-labelstringunder300bytes), [OutpointString](./wallet.md#type-outpointstring), [OutputTagStringUnder300Bytes](./wallet.md#type-outputtagstringunder300bytes), [PositiveInteger](./wallet.md#type-positiveinteger), [PositiveIntegerDefault10Max10000](./wallet.md#type-positiveintegerdefault10max10000), [PositiveIntegerMax10](./wallet.md#type-positiveintegermax10), [PositiveIntegerOrZero](./wallet.md#type-positiveintegerorzero), [ProtocolString5To400Bytes](./wallet.md#type-protocolstring5to400bytes), [PubKeyHex](./wallet.md#type-pubkeyhex), [SatoshiValue](./wallet.md#type-satoshivalue), [SecurityLevel](./wallet.md#type-securitylevel), [TXIDHexString](./wallet.md#type-txidhexstring), [VersionString7To30Bytes](./wallet.md#type-versionstring7to30bytes), [WalletInterface](./wallet.md#interface-walletinterface), [decrypt](./messages.md#variable-decrypt), [encrypt](./messages.md#variable-encrypt)
+
+Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
+
 ---
 ### Class: WERR_REVIEW_ACTIONS
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bsv/sdk",
-  "version": "1.4.23",
+  "version": "1.5.0",
   "type": "module",
   "description": "BSV Blockchain Software Development Kit",
   "main": "dist/cjs/mod.js",

package/src/transaction/broadcasters/Teranode.ts

@@ -0,0 +1,77 @@
+import {
+  BroadcastResponse,
+  BroadcastFailure,
+  Broadcaster
+} from '../Broadcaster.js'
+import Transaction from '../Transaction.js'
+import { binaryHttpClient, HttpClient } from '../http/index.js'
+
+/**
+ * Represents an Teranode transaction broadcaster.
+ */
+export default class Teranode implements Broadcaster {
+  readonly URL: string
+  readonly httpClient: HttpClient
+
+  /**
+   * Constructs an instance of the Teranode broadcaster.
+   *
+   * @param {string} URL - The URL endpoint for the Teranode API.
+   * @param {HttpClient} httpClient - The HTTP client used to make requests to the API, binaryHttpClient by default.
+   */
+  constructor(
+    URL: string,
+    httpClient: HttpClient = binaryHttpClient()
+  ) {
+    this.URL = URL
+    this.httpClient = httpClient
+  }
+
+  /**
+   * Broadcasts a transaction via Teranode.
+   *
+   * @param {Transaction} tx - The transaction to be broadcasted.
+   * @returns {Promise<BroadcastResponse | BroadcastFailure>} A promise that resolves to either a success or failure response.
+   */
+  async broadcast(
+    tx: Transaction
+  ): Promise<BroadcastResponse | BroadcastFailure> {
+    const rawTx = tx.toEF()
+    const requestOptions = {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/octet-stream'
+      },
+      data: new Blob([new Uint8Array(rawTx)])
+    }
+    try {
+      const response = await this.httpClient.request<string>(
+        this.URL,
+        requestOptions
+      )
+      if (response.ok) {
+        const txid = tx.id('hex')
+        return {
+          status: 'success',
+          txid,
+          message: 'broadcast successful'
+        }
+      } else {
+        return {
+          status: 'error',
+          code: response.status.toString() ?? 'ERR_UNKNOWN',
+          description: response.data ?? 'Unknown error'
+        }
+      }
+    } catch (error) {
+      return {
+        status: 'error',
+        code: '500',
+        description:
+          typeof error.message === 'string'
+            ? error.message
+            : 'Internal Server Error'
+      }
+    }
+  }
+}

package/src/transaction/broadcasters/index.ts

@@ -1,4 +1,5 @@
 export { default as ARC } from './ARC.js'
 export type { ArcConfig } from './ARC.js'
 export { default as WhatsOnChainBroadcaster } from './WhatsOnChainBroadcaster.js'
+export { default as Teranode } from './Teranode.js'
 export { defaultBroadcaster } from './DefaultBroadcaster.js'