@bsv/sdk 1.10.4 → 2.0.0

package/src/remittance/modules/BasicBRC29.ts

@@ -0,0 +1,361 @@
+import type {
+  Invoice,
+  RemittanceOptionId,
+  Termination
+} from '../types.js'
+import type { ModuleContext } from '../types.js'
+import type { RemittanceModule } from '../RemittanceModule.js'
+import type {
+  WalletInterface,
+  WalletCounterparty,
+  PubKeyHex,
+  OriginatorDomainNameStringUnder250Bytes,
+  WalletProtocol
+} from '../../wallet/Wallet.interfaces.js'
+import { createNonce } from '../../auth/utils/createNonce.js'
+import P2PKH from '../../script/templates/P2PKH.js'
+import PublicKey from '../../primitives/PublicKey.js'
+
+/**
+ * BRC-29-like payment option terms.
+ *
+ * This module intentionally keeps option terms minimal:
+ * - Amount is taken from the invoice total (and validated as satoshis)
+ * - The payer derives the payee's per-payment public key using wallet.getPublicKey with a stable protocolID
+ */
+export interface Brc29OptionTerms {
+  /** Payment amount in satoshis. */
+  amountSatoshis: number
+  /** The recipient of the payment */
+  payee: PubKeyHex
+  /** Which output index to internalize, default 0. */
+  outputIndex?: number
+  /** Optionally override the protocolID used in getPublicKey. */
+  protocolID?: WalletProtocol
+  /** Optional labels for createAction. */
+  labels?: string[]
+  /** Optional description for createAction. */
+  description?: string
+}
+
+/**
+ * Settlement artifact carried in the settlement message.
+ */
+export interface Brc29SettlementArtifact {
+  customInstructions: {
+    derivationPrefix: string
+    derivationSuffix: string
+  }
+  transaction: number[]
+  amountSatoshis: number
+  outputIndex?: number
+}
+
+/**
+ * Receipt data for BRC-29 settlements.
+ */
+export interface Brc29ReceiptData {
+  /** Result returned from wallet.internalizeAction, if accepted. */
+  internalizeResult?: unknown
+  /** Human-readable rejection reason, if rejected. */
+  rejectedReason?: string
+  /** If rejected with refund, contains the refund payment token. */
+  refund?: {
+    token: Brc29SettlementArtifact
+    feeSatoshis: number
+  }
+}
+
+export interface NonceProvider {
+  createNonce: (wallet: WalletInterface, scope: WalletCounterparty, originator?: unknown) => Promise<string>
+}
+
+export interface LockingScriptProvider {
+  /** Converts a public key string to a P2PKH locking script hex. */
+  pubKeyToP2PKHLockingScript: (publicKey: string) => Promise<string> | string
+}
+
+/**
+ * Default nonce provider using SDK createNonce.
+ */
+export const DefaultNonceProvider: NonceProvider = {
+  async createNonce(wallet, scope, originator) {
+    const origin = originator as OriginatorDomainNameStringUnder250Bytes | undefined
+    return await createNonce(wallet, scope, origin)
+  }
+}
+
+/**
+ * Default locking script provider using SDK P2PKH template.
+ */
+export const DefaultLockingScriptProvider: LockingScriptProvider = {
+  async pubKeyToP2PKHLockingScript(publicKey: string) {
+    const address = PublicKey.fromString(publicKey).toAddress()
+    return new P2PKH().lock(address).toHex()
+  }
+}
+
+export interface Brc29RemittanceModuleConfig {
+  /** Default protocolID to use with wallet.getPublicKey. */
+  protocolID?: WalletProtocol
+  /** Labels applied to created actions. */
+  labels?: string[]
+  /** Description applied to created actions. */
+  description?: string
+  /** Output description for created actions. */
+  outputDescription?: string
+
+  /**
+   * Fee charged on refunds, in satoshis.
+   */
+  refundFeeSatoshis?: number
+
+  /**
+   * Minimum refund to issue. If refund would be smaller, module will reject without refund.
+   */
+  minRefundSatoshis?: number
+
+  /** How wallet internalizes the payment. */
+  internalizeProtocol?: 'wallet payment' | 'basket insertion'
+
+  nonceProvider?: NonceProvider
+  lockingScriptProvider?: LockingScriptProvider
+}
+
+/**
+ * BRC-29-based remittance module.
+ * - payer creates a payment action to a derived P2PKH output
+ * - payer sends { tx, derivationPrefix, derivationSuffix } as settlement artifact
+ * - payee internalizes the tx output using wallet.internalizeAction
+ * - optional rejection can include a refund token embedded in the termination details
+ */
+export class Brc29RemittanceModule
+  implements RemittanceModule<Brc29OptionTerms, Brc29SettlementArtifact, Brc29ReceiptData> {
+  readonly id: RemittanceOptionId = 'brc29.p2pkh'
+  readonly name = 'BSV (BRC-29 derived P2PKH)'
+  readonly allowUnsolicitedSettlements = true
+
+  private readonly protocolID: WalletProtocol
+  private readonly labels: string[]
+  private readonly description: string
+  private readonly outputDescription: string
+  private readonly refundFeeSatoshis: number
+  private readonly minRefundSatoshis: number
+  private readonly internalizeProtocol: 'wallet payment' | 'basket insertion'
+  private readonly nonceProvider: NonceProvider
+  private readonly lockingScriptProvider: LockingScriptProvider
+
+  constructor(cfg: Brc29RemittanceModuleConfig = {}) {
+    // BRC-29 Protocol.
+    this.protocolID = cfg.protocolID ?? [2, '3241645161d8']
+    this.labels = cfg.labels ?? ['brc29']
+    this.description = cfg.description ?? 'BRC-29 payment'
+    this.outputDescription = cfg.outputDescription ?? 'Payment for remittance invoice'
+    this.refundFeeSatoshis = cfg.refundFeeSatoshis ?? 1000
+    this.minRefundSatoshis = cfg.minRefundSatoshis ?? 1000
+    this.internalizeProtocol = cfg.internalizeProtocol ?? 'wallet payment'
+    this.nonceProvider = cfg.nonceProvider ?? DefaultNonceProvider
+    this.lockingScriptProvider = cfg.lockingScriptProvider ?? DefaultLockingScriptProvider
+  }
+
+  async buildSettlement(
+    args: { threadId: string; option: Brc29OptionTerms; note?: string },
+    ctx: ModuleContext
+  ): Promise<{ action: 'settle'; artifact: Brc29SettlementArtifact } | { action: 'terminate'; termination: Termination }> {
+    const { wallet, originator } = ctx
+
+    let option: Brc29OptionTerms
+    try {
+      option = ensureValidOption(args.option)
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return terminate('brc29.invalid_option', message)
+    }
+
+    const amountSatoshis = option.amountSatoshis
+    const origin = originator as OriginatorDomainNameStringUnder250Bytes | undefined
+
+    try {
+      // Create per-payment derivation values.
+      const derivationPrefix = await this.nonceProvider.createNonce(wallet, 'self', origin)
+      const derivationSuffix = await this.nonceProvider.createNonce(wallet, 'self', origin)
+
+      // Derive payee public key.
+      const protocolID = option.protocolID ?? this.protocolID
+      const keyID = `${derivationPrefix} ${derivationSuffix}`
+
+      const { publicKey } = await wallet.getPublicKey(
+        {
+          protocolID,
+          keyID,
+          counterparty: option.payee
+        },
+        origin
+      )
+
+      if (typeof publicKey !== 'string' || publicKey.trim() === '') {
+        return terminate('brc29.public_key_missing', 'Failed to derive payee public key for BRC-29 settlement.')
+      }
+
+      const lockingScript = await this.lockingScriptProvider.pubKeyToP2PKHLockingScript(publicKey)
+      if (typeof lockingScript !== 'string' || lockingScript.trim() === '') {
+        return terminate('brc29.locking_script_missing', 'Failed to produce P2PKH locking script.')
+      }
+
+      const action = await wallet.createAction(
+        {
+          description: option.description ?? this.description,
+          labels: option.labels ?? this.labels,
+          outputs: [
+            {
+              satoshis: amountSatoshis,
+              lockingScript,
+              customInstructions: JSON.stringify({
+                derivationPrefix,
+                derivationSuffix,
+                payee: option.payee,
+                threadId: args.threadId,
+                note: args.note
+              }),
+              outputDescription: this.outputDescription
+            }
+          ],
+          options: {
+            randomizeOutputs: false
+          }
+        },
+        origin
+      )
+
+      const tx = action.tx ?? action.signableTransaction?.tx
+      if (tx == null) {
+        return terminate('brc29.missing_tx', 'wallet.createAction did not return a transaction.')
+      }
+      if (!isAtomicBeef(tx)) {
+        return terminate('brc29.invalid_tx', 'wallet.createAction returned an invalid transaction payload.')
+      }
+
+      return {
+        action: 'settle',
+        artifact: {
+          customInstructions: { derivationPrefix, derivationSuffix },
+          transaction: tx,
+          amountSatoshis: option.amountSatoshis,
+          outputIndex: option.outputIndex ?? 0
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return terminate('brc29.build_failed', `BRC-29 settlement failed: ${message}`)
+    }
+  }
+
+  async acceptSettlement(
+    args: { threadId: string; settlement: Brc29SettlementArtifact; sender: PubKeyHex },
+    ctx: ModuleContext
+  ): Promise<{ action: 'accept'; receiptData?: Brc29ReceiptData } | { action: 'terminate'; termination: Termination }> {
+    const { wallet, originator } = ctx
+    const origin = originator as OriginatorDomainNameStringUnder250Bytes | undefined
+    console.log('acceptSettlement', args)
+    try {
+      const settlement = ensureValidSettlement(args.settlement)
+      const outputIndex = settlement.outputIndex ?? 0
+      debugger
+      const internalizeResult = await wallet.internalizeAction(
+        {
+          tx: settlement.transaction,
+          outputs: [
+            {
+              paymentRemittance: {
+                derivationPrefix: settlement.customInstructions.derivationPrefix,
+                derivationSuffix: settlement.customInstructions.derivationSuffix,
+                senderIdentityKey: args.sender
+              },
+              outputIndex,
+              protocol: this.internalizeProtocol
+            }
+          ],
+          labels: this.labels,
+          description: 'BRC-29 payment received'
+        },
+        origin
+      )
+
+      return { action: 'accept', receiptData: { internalizeResult } }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error)
+      return terminate('brc29.internalize_failed', `Failed to internalize BRC-29 settlement: ${message}`)
+    }
+  }
+}
+
+function terminate(code: string, message: string, details?: unknown): { action: 'terminate'; termination: Termination } {
+  return { action: 'terminate', termination: { code, message, details } }
+}
+
+function ensureValidOption(option: Brc29OptionTerms): Brc29OptionTerms {
+  if (option == null || typeof option !== 'object') {
+    throw new Error('BRC-29 option terms are required')
+  }
+  const amountSatoshis = (option as Brc29OptionTerms).amountSatoshis
+  if (!Number.isInteger(amountSatoshis) || amountSatoshis <= 0) {
+    throw new Error('BRC-29 option amount must be a positive integer')
+  }
+  const outputIndex = (option as Brc29OptionTerms).outputIndex
+  if (outputIndex != null && (!Number.isInteger(outputIndex) || outputIndex < 0)) {
+    throw new Error('BRC-29 option outputIndex must be a non-negative integer')
+  }
+  const protocolID = (option as Brc29OptionTerms).protocolID
+  if (protocolID != null) {
+    if (!Array.isArray(protocolID) || protocolID.length !== 2) {
+      throw new Error('BRC-29 option protocolID must be a tuple [number, string]')
+    }
+    const [protocolNumber, protocolString] = protocolID
+    if (!Number.isInteger(protocolNumber) || protocolNumber < 0 || !isNonEmptyString(protocolString)) {
+      throw new Error('BRC-29 option protocolID must be a tuple [number, string]')
+    }
+  }
+  const labels = (option as Brc29OptionTerms).labels
+  if (labels != null && (!Array.isArray(labels) || labels.some((label) => !isNonEmptyString(label)))) {
+    throw new Error('BRC-29 option labels must be a list of non-empty strings')
+  }
+  const description = (option as Brc29OptionTerms).description
+  if (description != null && !isNonEmptyString(description)) {
+    throw new Error('BRC-29 option description must be a non-empty string')
+  }
+  return option
+}
+
+function ensureValidSettlement(settlement: Brc29SettlementArtifact): Brc29SettlementArtifact {
+  if (settlement == null || typeof settlement !== 'object') {
+    throw new Error('BRC-29 settlement artifact is required')
+  }
+  const instructions = settlement.customInstructions
+  if (instructions == null || typeof instructions !== 'object') {
+    throw new Error('BRC-29 settlement requires customInstructions')
+  }
+  if (!isNonEmptyString(instructions.derivationPrefix) || !isNonEmptyString(instructions.derivationSuffix)) {
+    throw new Error('BRC-29 settlement derivation values are required')
+  }
+  const amountSatoshis = settlement.amountSatoshis
+  if (!Number.isInteger(amountSatoshis) || amountSatoshis <= 0) {
+    throw new Error('BRC-29 settlement amount must be a positive integer')
+  }
+  const outputIndex = settlement.outputIndex
+  if (outputIndex != null && (!Number.isInteger(outputIndex) || outputIndex < 0)) {
+    throw new Error('BRC-29 settlement outputIndex must be a non-negative integer')
+  }
+  if (!isAtomicBeef(settlement.transaction)) {
+    throw new Error('BRC-29 settlement transaction must be a non-empty byte array')
+  }
+  return settlement
+}
+
+function isAtomicBeef(tx: unknown): tx is number[] {
+  if (!Array.isArray(tx) || tx.length === 0) return false
+  return tx.every((byte) => Number.isInteger(byte) && byte >= 0 && byte <= 255)
+}
+
+function isNonEmptyString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0
+}

package/src/remittance/modules/index.ts

@@ -0,0 +1 @@
+export * from './BasicBRC29.js'

package/src/remittance/types.ts

@@ -0,0 +1,284 @@
+import { HexString, OutpointString, PubKeyHex, Base64String, WalletInterface } from '../wallet/index.js'
+
+/**
+ * Types for core Remittance protocol.
+ *
+ * The goal is to keep the core protocol:
+ * - UTXO-friendly (transactions and partial transactions can be carried as artifacts)
+ * - Denomination-agnostic (amounts are typed, not forced to satoshis)
+ * - Module-oriented (remittance option payloads are opaque to the core)
+ */
+
+export type ThreadId = Base64String
+export type RemittanceOptionId = Base64String
+export type UnixMillis = number
+
+/**
+ * Remittance thread state machine.
+ *
+ * States:
+ * - new: thread exists but no identity/invoice/settlement activity yet.
+ * - identityRequested: identity request sent or received.
+ * - identityResponded: identity response sent or received.
+ * - identityAcknowledged: identity response acknowledged (required before proceeding).
+ * - invoiced: invoice sent or received.
+ * - settled: settlement sent or received.
+ * - receipted: receipt issued or received.
+ * - terminated: thread terminated with a reason.
+ * - errored: unexpected error occurred while processing the thread.
+ */
+export type RemittanceThreadState =
+  | 'new'
+  | 'identityRequested'
+  | 'identityResponded'
+  | 'identityAcknowledged'
+  | 'invoiced'
+  | 'settled'
+  | 'receipted'
+  | 'terminated'
+  | 'errored'
+
+/**
+ * Allowed remittance state transitions.
+ *
+ * This is the canonical state machine for remittance threads.
+ * Use it to validate transitions and to build audits/visualizations.
+ */
+export const REMITTANCE_STATE_TRANSITIONS: Record<RemittanceThreadState, RemittanceThreadState[]> = {
+  new: ['identityRequested', 'invoiced', 'settled', 'terminated', 'errored'],
+  identityRequested: ['identityResponded', 'identityAcknowledged', 'invoiced', 'settled', 'terminated', 'errored'],
+  identityResponded: ['identityAcknowledged', 'invoiced', 'settled', 'terminated', 'errored'],
+  identityAcknowledged: ['invoiced', 'settled', 'terminated', 'errored'],
+  invoiced: ['identityRequested', 'identityResponded', 'identityAcknowledged', 'settled', 'terminated', 'errored'],
+  settled: ['receipted', 'terminated', 'errored'],
+  receipted: ['terminated', 'errored'],
+  terminated: ['errored'],
+  errored: []
+}
+
+export interface Unit {
+  /** Namespace for disambiguation, e.g. 'bsv', 'iso4217', 'token'. */
+  namespace: string
+  /** Unit code within the namespace, e.g. 'sat', 'USD', 'mnee'. */
+  code: string
+  /** Optional decimal places for display/normalization. */
+  decimals?: number
+}
+
+export interface Amount {
+  /** Decimal string. Avoid floats at the protocol layer. */
+  value: string
+  unit: Unit
+}
+
+export const SAT_UNIT: Unit = { namespace: 'bsv', code: 'sat', decimals: 0 }
+
+export interface LineItem {
+  id?: string
+  description: string
+  /** Decimal string, e.g. '1', '2', '0.5'. */
+  quantity?: string
+  unitPrice?: Amount
+  /** Total amount for the line (optional if derivable). */
+  amount?: Amount
+  metadata?: Record<string, unknown>
+}
+
+/**
+ * Shared commercial/metadata fields for invoice and receipt-like instruments.
+ *
+ * NOTE: "payee" and "payer" are identity keys, not addresses.
+ * Payment addresses / scripts are settlement-module concerns.
+ */
+export interface InstrumentBase {
+  threadId: ThreadId
+  payee: PubKeyHex
+  payer: PubKeyHex
+  note?: string
+  lineItems: LineItem[]
+  total: Amount
+  invoiceNumber: string
+  createdAt: UnixMillis
+  arbitrary?: Record<string, unknown>
+}
+
+/**
+ * Invoice (solicitation) that contains N remittance options.
+ *
+ * Each remittance option is keyed by a module id.
+ * The payload for each option is module-defined and opaque to the core.
+ *
+ * This is where “UTXO offers” live: a module option payload can include a partial tx template,
+ * UTXO references, scripts, overlay anchors, SPV, etc. The manager does not interpret them.
+ */
+export interface Invoice extends InstrumentBase {
+  kind: 'invoice'
+  expiresAt?: UnixMillis
+  options: Record<RemittanceOptionId, unknown>
+}
+
+/**
+ * An identity certificate request.
+ *
+ * Contains a list of requested certificate types, fields from each, plus acceptable certifiers.
+ */
+export interface IdentityVerificationRequest {
+  kind: 'identityVerificationRequest'
+  threadId: ThreadId
+  /** Details of the requested certificates. */
+  request: {
+    /** Map of certificate types to requested fields from each. */
+    types: Record<string, string[]>
+    /** List of acceptable certifier identity keys. */
+    certifiers: PubKeyHex[]
+  }
+}
+
+/**
+ * An identity certificate response.
+ *
+ * Contains certificates issued by the certifiers named in the corresponding request, with fields revealed to the counterparty.
+ */
+export interface IdentityVerificationResponse {
+  kind: 'identityVerificationResponse'
+  threadId: ThreadId
+  /** List of certificates issued by the certifiers named in the corresponding request, with fields revealed to the counterparty. */
+  certificates: Array<{
+    /** Certificate type, e.g. base64 Type ID corresponding to 'personalId', 'businessId', etc. */
+    type: Base64String
+    /** Certifier identity key. */
+    certifier: PubKeyHex
+    /** Subject identity key. */
+    subject: PubKeyHex
+    /** The certificate's encrypted fields that have been signed. */
+    fields: Record<string, Base64String>
+    /** Signature over the cert. */
+    signature: HexString
+    /** Certificate serial number. */
+    serialNumber: Base64String
+    /** Revocation outpoint. If spent on-chain, the certificate is invalid. */
+    revocationOutpoint: OutpointString
+    /** Field revelation keys for the counterparty. */
+    keyringForVerifier: Record<string, Base64String>
+  }>
+}
+
+/**
+ * An identity verification acknowledgment.
+ *
+ * A simple ack message indicating that a requested identity verification has been completed successfully.
+ */
+export interface IdentityVerificationAcknowledgment {
+  kind: 'identityVerificationAcknowledgment'
+  threadId: ThreadId
+}
+
+/**
+ * A settlement attempt.
+ *
+ * This is module-agnostic: "artifact" can be a transaction, a partial transaction,
+ * a stablecoin transfer result, even a fiat card-payment approval code, etc.
+ */
+export interface Settlement {
+  kind: 'settlement'
+  threadId: ThreadId
+  moduleId: RemittanceOptionId
+  optionId: RemittanceOptionId
+  sender: PubKeyHex
+  createdAt: UnixMillis
+  artifact: unknown
+  note?: string
+}
+
+/**
+ * Receipt issued by the payee (or service provider).
+ *
+ * A receipt could be a PDF, a photo/oroof-of-delivery, a copy of the payment transaction, etc.
+*
+ * A receipt should NOT be issued when a settlement is rejected/failed. Use a Termination instead.
+ */
+export interface Receipt {
+  kind: 'receipt'
+  threadId: ThreadId
+  moduleId: RemittanceOptionId
+  optionId: RemittanceOptionId
+  payee: PubKeyHex
+  payer: PubKeyHex
+  createdAt: UnixMillis
+  receiptData: unknown
+}
+
+/**
+ * Termination details for failed operations.
+ */
+export interface Termination {
+  /** Reason code (module-specific). */
+  code: string
+  /** Human-readable message. */
+  message: string
+  /** Optional module-specific details or refund information. */
+  details?: unknown
+}
+
+/**
+ * Transport message format expected from the CommsLayer.
+ *
+ * It closely matches the message-box-client shapes:
+ * messageId, sender, body, etc.
+ */
+export interface PeerMessage {
+  messageId: string
+  sender: PubKeyHex
+  recipient: PubKeyHex
+  messageBox: string
+  body: string
+}
+
+/**
+ * Protocol envelope kinds.
+ * Everything runs in “threads” and carries a threadId.
+ */
+export type RemittanceKind =
+  | 'invoice'
+  | 'identityVerificationRequest'
+  | 'identityVerificationResponse'
+  | 'identityVerificationAcknowledgment'
+  | 'settlement'
+  | 'receipt'
+  | 'termination'
+
+/**
+ * Protocol envelope.
+ *
+ * This is what RemittanceManager serializes into the CommsLayer message body.
+ */
+export interface RemittanceEnvelope<K extends RemittanceKind = RemittanceKind, P = unknown> {
+  /** Protocol version. */
+  v: 1
+  /** Envelope id (idempotency key). Not the transport messageId. */
+  id: string
+  kind: K
+  threadId: ThreadId
+  createdAt: UnixMillis
+  payload: P
+}
+
+/**
+ * Simple logger interface.
+ */
+export interface LoggerLike {
+  log: (...args: any[]) => void
+  warn: (...args: any[]) => void
+  error: (...args: any[]) => void
+}
+
+/**
+ * Context object passed to module methods.
+ */
+export interface ModuleContext {
+  wallet: WalletInterface
+  /** Optional originator domain forwarded to wallet methods. */
+  originator?: unknown
+  now: () => number
+  logger?: LoggerLike
+}

package/src/script/OP.ts

@@ -63,12 +63,9 @@ const OP = {
 
   // data manipulation ops
   OP_CAT: 0x7e,
-  OP_SUBSTR: 0x7f, // Replaced in BSV
-  OP_SPLIT: 0x7f,
-  OP_LEFT: 0x80, // Replaced in BSV
-  OP_NUM2BIN: 0x80,
-  OP_RIGHT: 0x81, // Replaced in BSV
-  OP_BIN2NUM: 0x81,
+  OP_SPLIT: 0x7f, // after monolith upgrade (May 2018)
+  OP_NUM2BIN: 0x80, // after monolith upgrade (May 2018)
+  OP_BIN2NUM: 0x81, // after monolith upgrade (May 2018)
   OP_SIZE: 0x82,
 
   // bit logic
@@ -127,13 +124,18 @@ const OP = {
 
   // expansion
   OP_NOP1: 0xb0,
-  OP_NOP2: 0xb1,
-  OP_NOP3: 0xb2,
-  OP_NOP4: 0xb3,
-  OP_NOP5: 0xb4,
-  OP_NOP6: 0xb5,
-  OP_NOP7: 0xb6,
-  OP_NOP8: 0xb7,
+  OP_NOP2: 0xb1, // Used on BTC for OP_CHECKLOCKTIMEVERIFY
+  OP_NOP3: 0xb2, // Used on BTC for OP_CHECKSEQUENCEVERIFY
+  OP_NOP4: 0xb3, // OP_NOP4 allocated to restore OP_SUBSTR in 2026 CHRONICLE upgrade
+  OP_SUBSTR: 0xb3, // OP_NOP4 allocated to restore OP_SUBSTR in 2026 CHRONICLE upgrade
+  OP_NOP5: 0xb4, // OP_NOP5 allocated to restore OP_LEFT in 2026 CHRONICLE upgrade
+  OP_LEFT: 0xb4, // OP_NOP5 allocated to restore OP_LEFT in 2026 CHRONICLE upgrade
+  OP_NOP6: 0xb5, // OP_NOP6 allocated to restore OP_RIGHT in 2026 CHRONICLE upgrade
+  OP_RIGHT: 0xb5, // OP_NOP6 allocated to restore OP_RIGHT in 2026 CHRONICLE upgrade
+  OP_NOP7: 0xb6, // OP_NOP7 allocated to restore OP_LSHIFTNUM in 2026 CHRONICLE upgrade
+  OP_LSHIFTNUM: 0xb6, // OP_NOP7 allocated to restore OP_LSHIFTNUM in 2026 CHRONICLE upgrade
+  OP_NOP8: 0xb7, // OP_NOP7 allocated to restore OP_RSHIFTNUM in 2026 CHRONICLE upgrade
+  OP_RSHIFTNUM: 0xb7, // OP_NOP7 allocated to restore OP_RSHIFTNUM in 2026 CHRONICLE upgrade
   OP_NOP9: 0xb8,
   OP_NOP10: 0xb9,
   OP_NOP11: 0xba,