@invisi-labs/sdk 1.1.4 → 1.1.6

package/dist/index.js

@@ -1,8 +1,6 @@
 import {
   DisclosureVerifier,
-  InvisiError,
   Operation,
-  TransactionPreparation,
   WalletSession,
   acceptFundingSignature,
   acceptWalletSignature,
@@ -10,27 +8,33 @@ import {
   decryptCandidates,
   defineGasBenchmarks,
   deserializeState,
-  encodeOperation,
   estimateGasReference,
   fundingSigningRequest,
   operationPreview,
-  positiveAmount,
-  prepareWithErrors,
   proveOperation,
-  publicProof,
   readProtocolLogs,
-  requiresAuthorization,
   sameStatement,
   serializeState,
-  statement,
-  walletBalance,
   walletSigningRequest
-} from "./chunk-BE52B32Z.js";
+} from "./chunk-4SD3MW6N.js";
+import {
+  InvisiError,
+  NoteOutput,
+  TransactionPreparation,
+  configureRecipientInfrastructure,
+  encodeOperation,
+  exportBroadcasterIntent,
+  positiveAmount,
+  prepareWithErrors,
+  publicProof,
+  requiresAuthorization,
+  statement,
+  walletBalance
+} from "./chunk-FL4TIGWW.js";
 import {
-  EthersAddressResolver,
   EthersChainReader,
   EthersFundingVerifier
-} from "./chunk-4HMM7ZKY.js";
+} from "./chunk-QC6TQR3R.js";
 
 // src/explicit-preparation.ts
 import { getAddress } from "ethers";
@@ -63,6 +67,29 @@ var PreparedTransaction = class _PreparedTransaction {
       { generation: 0, busy: false }
     );
   }
+  broadcasterQuote() {
+    return this.#saved.broadcasterQuote ? structuredClone(this.#saved.broadcasterQuote) : void 0;
+  }
+  async withBroadcaster(client, options) {
+    this.current();
+    check(
+      this.status === "prepared" && this.#runtime.reprepare,
+      "broadcaster must attach to an unsigned prepared transaction"
+    );
+    const { prepareBroadcasterPlan } = await import("./broadcaster-preparation-QVL62KM6.js");
+    const selected = await prepareBroadcasterPlan(
+      this.#saved.plan,
+      this.#runtime.reprepare,
+      client,
+      options
+    );
+    return new _PreparedTransaction(
+      this.#runtime,
+      { plan: selected.plan, broadcasterQuote: selected.quote, generation: 0 },
+      "prepared",
+      { generation: 0, busy: false }
+    );
+  }
   get id() {
     return this.#saved.plan.id;
   }
@@ -79,6 +106,15 @@ var PreparedTransaction = class _PreparedTransaction {
   preview() {
     return operationPreview(this.#saved.plan, this.status);
   }
+  /** Obtain a firm quote before signing. This intent contains no private inputs or witness. */
+  async exportBroadcasterIntent() {
+    this.current();
+    check(
+      ["prepared", "authorized"].includes(this.status),
+      "quote intent requires a prepared transaction"
+    );
+    return exportBroadcasterIntent(this.#saved.plan);
+  }
   current() {
     check(
       !this.#lifecycle.busy && this.#lifecycle.generation === this.#saved.generation,
@@ -178,6 +214,10 @@ var PreparedTransaction = class _PreparedTransaction {
   }
   async prove(backendOrOptions = {}, suppliedOptions = {}) {
     const options = { ..."prove" in backendOrOptions ? suppliedOptions : backendOrOptions };
+    check(
+      !this.#saved.broadcasterQuote || options.execution !== "aggregate",
+      "a broadcaster quote requires direct execution"
+    );
     const plan = this.#saved.plan;
     check(plan.kind !== "shield", "shield requires no proof");
     if (requiresAuthorization(plan)) {
@@ -287,7 +327,7 @@ function explicitPreparation(options, data, tokenAddress) {
     position(input);
     positiveAmount(input.note.amount);
     if (inventory.notes[input.commitment]) throw new Error("duplicate explicit note input");
-    if (input.note.chainId !== context.chainId || input.note.protocolAddress !== BigInt(context.protocolAddress) || input.note.walletIdentity !== options.wallet.walletIdentity)
+    if (input.note.chainId !== context.chainId || input.note.protocolAddress !== BigInt(context.protocolAddress) || input.note.ownerAddress !== options.wallet.ownerAddress)
       throw new Error("explicit note identity or deployment mismatch");
     inventory.notes[input.commitment] = { ...input, spent: "unspent" };
   }
@@ -302,7 +342,7 @@ function explicitPreparation(options, data, tokenAddress) {
   const scope = {
     ...context,
     namespace: "explicit",
-    walletIdentity: options.wallet.walletIdentity
+    ownerAddress: options.wallet.ownerAddress
   };
   const {
     store: _store,
@@ -320,18 +360,30 @@ function explicitPreparation(options, data, tokenAddress) {
     reader: options.chainReader,
     scope
   };
+  const reprepare = (intent) => import("./broadcaster-preparation-QVL62KM6.js").then(
+    ({ prepareIntent }) => prepareIntent(
+      {
+        ...runtime,
+        explicitInputs: true,
+        ...data.changeAddress ? { changeAddress: data.changeAddress } : {},
+        readInventory: async () => structuredClone(inventory),
+        complete: async (plan) => plan
+      },
+      intent
+    )
+  );
   return new TransactionPreparation({
     ...runtime,
     explicitInputs: true,
     ...data.changeAddress ? { changeAddress: data.changeAddress } : {},
     readInventory: async () => structuredClone(inventory),
-    complete: async (plan) => PreparedTransaction.prepare(runtime, plan)
+    complete: async (plan) => PreparedTransaction.prepare({ ...runtime, reprepare }, plan)
   });
 }
 
 // src/Invisi.ts
 import { ProtocolRpcClient } from "@invisi-labs/rpc";
-import { MissingCapabilityError as MissingCapabilityError2, PublicWallet, ReceivingAddress } from "@invisi-labs/core";
+import { MissingCapabilityError as MissingCapabilityError2, PublicWallet } from "@invisi-labs/core";
 
 // src/AddressRegistry.ts
 import { AddressRegistry as Registry } from "@invisi-labs/protocol";
@@ -354,6 +406,10 @@ var AddressRegistry = class extends Registry {
 var Invisi = class {
   #options;
   constructor(options = {}) {
+    if ("addressLookup" in options || "addressResolver" in options)
+      throw new TypeError(
+        "Recipient lookup belongs to each EVM output; caller resolver injection is not supported"
+      );
     if ("ciphertextCodecs" in options || "envelopeVersion" in options) {
       throw new Error(
         "SDK envelope versions are fixed; encode application payload bytes externally"
@@ -391,10 +447,7 @@ var Invisi = class {
     }
     const selected = { ...options };
     const combined = { ...this.#options, ...selected };
-    const { provider, addressLookup = "protocol-rpc", ...runtime } = combined;
-    if (addressLookup !== void 0 && addressLookup !== "chain" && addressLookup !== "protocol-rpc") {
-      throw new Error("Invalid recipient address lookup source");
-    }
+    const { provider, ...runtime } = combined;
     const reader = combined.chainReader ?? (provider ? new EthersChainReader(provider) : void 0);
     if (!reader) throw new MissingCapabilityError2("chain reader");
     if (provider && (await provider.getNetwork()).chainId !== selected.protocol.context.chainId)
@@ -403,41 +456,14 @@ var Invisi = class {
     if (runtime.protocolRpc instanceof ProtocolRpcClient) {
       runtime.protocolRpc = runtime.protocolRpc.withReader(reader);
     }
-    const registry = selected.protocol.deployment.registry;
     const fundingVerifier = combined.fundingVerifier ?? (provider ? new EthersFundingVerifier(provider, selected.protocol.context.chainId) : void 0);
-    let addressResolver = combined.addressResolver;
-    if (!addressResolver && registry) {
-      if (addressLookup === "protocol-rpc") {
-        const rpc = runtime.protocolRpc;
-        addressResolver = async (identity) => {
-          if (!(rpc instanceof ProtocolRpcClient)) {
-            throw new MissingCapabilityError2("Protocol RPC recipient discovery");
-          }
-          const discovered = await rpc.getDeployment(selected.protocol.context.chainId);
-          const expected = selected.protocol.deployment;
-          if (discovered.protocol.address !== expected.protocol.address || discovered.protocol.runtimeCodeHash !== expected.protocol.runtimeCodeHash || discovered.protocol.fromBlock !== expected.protocol.fromBlock || discovered.registry?.address !== registry.address || discovered.registry.runtimeCodeHash !== registry.runtimeCodeHash || discovered.registry.fromBlock !== registry.fromBlock)
-            throw new Error("Recipient registry deployment pins mismatch");
-          const registration = await rpc.getReceivingAddress(identity);
-          return registration ? ReceivingAddress.parse(registration.receivingAddress).getReceivingKeys() : null;
-        };
-      } else if (provider) {
-        addressResolver = new EthersAddressResolver(
-          provider,
-          {
-            chainId: selected.protocol.context.chainId,
-            registryAddress: registry.address
-          },
-          registry.runtimeCodeHash
-        ).lookup;
-      }
-    }
-    return {
+    return configureRecipientInfrastructure({
       ...runtime,
+      ...provider ? { provider } : {},
       chainReader: reader,
       ...fundingVerifier ? { fundingVerifier } : {},
-      ...addressResolver ? { addressResolver } : {},
       protocol: selected.protocol
-    };
+    });
   }
   /** Discover the selected chain's registry and prepare an independent signing request. */
   async prepareRegistration(options) {
@@ -563,8 +589,272 @@ import {
   computeCreditNullifier,
   creditPeriods
 } from "@invisi-labs/core";
-import { Protocol, RegistrationOperation } from "@invisi-labs/protocol";
-import { ProtocolRpcError } from "@invisi-labs/rpc";
+import { RegistrationOperation } from "@invisi-labs/protocol";
+
+// src/Protocol.ts
+import { Protocol as BaseProtocol } from "@invisi-labs/protocol";
+import { getAddress as getAddress3 } from "ethers";
+
+// src/broadcaster/index.ts
+import { AbiCoder, getAddress as getAddress2, Interface, keccak256, verifyTypedData } from "ethers";
+import { invisiProtocolAbi } from "@invisi-labs/protocol/contracts";
+var broadcasterQuoteTypes = {
+  Quote: [
+    { name: "token", type: "address" },
+    { name: "feeRecipient", type: "address" },
+    { name: "feeAmount", type: "uint256" },
+    { name: "deadline", type: "uint256" },
+    { name: "maxGas", type: "uint256" },
+    { name: "requestHash", type: "bytes32" }
+  ]
+};
+function broadcasterQuoteDomain(trust) {
+  return {
+    name: "InvisiBroadcaster",
+    version: "1",
+    chainId: trust.chainId,
+    verifyingContract: getAddress2(trust.protocol)
+  };
+}
+var supportedMethods = ["transact", "shield", "createCredit", "topUpCredit", "cancelCredit"];
+var intentAbi = invisiProtocolAbi.filter(
+  (item) => item.type === "function" && supportedMethods.includes(item.name) && (item.name !== "transact" || item.inputs[1]?.type === "tuple")
+);
+var broadcasterTransactInterface = new Interface(intentAbi);
+function decodeBroadcasterIntent(data) {
+  const parsed = broadcasterTransactInterface.parseTransaction({ data });
+  if (!parsed || !supportedMethods.includes(parsed.name))
+    throw new Error("unsupported broadcaster method");
+  const fragment = parsed.fragment;
+  const decoded = parsed.args;
+  if (broadcasterTransactInterface.encodeFunctionData(fragment, decoded).toLowerCase() !== data.toLowerCase())
+    throw new Error("noncanonical broadcaster calldata");
+  const method = parsed.name;
+  const raw = method === "transact" ? decoded[1] : void 0;
+  const params = raw?.params ?? (method === "shield" ? decoded[0] : method === "topUpCredit" ? decoded[1].creation : decoded[1]);
+  const funding = raw?.funding ?? (method === "shield" ? decoded[3] : ["createCredit", "topUpCredit"].includes(method) ? decoded[3] : void 0);
+  const deliveries = raw?.deliveries ?? (method === "shield" ? decoded[2] : ["createCredit", "topUpCredit"].includes(method) ? decoded[2] : []);
+  return {
+    fragment,
+    method,
+    args: decoded,
+    proof: method === "shield" ? "0x" : decoded[0],
+    request: { params, funding, deliveries }
+  };
+}
+function broadcasterRequestHash(data) {
+  const { fragment, method, args } = decodeBroadcasterIntent(data);
+  const copy = (value) => Array.isArray(value) ? value.map(copy) : value;
+  const canonical = copy(args);
+  if (method !== "shield") canonical[0] = "0x";
+  if (method === "transact") canonical[1][2][4] = "0x";
+  else if (method !== "cancelCredit") canonical[3][4] = "0x";
+  const calldata = broadcasterTransactInterface.encodeFunctionData(fragment, canonical);
+  return keccak256(
+    AbiCoder.defaultAbiCoder().encode(
+      ["string", "string", "bytes"],
+      ["InvisiBroadcasterIntentV1", method, calldata]
+    )
+  );
+}
+function verifyBroadcasterQuote(signed, trust, data, now = BigInt(Math.floor(Date.now() / 1e3))) {
+  const { quote } = signed;
+  const { request } = decodeBroadcasterIntent(data);
+  const p = request.params;
+  if (quote.requestHash !== broadcasterRequestHash(data) || getAddress2(quote.token) !== getAddress2(p.token) || getAddress2(quote.feeRecipient) !== getAddress2(p.feeRecipient) || BigInt(quote.feeAmount) !== p.feeAmount || BigInt(quote.deadline) > p.deadline || BigInt(quote.deadline) < now || BigInt(quote.maxGas) <= 0n || BigInt(quote.feeAmount) <= 0n || BigInt(quote.feeAmount) >= 1n << 128n)
+    throw new Error("quote does not match final intent or bounds");
+  if (getAddress2(
+    verifyTypedData(
+      broadcasterQuoteDomain(trust),
+      broadcasterQuoteTypes,
+      quote,
+      signed.signature
+    )
+  ) !== getAddress2(trust.signer))
+    throw new Error("untrusted quote signature");
+  return quote;
+}
+function checkedStatus(value, id) {
+  const status = value;
+  if (!status || status.id !== id || !["pending", "submitted", "confirmed", "reverted", "uncertain"].includes(status.state) || status.transactionHash !== void 0 && !/^0x[0-9a-fA-F]{64}$/.test(status.transactionHash))
+    throw new Error("invalid broadcaster status");
+  return status;
+}
+var BroadcasterClient = class {
+  configuration;
+  url;
+  transport;
+  requestId = 0;
+  constructor(configuration, transport) {
+    this.configuration = Object.freeze({
+      endpoint: configuration.endpoint,
+      quoteSigner: getAddress2(configuration.quoteSigner),
+      feeRecipient: getAddress2(configuration.feeRecipient)
+    });
+    if (BigInt(this.configuration.quoteSigner) === 0n || BigInt(this.configuration.feeRecipient) === 0n)
+      throw new Error("invalid broadcaster configuration");
+    this.url = configuration.endpoint;
+    const base = new URL(this.url);
+    if (base.protocol !== "https:" || base.username || base.password)
+      throw new Error("broadcaster requires HTTPS");
+    this.transport = transport ?? (async (request) => {
+      const response = await fetch(base, {
+        redirect: "error",
+        method: "POST",
+        body: JSON.stringify(request),
+        headers: { "content-type": "application/json" },
+        signal: AbortSignal.timeout(3e4)
+      });
+      if (!response.ok) throw new Error(`Broadcaster HTTP ${response.status}`);
+      if (!response.body) throw new Error("empty broadcaster response");
+      const reader = response.body.getReader();
+      const chunks = [];
+      let size = 0;
+      try {
+        while (true) {
+          const result = await reader.read();
+          if (result.done) break;
+          size += result.value.length;
+          if (size > 65536) throw new Error("broadcaster response too large");
+          chunks.push(result.value);
+        }
+      } finally {
+        await reader.cancel();
+      }
+      const bytes = new Uint8Array(size);
+      let offset = 0;
+      for (const chunk of chunks) {
+        bytes.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return JSON.parse(new TextDecoder().decode(bytes));
+    });
+  }
+  async call(method, params) {
+    const id = ++this.requestId;
+    const response = await this.transport({
+      jsonrpc: "2.0",
+      id,
+      method,
+      params: [params]
+    });
+    if (!response || response.jsonrpc !== "2.0" || response.id !== id || Object.hasOwn(response, "result") === Object.hasOwn(response, "error"))
+      throw new Error("invalid broadcaster JSON-RPC response");
+    if (response.error) {
+      if (!Number.isInteger(response.error.code) || typeof response.error.message !== "string")
+        throw new Error("invalid broadcaster JSON-RPC error");
+      throw new BroadcasterRpcError(response.error.code, response.error.message);
+    }
+    return response.result;
+  }
+  async fee(token, data) {
+    const fee = await this.call("broadcaster_getFee", {
+      token: getAddress2(token),
+      ...data ? { data } : {}
+    });
+    if (!fee || getAddress2(fee.feeRecipient) !== this.configuration.feeRecipient || !/^\d+$/.test(fee.feeAmount) || BigInt(fee.feeAmount) <= 0n || BigInt(fee.feeAmount) >= 1n << 128n || !/^\d+$/.test(fee.maxGas) || BigInt(fee.maxGas) <= 0n)
+      throw new Error("invalid broadcaster fee");
+    return fee;
+  }
+  async quote(data, context) {
+    const signed = await this.call("broadcaster_getQuote", {
+      data
+    });
+    verifyBroadcasterQuote(
+      signed,
+      { ...context, signer: this.configuration.quoteSigner },
+      data
+    );
+    if (getAddress2(signed.quote.feeRecipient) !== this.configuration.feeRecipient)
+      throw new Error("unregistered fee recipient");
+    return { quote: signed.quote, signature: signed.signature, context: { ...context } };
+  }
+  async submit(data, signed, idempotencyKey) {
+    if (!signed.context) throw new Error("missing verified quote context");
+    verifyBroadcasterQuote(
+      signed,
+      { ...signed.context, signer: this.configuration.quoteSigner },
+      data,
+      0n
+    );
+    if (getAddress2(signed.quote.feeRecipient) !== this.configuration.feeRecipient)
+      throw new Error("unregistered fee recipient");
+    return checkedStatus(
+      await this.call("broadcaster_submitTransaction", {
+        data,
+        quote: signed.quote,
+        signature: signed.signature,
+        idempotencyKey
+      }),
+      idempotencyKey
+    );
+  }
+  async status(id) {
+    return checkedStatus(await this.call("broadcaster_getTransactionStatus", { id }), id);
+  }
+};
+var BroadcasterRpcError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "BroadcasterRpcError";
+  }
+};
+
+// src/Protocol.ts
+var sources = /* @__PURE__ */ new WeakMap();
+var Protocol = class _Protocol extends BaseProtocol {
+  static async fromRpc(rpc, provider, options = {}) {
+    const verified = await BaseProtocol.fromRpc(rpc, provider, options);
+    const protocol = new _Protocol({ deployment: verified.deployment });
+    if (rpc.getBroadcasters)
+      sources.set(protocol, rpc);
+    return protocol;
+  }
+  /** Returns enabled services that answer a token fee probe; final quotes are checked by prepared. */
+  async getBroadcasters(options) {
+    const token = getAddress3(options.tokenAddress);
+    if (!this.deployment.broadcasterRegistry)
+      throw new Error("broadcaster registry is not configured");
+    const rpc = sources.get(this);
+    if (!rpc) throw new Error("broadcaster discovery requires Protocol.fromRpc");
+    const clients = [];
+    let after;
+    let block;
+    const seen = /* @__PURE__ */ new Set();
+    do {
+      const page = await rpc.getBroadcasters({
+        enabled: true,
+        limit: 100,
+        ...after ? { after } : {},
+        ...block ? { block } : {}
+      });
+      block ??= page.block;
+      const compatible = await Promise.all(
+        page.broadcasters.map(async (entry) => {
+          if (!entry.enabled) return void 0;
+          try {
+            const client = new BroadcasterClient(entry);
+            await client.fee(token);
+            return client;
+          } catch {
+            return void 0;
+          }
+        })
+      );
+      clients.push(
+        ...compatible.filter((client) => client !== void 0)
+      );
+      after = page.next;
+      if (after && seen.has(after)) throw new Error("repeated broadcaster pagination cursor");
+      if (after) seen.add(after);
+    } while (after);
+    return clients;
+  }
+};
+
+// src/index.ts
+import { ProtocolRpcError, MAX_UPDATE_BLOCKS } from "@invisi-labs/rpc";
 
 // src/ProtocolRpcClient.ts
 import { ProtocolRpcClient as RpcClient } from "@invisi-labs/rpc";
@@ -574,6 +864,112 @@ var ProtocolRpcClient2 = class extends RpcClient {
   }
 };
 
+// src/BroadcasterRegistry.ts
+import { getAddress as getAddress4, Interface as Interface2, keccak256 as keccak2562 } from "ethers";
+import { broadcasterRegistryAbi } from "@invisi-labs/protocol/contracts";
+var abi = new Interface2(broadcasterRegistryAbi);
+function address(value) {
+  const normalized = getAddress4(value);
+  if (BigInt(normalized) === 0n) throw new Error("zero broadcaster address");
+  return normalized;
+}
+var BroadcasterRegistry = class {
+  address;
+  #options;
+  constructor(options) {
+    this.address = address(options.address);
+    const blockRange = options.blockRange ?? 2e3;
+    if (options.chainId <= 0n || !Number.isSafeInteger(options.fromBlock) || options.fromBlock < 0 || !Number.isSafeInteger(blockRange) || blockRange < 1 || blockRange > 1e5 || !/^0x[0-9a-fA-F]{64}$/.test(options.runtimeCodeHash))
+      throw new Error("invalid broadcaster registry configuration");
+    this.#options = Object.freeze({ ...options, blockRange });
+  }
+  prepareRegistration(registration) {
+    const { endpoint, metadataURI = "" } = registration;
+    if (!endpoint.startsWith("https://") || endpoint.length <= 8 || endpoint.length > 2048 || /[^\x21-\x7e]/.test(endpoint))
+      throw new Error("broadcaster endpoint must be a printable HTTPS URI");
+    const url = new URL(endpoint);
+    if (!url.hostname || url.username || url.password) {
+      throw new Error("broadcaster HTTPS endpoint must not include credentials");
+    }
+    if (metadataURI.length > 2048 || /[^\x21-\x7e]/.test(metadataURI)) {
+      throw new Error("invalid broadcaster metadata URI");
+    }
+    return this.call("setBroadcaster", [
+      endpoint,
+      metadataURI,
+      address(registration.quoteSigner),
+      address(registration.feeRecipient)
+    ]);
+  }
+  prepareAvailability(enabled) {
+    return this.call("setEnabled", [enabled]);
+  }
+  call(name, args) {
+    return { to: this.address, data: abi.encodeFunctionData(name, args), value: 0n };
+  }
+  async validate() {
+    const { provider, chainId, runtimeCodeHash } = this.#options;
+    if ((await provider.getNetwork()).chainId !== chainId) {
+      throw new Error("broadcaster registry chain mismatch");
+    }
+    if (keccak2562(await provider.getCode(this.address)).toLowerCase() !== runtimeCodeHash.toLowerCase()) {
+      throw new Error("broadcaster registry runtime code mismatch");
+    }
+  }
+  async get(operator) {
+    await this.validate();
+    return this.read(address(operator));
+  }
+  async read(operator) {
+    const result = await this.#options.provider.call(this.call("broadcasterOf", [operator]));
+    const [entry] = abi.decodeFunctionResult("broadcasterOf", result);
+    return {
+      operator,
+      endpoint: entry.endpoint,
+      metadataURI: entry.metadataURI,
+      quoteSigner: address(entry.quoteSigner),
+      feeRecipient: address(entry.feeRecipient),
+      enabled: entry.enabled
+    };
+  }
+  /** Discover event operators, then read their latest entry; disabled services remain explicit. */
+  async discover(options = {}) {
+    const { provider, fromBlock, blockRange } = this.#options;
+    options.signal?.throwIfAborted();
+    await this.validate();
+    const toBlock = options.toBlock ?? await provider.getBlockNumber();
+    if (!Number.isSafeInteger(toBlock) || toBlock < fromBlock) {
+      throw new Error("invalid broadcaster discovery block range");
+    }
+    const operators = /* @__PURE__ */ new Set();
+    for (let start = fromBlock; start <= toBlock; ) {
+      options.signal?.throwIfAborted();
+      const end = Math.min(start + blockRange - 1, toBlock);
+      const logs = await provider.getLogs({
+        address: this.address,
+        topics: [abi.getEvent("BroadcasterSet").topicHash],
+        fromBlock: start,
+        toBlock: end
+      });
+      for (const log of logs) {
+        if (getAddress4(log.address) !== this.address)
+          throw new Error("registry event address mismatch");
+        const event = abi.parseLog(log);
+        if (!event || event.name !== "BroadcasterSet")
+          throw new Error("invalid registry event");
+        operators.add(address(event.args.operator));
+      }
+      start = end + 1;
+    }
+    const entries = [];
+    for (const operator of operators) {
+      options.signal?.throwIfAborted();
+      entries.push(await this.read(operator));
+    }
+    return entries;
+  }
+};
+
 // src/integrations/encrypted-codec.ts
 var EncryptedWalletCodec = class _EncryptedWalletCodec {
   #key;
@@ -659,6 +1055,9 @@ var EncryptedWalletCodec = class _EncryptedWalletCodec {
 };
 export {
   AddressRegistry,
+  BroadcasterClient,
+  BroadcasterRegistry,
+  BroadcasterRpcError,
   Detector,
   Disclosure,
   DisclosureVerifier,
@@ -666,7 +1065,9 @@ export {
   Invisi,
   InvisiError,
   MAX_MEMO_BYTES,
+  MAX_UPDATE_BLOCKS,
   MissingCapabilityError3 as MissingCapabilityError,
+  NoteOutput,
   NullifierCapability,
   Operation,
   PreparedTransaction,
@@ -679,9 +1080,14 @@ export {
   Wallet,
   WalletAuthorization,
   WalletSession,
+  broadcasterQuoteDomain,
+  broadcasterQuoteTypes,
+  broadcasterRequestHash,
+  broadcasterTransactInterface,
   computeCreditNullifier,
   creditPeriods,
   creditV1,
+  decodeBroadcasterIntent,
   decodeDeliveryHeader,
   decodeMemoText,
   decryptCandidates,
@@ -689,6 +1095,7 @@ export {
   encodeMemo,
   fundsV1,
   readProtocolLogs,
+  verifyBroadcasterQuote,
   walletBalance
 };
 //# sourceMappingURL=index.js.map