@bsv/sdk 1.9.0 → 1.9.2

package/docs/reference/registry.md

@@ -205,22 +205,27 @@ It provides methods to:
 - Register new definitions using pushdrop-based UTXOs.
 - Resolve existing definitions using a lookup service.
 - List registry entries associated with the operator's wallet.
-- Revoke an existing registry entry by spending its UTXO.
+- Remove existing registry entries by spending their UTXOs.
+- Update existing registry entries.
 
 Registry operators use this client to establish and manage
 canonical references for baskets, protocols, and certificate types.
 
 ```ts
 export class RegistryClient {
-    constructor(private readonly wallet: WalletInterface = new WalletClient()) 
+    constructor(private readonly wallet: WalletInterface = new WalletClient(), options: {
+        acceptDelayedBroadcast?: boolean;
+        resolver?: LookupResolver;
+    } = {}) 
     async registerDefinition(data: DefinitionData): Promise<BroadcastResponse | BroadcastFailure> 
     async resolve<T extends DefinitionType>(definitionType: T, query: RegistryQueryMapping[T]): Promise<DefinitionData[]> 
     async listOwnRegistryEntries(definitionType: DefinitionType): Promise<RegistryRecord[]> 
-    async revokeOwnRegistryEntry(registryRecord: RegistryRecord): Promise<BroadcastResponse | BroadcastFailure> 
+    async removeDefinition(registryRecord: RegistryRecord): Promise<BroadcastResponse | BroadcastFailure> 
+    async updateDefinition(registryRecord: RegistryRecord, updatedData: DefinitionData): Promise<BroadcastResponse | BroadcastFailure> 
 }
 ```
 
-See also: [BroadcastFailure](./transaction.md#interface-broadcastfailure), [BroadcastResponse](./transaction.md#interface-broadcastresponse), [DefinitionData](./registry.md#type-definitiondata), [DefinitionType](./registry.md#type-definitiontype), [RegistryQueryMapping](./registry.md#interface-registryquerymapping), [RegistryRecord](./registry.md#type-registryrecord), [WalletClient](./wallet.md#class-walletclient), [WalletInterface](./wallet.md#interface-walletinterface)
+See also: [BroadcastFailure](./transaction.md#interface-broadcastfailure), [BroadcastResponse](./transaction.md#interface-broadcastresponse), [DefinitionData](./registry.md#type-definitiondata), [DefinitionType](./registry.md#type-definitiontype), [LookupResolver](./overlay-tools.md#class-lookupresolver), [RegistryQueryMapping](./registry.md#interface-registryquerymapping), [RegistryRecord](./registry.md#type-registryrecord), [WalletClient](./wallet.md#class-walletclient), [WalletInterface](./wallet.md#interface-walletinterface)
 
 #### Method listOwnRegistryEntries
 
@@ -264,6 +269,24 @@ Argument Details
 + **data**
   + Structured information about a 'basket', 'protocol', or 'certificate'.
 
+#### Method removeDefinition
+
+Removes a registry definition by spending its associated UTXO.
+
+```ts
+async removeDefinition(registryRecord: RegistryRecord): Promise<BroadcastResponse | BroadcastFailure> 
+```
+See also: [BroadcastFailure](./transaction.md#interface-broadcastfailure), [BroadcastResponse](./transaction.md#interface-broadcastresponse), [RegistryRecord](./registry.md#type-registryrecord)
+
+Returns
+
+Broadcast success/failure.
+
+Argument Details
+
++ **registryRecord**
+  + The registry record to remove (must have valid txid, outputIndex, and lockingScript).
+
 #### Method resolve
 
 Resolves registrant tokens of a particular type using a lookup service.
@@ -292,14 +315,14 @@ Argument Details
 + **query**
   + The query object used to filter registry records, whose shape is determined by the registry type.
 
-#### Method revokeOwnRegistryEntry
+#### Method updateDefinition
 
-Revokes a registry record by spending its associated UTXO.
+Updates an existing registry record by spending its UTXO and creating a new one with updated data.
 
 ```ts
-async revokeOwnRegistryEntry(registryRecord: RegistryRecord): Promise<BroadcastResponse | BroadcastFailure> 
+async updateDefinition(registryRecord: RegistryRecord, updatedData: DefinitionData): Promise<BroadcastResponse | BroadcastFailure> 
 ```
-See also: [BroadcastFailure](./transaction.md#interface-broadcastfailure), [BroadcastResponse](./transaction.md#interface-broadcastresponse), [RegistryRecord](./registry.md#type-registryrecord)
+See also: [BroadcastFailure](./transaction.md#interface-broadcastfailure), [BroadcastResponse](./transaction.md#interface-broadcastresponse), [DefinitionData](./registry.md#type-definitiondata), [RegistryRecord](./registry.md#type-registryrecord)
 
 Returns
 
@@ -308,7 +331,9 @@ Broadcast success/failure.
 Argument Details
 
 + **registryRecord**
-  + Must have valid txid, outputIndex, and lockingScript.
+  + The existing registry record to update (must have valid txid, outputIndex, and lockingScript).
++ **updatedData**
+  + The new definition data to replace the old record.
 
 Links: [API](#api), [Interfaces](#interfaces), [Classes](#classes), [Functions](#functions), [Types](#types), [Enums](#enums), [Variables](#variables)
 

package/package.json

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

package/src/kvstore/LocalKVStore.ts

@@ -115,7 +115,7 @@ export default class LocalKVStore {
       tagQueryMode: 'all',
       include: 'entire transactions',
       limit
-    })
+    }, this.originator)
     return results
   }
 
@@ -175,7 +175,7 @@ export default class LocalKVStore {
       const { plaintext } = await this.wallet.decrypt({
         ...this.getProtocol(key),
         ciphertext: field
-      })
+      }, this.originator)
       r.value = Utils.toUTF8(plaintext)
     }
     return r
@@ -241,7 +241,7 @@ export default class LocalKVStore {
         const { ciphertext } = await this.wallet.encrypt({
           ...protocol,
           plaintext: valueAsArray
-        })
+        }, this.originator)
         valueAsArray = ciphertext
       }
 
@@ -272,7 +272,7 @@ export default class LocalKVStore {
             acceptDelayedBroadcast: this.acceptDelayedBroadcast,
             randomizeOutputs: false
           }
-        })
+        }, this.originator)
 
         if (outputs.length > 0 && typeof signableTransaction !== 'object') {
           throw new Error('Wallet did not return a signable transaction when expected.')
@@ -285,7 +285,7 @@ export default class LocalKVStore {
           const { txid } = await this.wallet.signAction({
             reference: signableTransaction.reference,
             spends
-          })
+          }, this.originator)
           outpoint = `${txid as string}.0`
         }
       } catch (error) {
@@ -326,7 +326,7 @@ export default class LocalKVStore {
               options: {
                 acceptDelayedBroadcast: this.acceptDelayedBroadcast
               }
-            })
+            }, this.originator)
             if (typeof signableTransaction !== 'object') {
               throw new Error('Wallet did not return a signable transaction when expected.')
             }
@@ -334,7 +334,7 @@ export default class LocalKVStore {
             const { txid } = await this.wallet.signAction({
               reference: signableTransaction.reference,
               spends
-            })
+            }, this.originator)
             if (txid === undefined) { throw new Error('signAction must return a valid txid') }
             txids.push(txid)
           } catch (error) {

package/src/kvstore/__tests/LocalKVStore.test.ts

@@ -104,7 +104,7 @@ describe('localKVStore', () => {
   // const testUnlockingScriptHex = 'mockUnlockingScriptHex'; // Defined above
 
   beforeEach(() => {
-  // Reset mocks before each test (clears calls and resets implementations)
+    // Reset mocks before each test (clears calls and resets implementations)
     jest.clearAllMocks()
 
     // Create a fresh mock wallet for each test
@@ -122,7 +122,7 @@ describe('localKVStore', () => {
   // --- Constructor Tests ---
   describe('constructor', () => {
     it('should create an instance with default wallet and encrypt=true', () => {
-    // We need to mock the default WalletClient if the SUT uses it
+      // We need to mock the default WalletClient if the SUT uses it
       const MockedWalletClient = require('../../../mod.js').WalletClient
       const store = new LocalKVStore(undefined, 'default-context')
       expect(store).toBeInstanceOf(LocalKVStore)
@@ -200,7 +200,7 @@ describe('localKVStore', () => {
     let pushDropInstance: PushDrop // To access the instance methods
 
     beforeEach(() => {
-    // Get the mock instance that will be created by `new PushDrop()`
+      // Get the mock instance that will be created by `new PushDrop()`
       pushDropInstance = new (PushDrop as any)()
     })
 
@@ -223,7 +223,7 @@ describe('localKVStore', () => {
         plaintext: valueArray, // Should be Array<number>
         protocolID: [2, testContext],
         keyID: testKey
-      })
+      }, undefined)
       // Check the mock instance's lock method
       expect(mockPDInstance.lock).toHaveBeenCalledWith(
         // The lock function expects Array<number[] | Uint8Array>
@@ -250,7 +250,7 @@ describe('localKVStore', () => {
           acceptDelayedBroadcast: false,
           randomizeOutputs: false
         }
-      })
+      }, undefined)
       expect(mockWallet.signAction).not.toHaveBeenCalled()
       expect(mockWallet.relinquishOutput).not.toHaveBeenCalled()
     })
@@ -293,7 +293,7 @@ describe('localKVStore', () => {
           acceptDelayedBroadcast: false,
           randomizeOutputs: false
         }
-      })
+      }, undefined)
       expect(mockWallet.signAction).not.toHaveBeenCalled()
       expect(mockWallet.relinquishOutput).not.toHaveBeenCalled()
     })
@@ -301,7 +301,7 @@ describe('localKVStore', () => {
     it('should update an existing output (spend and create)', async () => {
       const existingOutpoint = 'oldTxId.0'
       const existingOutput = { outpoint: existingOutpoint, txid: 'oldTxId', vout: 0, lockingScript: 'oldScriptHex' } // Added script
-      const mockBEEF = [1,2,3,4,5,6]
+      const mockBEEF = [1, 2, 3, 4, 5, 6]
       const signableRef = 'signableTxRef123'
       const signableTx = []
       const updatedTxId = 'updatedTxId'
@@ -366,7 +366,7 @@ describe('localKVStore', () => {
         outputs: expect.arrayContaining([ // Check outputs array
           expect.objectContaining({ lockingScript: testLockingScriptHex }) // Check the new output script
         ])
-      }))
+      }), undefined)
 
       // Verify signing steps
       expect(MockedTransaction.fromAtomicBEEF).toHaveBeenCalledWith(signableTx)
@@ -383,7 +383,7 @@ describe('localKVStore', () => {
         spends: {
           0: { unlockingScript: testUnlockingScriptHex } // Check unlocking script from mock sign result
         }
-      })
+      }, undefined)
       expect(mockWallet.relinquishOutput).not.toHaveBeenCalled()
     })
 
@@ -395,7 +395,7 @@ describe('localKVStore', () => {
       const existingOutpoint2 = 'oldTxId2.1'
       const existingOutput1 = { outpoint: existingOutpoint1, txid: 'oldTxId1', vout: 0, lockingScript: 's1' }
       const existingOutput2 = { outpoint: existingOutpoint2, txid: 'oldTxId2', vout: 1, lockingScript: 's2' }
-      const mockBEEF = [1,2,3,4,5,6]
+      const mockBEEF = [1, 2, 3, 4, 5, 6]
       const signableRef = 'signableTxRefMulti'
       const signableTx = []
       const updatedTxId = 'updatedTxIdMulti'
@@ -457,7 +457,7 @@ describe('localKVStore', () => {
         outputs: expect.arrayContaining([
           expect.objectContaining({ lockingScript: testLockingScriptHex })
         ])
-      }))
+      }), undefined)
 
       // Verify signing loop
       expect(MockedTransaction.fromAtomicBEEF).toHaveBeenCalledWith(signableTx)
@@ -478,14 +478,14 @@ describe('localKVStore', () => {
           0: { unlockingScript: testUnlockingScriptHex }, // Same mock script for both
           1: { unlockingScript: testUnlockingScriptHex }
         }
-      })
+      }, undefined)
       expect(mockWallet.relinquishOutput).not.toHaveBeenCalled()
     })
 
     it('should preserve original error message when createAction fails', async () => {
       const originalErrorMessage = 'Network connection timeout while creating transaction'
       const originalError = new Error(originalErrorMessage)
-      
+
       // Mock the lookupValue to return a value that differs from what we're setting
       // to ensure set() will attempt to create a transaction
       const mockedLor: ListOutputsResult = {
@@ -533,7 +533,7 @@ describe('localKVStore', () => {
     let pushDropInstance: PushDrop // To access the instance methods
 
     beforeEach(() => {
-    // Get the mock instance that will be created by `new PushDrop()`
+      // Get the mock instance that will be created by `new PushDrop()`
       pushDropInstance = new (PushDrop as any)()
     })
 
@@ -598,7 +598,7 @@ describe('localKVStore', () => {
         options: {
           acceptDelayedBroadcast: false
         }
-      })
+      }, undefined)
       // Check that outputs key is absent
       expect(mockWallet.createAction.mock.calls[0][0]).not.toHaveProperty('outputs')
 
@@ -619,7 +619,7 @@ describe('localKVStore', () => {
           0: { unlockingScript: testUnlockingScriptHex },
           1: { unlockingScript: testUnlockingScriptHex }
         }
-      })
+      }, undefined)
       expect(mockWallet.relinquishOutput).not.toHaveBeenCalled()
     })
 
@@ -659,7 +659,7 @@ describe('localKVStore', () => {
     it('should preserve original error message when wallet operations fail during removal', async () => {
       const originalErrorMessage = 'Insufficient funds to cover transaction fees'
       const originalError = new Error(originalErrorMessage)
-      
+
       const existingOutpoint = 'failTxId.0'
       const existingOutput = { outpoint: existingOutpoint, txid: 'failTxId', vout: 0, lockingScript: 's1' }
       const mockBEEF = Buffer.from('mockBEEFFail')

package/src/registry/RegistryClient.ts

@@ -25,6 +25,7 @@ import {
 } from './types/index.js'
 
 const REGISTRANT_TOKEN_AMOUNT = 1
+const REGISTRANT_KEY_ID = '1'
 
 /**
  * RegistryClient manages on-chain registry definitions for three types:
@@ -36,16 +37,47 @@ const REGISTRANT_TOKEN_AMOUNT = 1
  * - Register new definitions using pushdrop-based UTXOs.
  * - Resolve existing definitions using a lookup service.
  * - List registry entries associated with the operator's wallet.
- * - Revoke an existing registry entry by spending its UTXO.
+ * - Remove existing registry entries by spending their UTXOs.
+ * - Update existing registry entries.
  *
  * Registry operators use this client to establish and manage
  * canonical references for baskets, protocols, and certificate types.
  */
 export class RegistryClient {
-  private network: 'mainnet' | 'testnet'
+  private network: 'mainnet' | 'testnet' | undefined
+  private readonly resolver: LookupResolver
+  private cachedIdentityKey: PubKeyHex | undefined
+  private readonly acceptDelayedBroadcast: boolean
+
   constructor (
-    private readonly wallet: WalletInterface = new WalletClient()
-  ) { }
+    private readonly wallet: WalletInterface = new WalletClient(),
+    options: { acceptDelayedBroadcast?: boolean, resolver?: LookupResolver } = {}
+  ) {
+    this.acceptDelayedBroadcast = options.acceptDelayedBroadcast ?? false
+    this.resolver = options.resolver ?? new LookupResolver()
+  }
+
+  /**
+   * Gets the wallet's identity key, caching it after the first call.
+   * @returns The public identity key as a hex string.
+   */
+  private async getIdentityKey (): Promise<PubKeyHex> {
+    if (this.cachedIdentityKey === undefined) {
+      this.cachedIdentityKey = (await this.wallet.getPublicKey({ identityKey: true })).publicKey
+    }
+    return this.cachedIdentityKey
+  }
+
+  /**
+   * Gets the network, initializing and caching it on first call.
+   * @returns The network type ('mainnet' or 'testnet').
+   */
+  private async getNetwork (): Promise<'mainnet' | 'testnet'> {
+    if (this.network === undefined) {
+      this.network = (await this.wallet.getNetwork({})).network
+    }
+    return this.network
+  }
 
   /**
    * Publishes a new on-chain definition for baskets, protocols, or certificates.
@@ -58,7 +90,7 @@ export class RegistryClient {
    * @returns A promise with the broadcast result or failure.
    */
   async registerDefinition (data: DefinitionData): Promise<BroadcastResponse | BroadcastFailure> {
-    const registryOperator = (await this.wallet.getPublicKey({ identityKey: true })).publicKey
+    const registryOperator = await this.getIdentityKey()
     const pushdrop = new PushDrop(this.wallet)
 
     // Convert definition data into PushDrop fields
@@ -68,7 +100,7 @@ export class RegistryClient {
     const protocol = this.mapDefinitionTypeToWalletProtocol(data.definitionType)
 
     // Lock the fields into a pushdrop-based UTXO
-    const lockingScript = await pushdrop.lock(fields, protocol, '1', 'anyone', true)
+    const lockingScript = await pushdrop.lock(fields, protocol, REGISTRANT_KEY_ID, 'anyone', true)
 
     // Create a transaction
     const { tx } = await this.wallet.createAction({
@@ -82,22 +114,23 @@ export class RegistryClient {
         }
       ],
       options: {
+        acceptDelayedBroadcast: this.acceptDelayedBroadcast,
         randomizeOutputs: false
       }
     })
-
     if (tx === undefined) {
       throw new Error(`Failed to create ${data.definitionType} registration transaction!`)
     }
-
     // Broadcast to the relevant topic
     const broadcaster = new TopicBroadcaster(
       [this.mapDefinitionTypeToTopic(data.definitionType)],
       {
-        networkPreset: this.network ??= (await this.wallet.getNetwork({})).network
+        networkPreset: await this.getNetwork(),
+        resolver: this.resolver
       }
     )
-    return await broadcaster.broadcast(Transaction.fromAtomicBEEF(tx))
+    const result = await broadcaster.broadcast(Transaction.fromAtomicBEEF(tx))
+    return result
   }
 
   /**
@@ -119,11 +152,10 @@ export class RegistryClient {
     definitionType: T,
     query: RegistryQueryMapping[T]
   ): Promise<DefinitionData[]> {
-    const resolver = new LookupResolver()
     const serviceName = this.mapDefinitionTypeToServiceName(definitionType)
 
     // Make the lookup query
-    const result = await resolver.query({ service: serviceName, query })
+    const result = await this.resolver.query({ service: serviceName, query })
     if (result.type !== 'output-list') {
       return []
     }
@@ -164,8 +196,8 @@ export class RegistryClient {
       }
       try {
         const [txid, outputIndex] = output.outpoint.split('.')
-        const tx = Transaction.fromBEEF(BEEF as number[])
-        const lockingScript: LockingScript = tx.outputs[outputIndex].lockingScript
+        const tx = Transaction.fromBEEF(BEEF as number[], txid)
+        const lockingScript: LockingScript = tx.outputs[Number(outputIndex)].lockingScript
         const record = await this.parseLockingScript(
           definitionType,
           lockingScript
@@ -187,12 +219,12 @@ export class RegistryClient {
   }
 
   /**
-   * Revokes a registry record by spending its associated UTXO.
+   * Removes a registry definition by spending its associated UTXO.
    *
-   * @param registryRecord - Must have valid txid, outputIndex, and lockingScript.
+   * @param registryRecord - The registry record to remove (must have valid txid, outputIndex, and lockingScript).
    * @returns Broadcast success/failure.
    */
-  async revokeOwnRegistryEntry (
+  async removeDefinition (
     registryRecord: RegistryRecord
   ): Promise<BroadcastResponse | BroadcastFailure> {
     if (registryRecord.txid === undefined || typeof registryRecord.outputIndex === 'undefined' || registryRecord.lockingScript === undefined) {
@@ -200,12 +232,12 @@ export class RegistryClient {
     }
 
     // Check if the registry record belongs to the current user
-    const currentIdentityKey = (await this.wallet.getPublicKey({ identityKey: true })).publicKey
+    const currentIdentityKey = await this.getIdentityKey()
     if (registryRecord.registryOperator !== currentIdentityKey) {
       throw new Error('This registry token does not belong to the current wallet.')
     }
 
-    // Create a descriptive label for the item we’re revoking
+    // Create a descriptive label for the item we're removing
     const itemIdentifier =
       registryRecord.definitionType === 'basket'
         ? registryRecord.basketID
@@ -217,48 +249,159 @@ export class RegistryClient {
 
     const outpoint = `${registryRecord.txid}.${registryRecord.outputIndex}`
     const { signableTransaction } = await this.wallet.createAction({
-      description: `Revoke ${registryRecord.definitionType} item: ${itemIdentifier}`,
+      description: `Remove ${registryRecord.definitionType} item: ${itemIdentifier}`,
       inputBEEF: registryRecord.beef,
       inputs: [
         {
           outpoint,
-          unlockingScriptLength: 73,
-          inputDescription: `Revoking ${registryRecord.definitionType} token`
+          unlockingScriptLength: 74,
+          inputDescription: `Removing ${registryRecord.definitionType} token`
         }
-      ]
+      ],
+      options: {
+        acceptDelayedBroadcast: this.acceptDelayedBroadcast,
+        randomizeOutputs: false
+      }
     })
 
     if (signableTransaction === undefined) {
       throw new Error('Failed to create signable transaction.')
     }
-
-    const partialTx = Transaction.fromBEEF(signableTransaction.tx)
+    const partialTx = Transaction.fromAtomicBEEF(signableTransaction.tx)
 
     // Prepare the unlocker
     const pushdrop = new PushDrop(this.wallet)
-    const unlocker = await pushdrop.unlock(
+    const unlocker = pushdrop.unlock(
       this.mapDefinitionTypeToWalletProtocol(registryRecord.definitionType),
-      '1',
-      'anyone',
-      'all',
-      false,
-      registryRecord.satoshis,
-      LockingScript.fromHex(registryRecord.lockingScript)
+      REGISTRANT_KEY_ID,
+      'anyone'
     )
 
     // Convert to Transaction, apply signature
-    const finalUnlockScript = await unlocker.sign(partialTx, registryRecord.outputIndex)
+    const finalUnlockScript = await unlocker.sign(partialTx, 0)
+
+    // Complete signing with the final unlock script
+    const { tx: signedTx } = await this.wallet.signAction({
+      reference: signableTransaction.reference,
+      spends: {
+        0: {
+          unlockingScript: finalUnlockScript.toHex()
+        }
+      },
+      options: {
+        acceptDelayedBroadcast: this.acceptDelayedBroadcast
+      }
+    })
+
+    if (signedTx === undefined) {
+      throw new Error('Failed to finalize the transaction signature.')
+    }
+    // Broadcast
+    const broadcaster = new TopicBroadcaster(
+      [this.mapDefinitionTypeToTopic(registryRecord.definitionType)],
+      {
+        networkPreset: await this.getNetwork(),
+        resolver: this.resolver
+      }
+    )
+    const result = await broadcaster.broadcast(Transaction.fromAtomicBEEF(signedTx))
+    return result
+  }
+
+  /**
+   * Updates an existing registry record by spending its UTXO and creating a new one with updated data.
+   *
+   * @param registryRecord - The existing registry record to update (must have valid txid, outputIndex, and lockingScript).
+   * @param updatedData - The new definition data to replace the old record.
+   * @returns Broadcast success/failure.
+   */
+  async updateDefinition (
+    registryRecord: RegistryRecord,
+    updatedData: DefinitionData
+  ): Promise<BroadcastResponse | BroadcastFailure> {
+    if (registryRecord.txid === undefined || typeof registryRecord.outputIndex === 'undefined' || registryRecord.lockingScript === undefined) {
+      throw new Error('Invalid registry record. Missing txid, outputIndex, or lockingScript.')
+    }
+
+    // Verify the updated data matches the record type
+    if (registryRecord.definitionType !== updatedData.definitionType) {
+      throw new Error(`Cannot change definition type from ${registryRecord.definitionType} to ${updatedData.definitionType}`)
+    }
+
+    // Check if the registry record belongs to the current user
+    const currentIdentityKey = await this.getIdentityKey()
+    if (registryRecord.registryOperator !== currentIdentityKey) {
+      throw new Error('This registry token does not belong to the current wallet.')
+    }
+
+    // Create a descriptive label for the item we're updating
+    const itemIdentifier =
+      registryRecord.definitionType === 'basket'
+        ? registryRecord.basketID
+        : registryRecord.definitionType === 'protocol'
+          ? registryRecord.name
+          : registryRecord.definitionType === 'certificate'
+            ? (registryRecord.name !== undefined ? registryRecord.name : registryRecord.type)
+            : 'unknown'
+
+    const pushdrop = new PushDrop(this.wallet)
+
+    // Build the new locking script with updated data
+    const fields = this.buildPushDropFields(updatedData, currentIdentityKey)
+    const protocol = this.mapDefinitionTypeToWalletProtocol(updatedData.definitionType)
+    const newLockingScript = await pushdrop.lock(fields, protocol, REGISTRANT_KEY_ID, 'anyone', true)
+
+    const outpoint = `${registryRecord.txid}.${registryRecord.outputIndex}`
+    const { signableTransaction } = await this.wallet.createAction({
+      description: `Update ${registryRecord.definitionType} item: ${itemIdentifier}`,
+      inputBEEF: registryRecord.beef,
+      inputs: [
+        {
+          outpoint,
+          unlockingScriptLength: 74,
+          inputDescription: `Updating ${registryRecord.definitionType} token`
+        }
+      ],
+      outputs: [
+        {
+          satoshis: REGISTRANT_TOKEN_AMOUNT,
+          lockingScript: newLockingScript.toHex(),
+          outputDescription: `Updated ${registryRecord.definitionType} registration token`,
+          basket: this.mapDefinitionTypeToBasketName(registryRecord.definitionType)
+        }
+      ],
+      options: {
+        acceptDelayedBroadcast: this.acceptDelayedBroadcast,
+        randomizeOutputs: false
+      }
+    })
+
+    if (signableTransaction === undefined) {
+      throw new Error('Failed to create signable transaction.')
+    }
+
+    const partialTx = Transaction.fromAtomicBEEF(signableTransaction.tx)
+
+    // Prepare the unlocker for the input
+    const unlocker = pushdrop.unlock(
+      this.mapDefinitionTypeToWalletProtocol(registryRecord.definitionType),
+      REGISTRANT_KEY_ID,
+      'anyone'
+    )
+
+    // Sign the input
+    const finalUnlockScript = await unlocker.sign(partialTx, 0)
 
     // Complete signing with the final unlock script
     const { tx: signedTx } = await this.wallet.signAction({
       reference: signableTransaction.reference,
       spends: {
-        [registryRecord.outputIndex]: {
+        0: {
           unlockingScript: finalUnlockScript.toHex()
         }
       },
       options: {
-        acceptDelayedBroadcast: false
+        acceptDelayedBroadcast: this.acceptDelayedBroadcast
       }
     })
 
@@ -270,7 +413,8 @@ export class RegistryClient {
     const broadcaster = new TopicBroadcaster(
       [this.mapDefinitionTypeToTopic(registryRecord.definitionType)],
       {
-        networkPreset: this.network ??= (await this.wallet.getNetwork({})).network
+        networkPreset: await this.getNetwork(),
+        resolver: this.resolver
       }
     )
     return await broadcaster.broadcast(Transaction.fromAtomicBEEF(signedTx))