@bsv/sdk 1.4.24 → 1.5.1

package/package.json

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

package/src/script/Script.ts

@@ -125,10 +125,28 @@ export default class Script {
     bin = [...bin]
     const chunks: ScriptChunk[] = []
 
+    let inConditionalBlock: number = 0
+
     const br = new Reader(bin)
     while (!br.eof()) {
       const op = br.readUInt8()
 
+      // if OP_RETURN and not in a conditional block, do not parse the rest of the data,
+      // rather just return the last chunk as data without prefixing with data length.
+      if (op === OP.OP_RETURN && inConditionalBlock === 0) {
+        chunks.push({
+          op,
+          data: br.read()
+        })
+        break
+      }
+
+      if (op === OP.OP_IF || op === OP.OP_NOTIF || op === OP.OP_VERIF || op === OP.OP_VERNOTIF) {
+        inConditionalBlock++
+      } else if (op === OP.OP_ENDIF) {
+        inConditionalBlock--
+      }
+
       let len = 0
       // eslint-disable-next-line @typescript-eslint/no-shadow
       let data: number[] = []
@@ -225,7 +243,10 @@ export default class Script {
       const chunk = this.chunks[i]
       const op = chunk.op
       writer.writeUInt8(op)
-      if (chunk.data != null) {
+      if (op === OP.OP_RETURN && chunk.data != null) { // special case for unformatted data
+        writer.write(chunk.data)
+        break
+      } else if (chunk.data != null) {
         if (op < OP.OP_PUSHDATA1) {
           writer.write(chunk.data)
         } else if (op === OP.OP_PUSHDATA1) {

package/src/wallet/WalletClient.ts

@@ -40,6 +40,7 @@ import XDMSubstrate from './substrates/XDM.js'
 import WalletWireTransceiver from './substrates/WalletWireTransceiver.js'
 import HTTPWalletWire from './substrates/HTTPWalletWire.js'
 import HTTPWalletJSON from './substrates/HTTPWalletJSON.js'
+import ReactNativeWebView from './substrates/ReactNativeWebView.js'
 
 const MAX_XDM_RESPONSE_WAIT = 200
 
@@ -91,6 +92,7 @@ export default class WalletClient implements WalletInterface {
       }
     }
     try {
+      console.log('Connecting to substrate...')
       sub = new WindowCWISubstrate()
       await checkSub()
       this.substrate = sub
@@ -113,10 +115,17 @@ export default class WalletClient implements WalletInterface {
             await checkSub()
             this.substrate = sub
           } catch (e) {
-            // No comms. Tell the user to install a BSV wallet.
-            throw new Error(
-              'No wallet available over any communication substrate. Install a BSV wallet today!'
-            )
+            // HTTP JSON failed, attempt the next...
+            try {
+              sub = new ReactNativeWebView(this.originator)
+              await checkSub()
+              this.substrate = sub
+            } catch (e) {
+              // No comms. Tell the user to install a BSV wallet.
+              throw new Error(
+                'No wallet available over any communication substrate. Install a BSV wallet today!'
+              )
+            }
           }
         }
       }

package/src/wallet/substrates/ReactNativeWebView.ts

@@ -0,0 +1,560 @@
+import {
+  Base64String,
+  BasketStringUnder300Bytes,
+  BEEF,
+  BooleanDefaultFalse,
+  BooleanDefaultTrue,
+  Byte,
+  CertificateFieldNameUnder50Bytes,
+  DescriptionString5to50Bytes,
+  EntityIconURLStringMax500Bytes,
+  EntityNameStringMax100Bytes,
+  HexString,
+  ISOTimestampString,
+  KeyIDStringUnder800Bytes,
+  LabelStringUnder300Bytes,
+  OutpointString,
+  OutputTagStringUnder300Bytes,
+  PositiveInteger,
+  PositiveIntegerDefault10Max10000,
+  PositiveIntegerMax10,
+  PositiveIntegerOrZero,
+  ProtocolString5To400Bytes,
+  PubKeyHex,
+  SatoshiValue,
+  SecurityLevel,
+  TXIDHexString,
+  VersionString7To30Bytes,
+  WalletInterface
+} from '../Wallet.interfaces.js'
+import Random from '../../primitives/Random.js'
+import * as Utils from '../../primitives/utils.js'
+import { WalletError } from '../WalletError.js'
+import { CallType } from './WalletWireCalls.js'
+
+type ReactNativeWindow = Window & {
+  ReactNativeWebView: {
+    postMessage: (message: any) => void
+  }
+}
+
+/**
+ * Facilitates wallet operations over cross-document messaging.
+ */
+export default class ReactNativeWebView implements WalletInterface {
+  private readonly domain: string
+
+
+  constructor(domain: string = '*') {
+    if (typeof window !== 'object') {
+      throw new Error('The XDM substrate requires a global window object.')
+    }
+    if (!(window as unknown as ReactNativeWindow).hasOwnProperty("ReactNativeWebView")) {
+      throw new Error(
+        'The window object does not have a ReactNativeWebView property.'
+      )
+    }
+    if (typeof (window as unknown as ReactNativeWindow).ReactNativeWebView.postMessage !== 'function') {
+      throw new Error(
+        'The window.ReactNativeWebView property does not seem to support postMessage calls.'
+      )
+    }
+    this.domain = domain
+  }
+
+  async invoke(call: CallType, args: any): Promise<any> {
+    return await new Promise((resolve, reject) => {
+      const id = Utils.toBase64(Random(12))
+      const listener = (e: MessageEvent): void => {
+        const data = JSON.parse(e.data)
+        if (
+          data.type !== 'CWI' ||
+          data.id !== id ||
+          data.isInvocation === true
+        ) {
+          return
+        }
+        if (typeof window.removeEventListener === 'function') {
+          window.removeEventListener('message', listener)
+        }
+        if (data.status === 'error') {
+          const err = new WalletError(data.description, data.code)
+          reject(err)
+        } else {
+          resolve(data.result)
+        }
+      }
+      window.addEventListener('message', listener)
+      ;(window as unknown as ReactNativeWindow).ReactNativeWebView.postMessage(
+        JSON.stringify({
+          type: 'CWI',
+          isInvocation: true,
+          id,
+          call,
+          args
+        })
+      )
+    })
+  }
+
+  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 }
+  }> {
+    return await this.invoke('createAction', args)
+  }
+
+  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'
+    }>
+  }> {
+    return await this.invoke('signAction', args)
+  }
+
+  async abortAction(args: {
+    reference: Base64String
+  }): Promise<{ aborted: true }> {
+    return await this.invoke('abortAction', args)
+  }
+
+  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
+      }>
+    }>
+  }> {
+    return await this.invoke('listActions', args)
+  }
+
+  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 }> {
+    return await this.invoke('internalizeAction', args)
+  }
+
+  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[]
+    }>
+  }> {
+    return await this.invoke('listOutputs', args)
+  }
+
+  async relinquishOutput(args: {
+    basket: BasketStringUnder300Bytes
+    output: OutpointString
+  }): Promise<{ relinquished: true }> {
+    return await this.invoke('relinquishOutput', args)
+  }
+
+  async getPublicKey(args: {
+    identityKey?: true
+    protocolID?: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID?: KeyIDStringUnder800Bytes
+    privileged?: BooleanDefaultFalse
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    forSelf?: BooleanDefaultFalse
+  }): Promise<{ publicKey: PubKeyHex }> {
+    return await this.invoke('getPublicKey', args)
+  }
+
+  async revealCounterpartyKeyLinkage(args: {
+    counterparty: PubKeyHex
+    verifier: PubKeyHex
+    privilegedReason?: DescriptionString5to50Bytes
+    privileged?: BooleanDefaultFalse
+  }): Promise<{
+    prover: PubKeyHex
+    verifier: PubKeyHex
+    counterparty: PubKeyHex
+    revelationTime: ISOTimestampString
+    encryptedLinkage: Byte[]
+    encryptedLinkageProof: Byte[]
+  }> {
+    return await this.invoke('revealCounterpartyKeyLinkage', args)
+  }
+
+  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
+  }> {
+    return await this.invoke('revealSpecificKeyLinkage', args)
+  }
+
+  async encrypt(args: {
+    plaintext: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ ciphertext: Byte[] }> {
+    return await this.invoke('encrypt', args)
+  }
+
+  async decrypt(args: {
+    ciphertext: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ plaintext: Byte[] }> {
+    return await this.invoke('decrypt', args)
+  }
+
+  async createHmac(args: {
+    data: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ hmac: Byte[] }> {
+    return await this.invoke('createHmac', args)
+  }
+
+  async verifyHmac(args: {
+    data: Byte[]
+    hmac: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ valid: true }> {
+    return await this.invoke('verifyHmac', args)
+  }
+
+  async createSignature(args: {
+    data?: Byte[]
+    hashToDirectlySign?: Byte[]
+    protocolID: [SecurityLevel, ProtocolString5To400Bytes]
+    keyID: KeyIDStringUnder800Bytes
+    privilegedReason?: DescriptionString5to50Bytes
+    counterparty?: PubKeyHex | 'self' | 'anyone'
+    privileged?: BooleanDefaultFalse
+  }): Promise<{ signature: Byte[] }> {
+    return await this.invoke('createSignature', args)
+  }
+
+  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 }> {
+    return await this.invoke('verifySignature', args)
+  }
+
+  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>
+  }> {
+    return await this.invoke('acquireCertificate', args)
+  }
+
+  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>
+    }>
+  }> {
+    return await this.invoke('listCertificates', args)
+  }
+
+  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>
+  }> {
+    return await this.invoke('proveCertificate', args)
+  }
+
+  async relinquishCertificate(args: {
+    type: Base64String
+    serialNumber: Base64String
+    certifier: PubKeyHex
+  }): Promise<{ relinquished: true }> {
+    return await this.invoke('relinquishCertificate', args)
+  }
+
+  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>
+    }>
+  }> {
+    return await this.invoke('discoverByIdentityKey', args)
+  }
+
+  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>
+    }>
+  }> {
+    return await this.invoke('discoverByAttributes', args)
+  }
+
+  async isAuthenticated(args: {}): Promise<{ authenticated: true }> {
+    return await this.invoke('isAuthenticated', args)
+  }
+
+  async waitForAuthentication(args: {}): Promise<{ authenticated: true }> {
+    return await this.invoke('waitForAuthentication', args)
+  }
+
+  async getHeight(args: {}): Promise<{ height: PositiveInteger }> {
+    return await this.invoke('getHeight', args)
+  }
+
+  async getHeaderForHeight(args: {
+    height: PositiveInteger
+  }): Promise<{ header: HexString }> {
+    return await this.invoke('getHeaderForHeight', args)
+  }
+
+  async getNetwork(args: {}): Promise<{ network: 'mainnet' | 'testnet' }> {
+    return await this.invoke('getNetwork', args)
+  }
+
+  async getVersion(args: {}): Promise<{ version: VersionString7To30Bytes }> {
+    return await this.invoke('getVersion', args)
+  }
+}

package/src/wallet/substrates/index.ts

@@ -6,3 +6,4 @@ export { default as WalletWireTransceiver } from './WalletWireTransceiver.js'
 export { default as WalletWireProcessor } from './WalletWireProcessor.js'
 export { default as HTTPWalletWire } from './HTTPWalletWire.js'
 export { default as HTTPWalletJSON } from './HTTPWalletJSON.js'
+export { default as ReactNativeWebView } from './ReactNativeWebView.js'