Class ServiceWorkerWallet

ReadonlycontractRepository

Readonlyidentity

ReadonlywalletRepository

assetManager

• get assetManager(): IAssetManager

  Asset manager bound to this wallet instance.

  Returns IAssetManager

advanceSigningDescriptorWatermark

• advanceSigningDescriptorWatermark(descriptor: string): Promise<void>

  Parameters

  • descriptor: string

  Returns Promise<void>

  See

  HDAllocationCapable.advanceSigningDescriptorWatermark

getArkadeBroadcaster

• getArkadeBroadcaster(): Promise<ArkadeBroadcaster>

  An ArkadeBroadcaster proxied to the worker, which holds the provider. Only ServiceWorkerWallet offers one: a readonly worker refuses SUBMIT_TX/FINALIZE_TX outright, so exposing it on the readonly class would promise something the boundary rejects.

  Returns Promise<ArkadeBroadcaster>

getCurrentSigningDescriptor

• getCurrentSigningDescriptor(): Promise<string | undefined>

  Returns Promise<string | undefined>

  See

  HDWalletCapable.getCurrentSigningDescriptor

getDelegateManager

• getDelegateManager(): Promise<IDelegateManager | undefined>

  Returns Promise<IDelegateManager | undefined>

  Delegation manager, when configured.

getNewAddresses

• getNewAddresses(opts?: GetNewAddressesOptions): Promise<NewAddress[]>

  Parameters

  • Optionalopts: GetNewAddressesOptions

  Returns Promise<NewAddress[]>

  See

  Wallet.getNewAddresses

  Proxied as a single request rather than rebuilt page-side out of getNextSigningDescriptor: the worker owns the HD watermark and the contract repository, so splitting the operation would let a page burn an index and then fail to register the script, leaving an address nothing watches.

  Note the error shape — WalletCannotAllocateAddressError is thrown worker-side and cannot cross the message boundary as a class, so a forceNew refusal surfaces here as a plain Error carrying its message (and the worker-side error as cause). Callers that must branch on the refusal match the message rather than instanceof.

getNextSigningDescriptor

• getNextSigningDescriptor(): Promise<string | undefined>

  Returns Promise<string | undefined>

  See

  HDAllocationCapable.getNextSigningDescriptor

getUsedSigningDescriptors

• getUsedSigningDescriptors(opts?: { lookAhead?: number }): Promise<string[]>

  Parameters

  • Optionalopts: { lookAhead?: number }

  Returns Promise<string[]>

  See

  HDWalletCapable.getUsedSigningDescriptors

getVtxoManager

• getVtxoManager(): Promise<IVtxoManager>

  Returns Promise<IVtxoManager>

restore

• restore(opts?: { gapLimit?: number }): Promise<void>

  Explicitly recover this wallet's contracts and balance on a fresh repo. Mirrors Wallet.restore but drives the scan inside the service worker — the materialize() callback used by scanContracts cannot cross the postMessage boundary, so the entire flow runs worker-side and only the gapLimit / outcome cross the wire.

  Uses the streaming send path so the bus deadline does not race a long indexer-bound scan. AggregateError thrown by the worker is reconstructed here so callers can inspect .errors.

  Parameters

  • Optionalopts: { gapLimit?: number }

  Returns Promise<void>

send

• send(...args: [SendParams] | [Recipient, ...Recipient[]]): Promise<string>

  Send bitcoin and/or assets to one or more Arkade recipients, passed either as variadic Recipients or as a single SendParams object — the latter also carries the inputs to spend.

  Parameters

  • ...args: [SendParams] | [Recipient, ...Recipient[]]

    Recipients, or a SendParams object

  Returns Promise<string>

  Arkade transaction id

  See

  SendParams

  Example

  await wallet.send({ address: 'ark1q...', amount: 1000 })
  
  // choosing the inputs as well as the outputs
  await wallet.send({
      recipients: [{ address: 'ark1q...', amount: 1000 }],
      selectedVtxos: mine,
  })
  Copy

settle

• settle(
      params?: SettleParams,
      callback?: (event: SettlementEvent) => void,
  ): Promise<string>

  Settle boarding inputs and/or preconfirmed virtual outputs into settled virtual outputs.

  Parameters

  • Optionalparams: SettleParams

    Optional explicit settlement inputs and outputs

  • Optionalcallback: (event: SettlementEvent) => void

  Returns Promise<string>

  Arkade transaction id

  See

  SettleParams

signerForDescriptor

• signerForDescriptor(descriptor: string): Promise<Identity>

  Parameters

  • descriptor: string

  Returns Promise<Identity>

  See

  HDWalletCapable.signerForDescriptor

  Runs page-side: an Identity cannot cross the message bus, and it does not need to — the page owns the signing identity, and resolving a descriptor reads no allocation state. Shares resolveDescriptorSigner with Wallet.signerForDescriptor so the two sides of the bus cannot answer differently for one descriptor.

  No provider is passed, and none is needed: HDDescriptorProvider's isOurs and signing members all delegate to the identity, which the page holds. Building one here would only add a page-side read of the wallet state the worker allocates from — shared mutable state on a path that has no business touching it.

Staticcreate

• create(options: ServiceWorkerWalletCreateOptions): Promise<ServiceWorkerWallet>

  Create a readonly service-worker wallet bound to an already-registered worker.

  Parameters

  • options: ServiceWorkerWalletCreateOptions

    Service worker, identity, and backend configuration

  Returns Promise<ServiceWorkerWallet>

  Initialized readonly service-worker wallet

  Throws

  Error if service-worker initialization fails

Staticsetup

• setup(options: ServiceWorkerWalletSetupOptions): Promise<ServiceWorkerWallet>

  Simplified setup method that handles service worker registration and wallet initialization automatically.

  Parameters

  • options: ServiceWorkerWalletSetupOptions

  Returns Promise<ServiceWorkerWallet>

  Example

  const wallet = await ServiceWorkerWallet.setup({
    serviceWorkerPath: '/service-worker.js',
    arkServer: { url: 'https://arkade.computer' },
    identity: MnemonicIdentity.fromMnemonic('abandon abandon...')
  });
  Copy