@blindmarket/sdk 0.1.4

package/dist/types-BOG5Ub1z.d.ts

@@ -0,0 +1,31 @@
+type Address = `0x${string}`;
+type Hex = `0x${string}`;
+type TaskId = bigint;
+type RootHash = Hex;
+type TokenSymbol = 'USDC' | 'A0GI' | string;
+interface Reward {
+    token: Address | TokenSymbol;
+    amount: bigint;
+}
+type TaskStatus = 'funded' | 'assigned' | 'submitted' | 'verified' | 'completed' | 'cancelled';
+interface TaskKey {
+    /** AES-256 symmetric key (32 bytes) used to encrypt task content. */
+    aesKey: Uint8Array;
+    createdAt: Date;
+}
+interface TaskKeyRef {
+    taskId: TaskId;
+    createdAt: Date;
+}
+interface UploadResult {
+    rootHash: RootHash;
+    txHash?: Hex;
+    size: number;
+}
+interface TxReceiptLike {
+    hash: Hex;
+    blockNumber: number;
+    gasUsed: bigint;
+}
+
+export type { Address as A, Hex as H, Reward as R, TaskId as T, UploadResult as U, TaskKey as a, TxReceiptLike as b, TaskKeyRef as c, RootHash as d, TaskStatus as e };

package/dist/types-V7_ZmUb-.d.cts

@@ -0,0 +1,19 @@
+import { A as Address } from './types-BOG5Ub1z.cjs';
+
+interface NetworkContracts {
+    escrow: Address;
+    registry: Address;
+    reputation: Address;
+    usdc: Address;
+}
+interface Network {
+    name: string;
+    chainId: bigint;
+    rpc: string[];
+    contracts: NetworkContracts;
+    indexer: string;
+    broker: string;
+    explorer?: string;
+}
+
+export type { Network as N, NetworkContracts as a };

package/dist/types-hAsITUQ7.d.ts

@@ -0,0 +1,19 @@
+import { A as Address } from './types-BOG5Ub1z.js';
+
+interface NetworkContracts {
+    escrow: Address;
+    registry: Address;
+    reputation: Address;
+    usdc: Address;
+}
+interface Network {
+    name: string;
+    chainId: bigint;
+    rpc: string[];
+    contracts: NetworkContracts;
+    indexer: string;
+    broker: string;
+    explorer?: string;
+}
+
+export type { Network as N, NetworkContracts as a };

package/dist/types.d.ts

@@ -0,0 +1,58 @@
+export type Address = `0x${string}`;
+export type Hex = `0x${string}`;
+export type TaskId = bigint;
+export type RootHash = Hex;
+export type TokenSymbol = 'USDC' | 'A0GI' | string;
+export interface TokenRef {
+    address: Address;
+    symbol?: TokenSymbol;
+    decimals?: number;
+}
+export interface Reward {
+    token: Address | TokenSymbol;
+    amount: bigint;
+}
+export type TaskStatus = 'funded' | 'assigned' | 'submitted' | 'verified' | 'completed' | 'cancelled';
+export interface TaskMetadata {
+    category: string;
+    locationZone: string;
+    reward: Reward;
+    deadline?: Date;
+    extra?: Record<string, string>;
+}
+export interface TaskRecord extends TaskMetadata {
+    taskId: TaskId;
+    agent: Address;
+    worker?: Address;
+    taskHash: RootHash;
+    evidenceHash?: RootHash;
+    status: TaskStatus;
+    createdAt: Date;
+}
+export interface TaskKey {
+    /** AES-256 symmetric key (32 bytes) used to encrypt task content. */
+    aesKey: Uint8Array;
+    createdAt: Date;
+}
+export interface TaskKeyRef {
+    taskId: TaskId;
+    createdAt: Date;
+}
+export interface UploadResult {
+    rootHash: RootHash;
+    txHash?: Hex;
+    size: number;
+}
+export interface VerificationResult {
+    passed: boolean;
+    confidence: number;
+    model: string;
+    attestation?: Hex;
+    completedAt: Date;
+}
+export interface TxReceiptLike {
+    hash: Hex;
+    blockNumber: number;
+    gasUsed: bigint;
+}
+export type Awaitable<T> = T | Promise<T>;

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/verifier/index.cjs

@@ -0,0 +1,4 @@
+'use strict';
+
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map

package/dist/verifier/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.cjs"}

package/dist/verifier/index.d.cts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/verifier/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/verifier/index.js

@@ -0,0 +1 @@
+export {};

package/dist/verifier/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","file":"index.js"}

package/dist/worker/Worker.d.ts

@@ -0,0 +1,53 @@
+import type { BlindEscrowClient, OnChainTask, TaskRegistryClient } from '../chain/index.js';
+import type { EventBus, SdkEvents } from '../events/index.js';
+import type { Signer } from '../signer/index.js';
+import type { Storage } from '../storage/index.js';
+import type { Hex, RootHash, TaskId, TxReceiptLike } from '../types.js';
+export interface WorkerDeps {
+    escrow: BlindEscrowClient;
+    registry: TaskRegistryClient;
+    storage: Storage;
+    signer: Signer;
+    events?: EventBus<SdkEvents>;
+}
+export interface DecryptInstructionsInput {
+    /** ECIES-wrapped AES key delivered out-of-band by the agent (e.g. via the backend API). */
+    wrappedKey: Uint8Array;
+    /** Worker's private key, hex with or without 0x prefix. */
+    workerPrivKey: string;
+    /** Storage root hash from the on-chain task metadata. */
+    taskHash: RootHash;
+}
+export interface SubmitEvidenceInput {
+    taskId: TaskId;
+    evidence: string | Uint8Array;
+    /** Agent's uncompressed secp256k1 pubkey (retrieved via the backend or chain). */
+    agentPubKey: string;
+    /** TEE enclave pubkey for Sealed Inference (from 0G Compute broker). */
+    enclavePubKey: string;
+}
+export interface SubmitEvidenceResult {
+    rootHash: RootHash;
+    txHash: Hex;
+    receipt: TxReceiptLike;
+}
+/**
+ * Worker-side flows: browse open tasks, decrypt assigned instructions, seal
+ * evidence for agent + TEE, and claim payment after the deadline if
+ * verification stalls. Peer pubkeys and wrapped keys are passed explicitly;
+ * the SDK does not assume a specific message-passing substrate.
+ */
+export declare class Worker {
+    private readonly deps;
+    constructor(deps: WorkerDeps);
+    browse(offset: bigint, limit: bigint): Promise<TaskId[]>;
+    getTaskDetail(taskId: TaskId): Promise<OnChainTask>;
+    decryptInstructions(input: DecryptInstructionsInput): Promise<Uint8Array>;
+    submitEvidence(input: SubmitEvidenceInput): Promise<SubmitEvidenceResult>;
+    /**
+     * Worker escape hatch: reclaim escrow after the deadline if completeVerification
+     * was never called. Payment released per contract logic (85% worker, 15% treasury
+     * or full refund depending on submission state — see BlindEscrow.claimTimeout).
+     */
+    claimTimeout(taskId: TaskId): Promise<TxReceiptLike>;
+}

package/dist/worker/Worker.js

@@ -0,0 +1,53 @@
+import { aesDecrypt, eciesDecrypt, sealEvidence } from '../crypto/index.js';
+/**
+ * Worker-side flows: browse open tasks, decrypt assigned instructions, seal
+ * evidence for agent + TEE, and claim payment after the deadline if
+ * verification stalls. Peer pubkeys and wrapped keys are passed explicitly;
+ * the SDK does not assume a specific message-passing substrate.
+ */
+export class Worker {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    async browse(offset, limit) {
+        return this.deps.registry.getOpenTasks(offset, limit);
+    }
+    async getTaskDetail(taskId) {
+        return this.deps.escrow.getTask(taskId);
+    }
+    async decryptInstructions(input) {
+        const aesKey = await eciesDecrypt(input.wrappedKey, input.workerPrivKey);
+        const ciphertext = await this.deps.storage.download(input.taskHash);
+        return aesDecrypt(ciphertext, aesKey);
+    }
+    async submitEvidence(input) {
+        const evidenceBytes = typeof input.evidence === 'string'
+            ? new TextEncoder().encode(input.evidence)
+            : input.evidence;
+        const { envelope } = await sealEvidence({
+            evidence: evidenceBytes,
+            agentPubKey: input.agentPubKey,
+            enclavePubKey: input.enclavePubKey,
+        });
+        const uploaded = await this.deps.storage.upload(envelope);
+        const rootHash = uploaded.rootHash;
+        const receipt = await this.deps.escrow.submitEvidence(input.taskId, rootHash);
+        this.deps.events?.emit('evidence.submitted', {
+            taskId: input.taskId,
+            rootHash,
+            txHash: receipt.hash,
+        });
+        return { rootHash, txHash: receipt.hash, receipt };
+    }
+    /**
+     * Worker escape hatch: reclaim escrow after the deadline if completeVerification
+     * was never called. Payment released per contract logic (85% worker, 15% treasury
+     * or full refund depending on submission state — see BlindEscrow.claimTimeout).
+     */
+    async claimTimeout(taskId) {
+        const receipt = await this.deps.escrow.claimTimeout(taskId);
+        this.deps.events?.emit('payment.claimed', { taskId, txHash: receipt.hash, amount: 0n });
+        return receipt;
+    }
+}

package/dist/worker/index.cjs

@@ -0,0 +1,382 @@
+'use strict';
+
+var ethers = require('ethers');
+
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/crypto/constants.ts
+var IV_LENGTH, TAG_LENGTH, KEY_LENGTH, ECIES_PUBKEY_LENGTH, ECIES_HKDF_INFO, AES_MIN_BLOB, ECIES_MIN_BLOB;
+var init_constants = __esm({
+  "src/crypto/constants.ts"() {
+    IV_LENGTH = 12;
+    TAG_LENGTH = 16;
+    KEY_LENGTH = 32;
+    ECIES_PUBKEY_LENGTH = 65;
+    ECIES_HKDF_INFO = new TextEncoder().encode("BlindBounty-ECIES-v1");
+    AES_MIN_BLOB = IV_LENGTH + TAG_LENGTH;
+    ECIES_MIN_BLOB = ECIES_PUBKEY_LENGTH + AES_MIN_BLOB;
+  }
+});
+
+// src/errors/codes.ts
+var init_codes = __esm({
+  "src/errors/codes.ts"() {
+  }
+});
+
+// src/errors/BlindBountyError.ts
+var BlindBountyError;
+var init_BlindBountyError = __esm({
+  "src/errors/BlindBountyError.ts"() {
+    BlindBountyError = class extends Error {
+      code;
+      retriable;
+      context;
+      cause;
+      constructor(code, message, opts = {}) {
+        super(message);
+        this.code = code;
+        this.retriable = opts.retriable ?? false;
+        if (opts.context !== void 0) this.context = opts.context;
+        if (opts.cause !== void 0) this.cause = opts.cause;
+        Object.defineProperty(this, "name", {
+          value: this.constructor.name,
+          enumerable: false,
+          configurable: true,
+          writable: true
+        });
+      }
+      toJSON() {
+        return {
+          name: this.name,
+          code: this.code,
+          message: this.message,
+          retriable: this.retriable,
+          ...this.context ? { context: this.context } : {}
+        };
+      }
+    };
+  }
+});
+
+// src/errors/subclasses.ts
+var CryptoError;
+var init_subclasses = __esm({
+  "src/errors/subclasses.ts"() {
+    init_BlindBountyError();
+    CryptoError = class extends BlindBountyError {
+      constructor(code, msg, opts) {
+        super(code, msg, opts);
+      }
+    };
+  }
+});
+
+// src/errors/index.ts
+var init_errors = __esm({
+  "src/errors/index.ts"() {
+    init_codes();
+    init_BlindBountyError();
+    init_subclasses();
+  }
+});
+
+// src/crypto/aes.ts
+function getCrypto() {
+  const c = globalThis.crypto;
+  if (!c?.subtle) {
+    throw new CryptoError("CRYPTO/UNSUPPORTED_CIPHER", "Web Crypto (crypto.subtle) is not available");
+  }
+  return c;
+}
+function toArrayBuffer(u) {
+  const ab = new ArrayBuffer(u.byteLength);
+  new Uint8Array(ab).set(u);
+  return ab;
+}
+async function generateAesKey() {
+  const key = new Uint8Array(KEY_LENGTH);
+  getCrypto().getRandomValues(key);
+  return key;
+}
+async function aesEncrypt(plaintext, key) {
+  if (key.byteLength !== KEY_LENGTH) {
+    throw new CryptoError(
+      "CRYPTO/INVALID_KEY",
+      `AES key must be ${KEY_LENGTH} bytes, got ${key.byteLength}`
+    );
+  }
+  const c = getCrypto();
+  const iv = new Uint8Array(IV_LENGTH);
+  c.getRandomValues(iv);
+  try {
+    const ck = await c.subtle.importKey("raw", toArrayBuffer(key), "AES-GCM", false, ["encrypt"]);
+    const wcOut = new Uint8Array(
+      await c.subtle.encrypt(
+        { name: "AES-GCM", iv: toArrayBuffer(iv), tagLength: TAG_LENGTH * 8 },
+        ck,
+        toArrayBuffer(plaintext)
+      )
+    );
+    const ctLen = wcOut.length - TAG_LENGTH;
+    const ct = wcOut.subarray(0, ctLen);
+    const tag = wcOut.subarray(ctLen);
+    const blob = new Uint8Array(IV_LENGTH + TAG_LENGTH + ctLen);
+    blob.set(iv, 0);
+    blob.set(tag, IV_LENGTH);
+    blob.set(ct, IV_LENGTH + TAG_LENGTH);
+    return blob;
+  } catch (cause) {
+    throw new CryptoError("CRYPTO/DECRYPT_FAILED", "AES-GCM encryption failed", { cause });
+  }
+}
+async function aesDecrypt(blob, key) {
+  if (key.byteLength !== KEY_LENGTH) {
+    throw new CryptoError(
+      "CRYPTO/INVALID_KEY",
+      `AES key must be ${KEY_LENGTH} bytes, got ${key.byteLength}`
+    );
+  }
+  if (blob.byteLength < AES_MIN_BLOB) {
+    throw new CryptoError(
+      "CRYPTO/INTEGRITY_CHECK",
+      `AES blob too short: need \u2265${AES_MIN_BLOB} bytes, got ${blob.byteLength}`
+    );
+  }
+  const iv = blob.subarray(0, IV_LENGTH);
+  const tag = blob.subarray(IV_LENGTH, IV_LENGTH + TAG_LENGTH);
+  const ct = blob.subarray(IV_LENGTH + TAG_LENGTH);
+  const combined = new Uint8Array(ct.length + TAG_LENGTH);
+  combined.set(ct, 0);
+  combined.set(tag, ct.length);
+  try {
+    const c = getCrypto();
+    const ck = await c.subtle.importKey("raw", toArrayBuffer(key), "AES-GCM", false, ["decrypt"]);
+    const pt = await c.subtle.decrypt(
+      { name: "AES-GCM", iv: toArrayBuffer(iv), tagLength: TAG_LENGTH * 8 },
+      ck,
+      toArrayBuffer(combined)
+    );
+    return new Uint8Array(pt);
+  } catch (cause) {
+    throw new CryptoError("CRYPTO/DECRYPT_FAILED", "AES-GCM decryption failed (wrong key or tampered data)", { cause });
+  }
+}
+var init_aes = __esm({
+  "src/crypto/aes.ts"() {
+    init_errors();
+    init_constants();
+  }
+});
+
+// src/crypto/hkdf.ts
+function getSubtle() {
+  const c = globalThis.crypto;
+  if (!c?.subtle) {
+    throw new CryptoError("CRYPTO/UNSUPPORTED_CIPHER", "Web Crypto (crypto.subtle) is not available");
+  }
+  return c.subtle;
+}
+function toArrayBuffer2(u) {
+  const ab = new ArrayBuffer(u.byteLength);
+  new Uint8Array(ab).set(u);
+  return ab;
+}
+async function hkdfSha256(ikm, length = 32, info = ECIES_HKDF_INFO, salt = new Uint8Array(0)) {
+  try {
+    const subtle = getSubtle();
+    const baseKey = await subtle.importKey("raw", toArrayBuffer2(ikm), "HKDF", false, ["deriveBits"]);
+    const derived = await subtle.deriveBits(
+      {
+        name: "HKDF",
+        hash: "SHA-256",
+        info: toArrayBuffer2(info),
+        salt: toArrayBuffer2(salt)
+      },
+      baseKey,
+      length * 8
+    );
+    return new Uint8Array(derived);
+  } catch (cause) {
+    throw new CryptoError("CRYPTO/INVALID_KEY", "HKDF derivation failed", { cause });
+  }
+}
+var init_hkdf = __esm({
+  "src/crypto/hkdf.ts"() {
+    init_errors();
+    init_constants();
+  }
+});
+function strip(hex) {
+  return hex.startsWith("0x") || hex.startsWith("0X") ? hex.slice(2) : hex;
+}
+function assertUncompressedPubKey(pub) {
+  const s = strip(pub);
+  if (s.length !== 130 || !/^04/i.test(s)) {
+    throw new CryptoError(
+      "CRYPTO/INVALID_KEY",
+      "expected uncompressed secp256k1 pubkey (65 bytes hex, starts with 04)"
+    );
+  }
+}
+function hexToBytes(hex) {
+  const s = strip(hex);
+  if (s.length % 2 !== 0) {
+    throw new CryptoError("CRYPTO/INVALID_KEY", "hex string has odd length");
+  }
+  const out = new Uint8Array(s.length / 2);
+  for (let i = 0; i < out.length; i++) {
+    const byte = Number.parseInt(s.substring(i * 2, i * 2 + 2), 16);
+    if (Number.isNaN(byte)) {
+      throw new CryptoError("CRYPTO/INVALID_KEY", `invalid hex byte at position ${i * 2}`);
+    }
+    out[i] = byte;
+  }
+  return out;
+}
+function bytesToHex(u) {
+  return Array.from(u, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+var init_keys = __esm({
+  "src/crypto/keys.ts"() {
+    init_errors();
+  }
+});
+async function eciesEncrypt(plaintext, recipientPubKey) {
+  assertUncompressedPubKey(recipientPubKey);
+  const ephemeral = ethers.ethers.Wallet.createRandom();
+  const shared = deriveSharedSecretX(ephemeral.privateKey, `0x${strip(recipientPubKey)}`);
+  const aesKey = await hkdfSha256(shared, KEY_LENGTH);
+  const aesBlob = await aesEncrypt(plaintext, aesKey);
+  const ephPub = hexToBytes(strip(ephemeral.signingKey.publicKey));
+  if (ephPub.byteLength !== ECIES_PUBKEY_LENGTH) {
+    throw new CryptoError("CRYPTO/INVALID_KEY", `ephemeral pubkey length ${ephPub.byteLength}`);
+  }
+  const blob = new Uint8Array(ECIES_PUBKEY_LENGTH + aesBlob.byteLength);
+  blob.set(ephPub, 0);
+  blob.set(aesBlob, ECIES_PUBKEY_LENGTH);
+  return blob;
+}
+async function eciesDecrypt(blob, recipientPrivKey) {
+  if (blob.byteLength < ECIES_MIN_BLOB) {
+    throw new CryptoError(
+      "CRYPTO/INTEGRITY_CHECK",
+      `ECIES blob too short: need \u2265${ECIES_MIN_BLOB} bytes, got ${blob.byteLength}`
+    );
+  }
+  const ephPub = blob.subarray(0, ECIES_PUBKEY_LENGTH);
+  const aesBlob = blob.subarray(ECIES_PUBKEY_LENGTH);
+  const shared = deriveSharedSecretX(`0x${strip(recipientPrivKey)}`, `0x${bytesToHex(ephPub)}`);
+  const aesKey = await hkdfSha256(shared, KEY_LENGTH);
+  return aesDecrypt(aesBlob, aesKey);
+}
+function deriveSharedSecretX(privHex, pubHex) {
+  const sk = new ethers.ethers.SigningKey(privHex);
+  const shared = sk.computeSharedSecret(pubHex);
+  const bytes = hexToBytes(strip(shared));
+  if (bytes.byteLength !== 65 || bytes[0] !== 4) {
+    throw new CryptoError(
+      "CRYPTO/INVALID_KEY",
+      `unexpected shared secret shape (len=${bytes.byteLength}, prefix=${bytes[0]?.toString(16) ?? "none"})`
+    );
+  }
+  return bytes.subarray(1, 33);
+}
+var init_ecies = __esm({
+  "src/crypto/ecies.ts"() {
+    init_errors();
+    init_aes();
+    init_constants();
+    init_hkdf();
+    init_keys();
+  }
+});
+
+// src/crypto/envelope.ts
+init_aes();
+init_ecies();
+var MAGIC_0 = 66;
+var MAGIC_1 = 66;
+var VERSION = 1;
+var HEADER_LEN = 3;
+async function sealEvidence(input) {
+  const aesKey = await generateAesKey();
+  const aesCiphertext = await aesEncrypt(input.evidence, aesKey);
+  const wrappedForAgent = await eciesEncrypt(aesKey, input.agentPubKey);
+  const wrappedForEnclave = await eciesEncrypt(aesKey, input.enclavePubKey);
+  const envelope = pack({ wrappedForAgent, wrappedForEnclave, aesCiphertext });
+  return { envelope, aesKey };
+}
+function pack(parts) {
+  const { wrappedForAgent, wrappedForEnclave, aesCiphertext } = parts;
+  const total = HEADER_LEN + 4 + wrappedForAgent.byteLength + 4 + wrappedForEnclave.byteLength + aesCiphertext.byteLength;
+  const out = new Uint8Array(total);
+  const view = new DataView(out.buffer);
+  let off = 0;
+  out[off++] = MAGIC_0;
+  out[off++] = MAGIC_1;
+  out[off++] = VERSION;
+  view.setUint32(off, wrappedForAgent.byteLength, false);
+  off += 4;
+  out.set(wrappedForAgent, off);
+  off += wrappedForAgent.byteLength;
+  view.setUint32(off, wrappedForEnclave.byteLength, false);
+  off += 4;
+  out.set(wrappedForEnclave, off);
+  off += wrappedForEnclave.byteLength;
+  out.set(aesCiphertext, off);
+  return out;
+}
+
+// src/worker/Worker.ts
+var Worker = class {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  async browse(offset, limit) {
+    return this.deps.registry.getOpenTasks(offset, limit);
+  }
+  async getTaskDetail(taskId) {
+    return this.deps.escrow.getTask(taskId);
+  }
+  async decryptInstructions(input) {
+    const aesKey = await eciesDecrypt(input.wrappedKey, input.workerPrivKey);
+    const ciphertext = await this.deps.storage.download(input.taskHash);
+    return aesDecrypt(ciphertext, aesKey);
+  }
+  async submitEvidence(input) {
+    const evidenceBytes = typeof input.evidence === "string" ? new TextEncoder().encode(input.evidence) : input.evidence;
+    const { envelope } = await sealEvidence({
+      evidence: evidenceBytes,
+      agentPubKey: input.agentPubKey,
+      enclavePubKey: input.enclavePubKey
+    });
+    const uploaded = await this.deps.storage.upload(envelope);
+    const rootHash = uploaded.rootHash;
+    const receipt = await this.deps.escrow.submitEvidence(input.taskId, rootHash);
+    this.deps.events?.emit("evidence.submitted", {
+      taskId: input.taskId,
+      rootHash,
+      txHash: receipt.hash
+    });
+    return { rootHash, txHash: receipt.hash, receipt };
+  }
+  /**
+   * Worker escape hatch: reclaim escrow after the deadline if completeVerification
+   * was never called. Payment released per contract logic (85% worker, 15% treasury
+   * or full refund depending on submission state — see BlindEscrow.claimTimeout).
+   */
+  async claimTimeout(taskId) {
+    const receipt = await this.deps.escrow.claimTimeout(taskId);
+    this.deps.events?.emit("payment.claimed", { taskId, txHash: receipt.hash, amount: 0n });
+    return receipt;
+  }
+};
+
+exports.Worker = Worker;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map