@finchip.ai/foga 0.0.0-stage → 0.6.0-alpha.4

package/dist/core/pack/cbor.js

@@ -0,0 +1,130 @@
+import { sha256Bytes } from "../canonical.js";
+/**
+ * The deterministic DAG-CBOR encoder of ERC-8338 / ERC-8414 packages, ported from the reference
+ * `tools/skill-pack/som.py` (and the identical `tools/task-pack/tom.py`):
+ *   - definite lengths only, shortest-form integer heads;
+ *   - map keys MUST be strings and are sorted by the bytes of their ENCODED form;
+ *   - links are CBOR tag 42 over a byte string of 0x00 (identity multibase) + the binary CID;
+ *   - CIDs are CIDv1 with sha2-256 multihash: 0x01 <codec varint> 0x12 0x20 <32-byte digest>;
+ *   - no floats, booleans, null or other tags.
+ */
+export const RAW_CODEC = 0x55;
+export const DAG_CBOR_CODEC = 0x71;
+export class Link {
+    cid;
+    constructor(cid) {
+        this.cid = cid;
+        if (cid.length !== 36)
+            throw new Error("Link: binary CID must be 36 bytes");
+    }
+}
+function head(major, arg) {
+    if (arg < 24n)
+        return Uint8Array.of((major << 5) | Number(arg));
+    const sizes = [
+        [24, 1],
+        [25, 2],
+        [26, 4],
+        [27, 8],
+    ];
+    for (const [ai, size] of sizes) {
+        if (arg < 1n << BigInt(8 * size)) {
+            const out = new Uint8Array(1 + size);
+            out[0] = (major << 5) | ai;
+            let v = arg;
+            for (let i = size; i >= 1; i--) {
+                out[i] = Number(v & 0xffn);
+                v >>= 8n;
+            }
+            return out;
+        }
+    }
+    throw new Error("integer too large");
+}
+function concat(parts) {
+    const total = parts.reduce((n, p) => n + p.length, 0);
+    const out = new Uint8Array(total);
+    let o = 0;
+    for (const p of parts) {
+        out.set(p, o);
+        o += p.length;
+    }
+    return out;
+}
+function compareBytes(a, b) {
+    const n = Math.min(a.length, b.length);
+    for (let i = 0; i < n; i++)
+        if (a[i] !== b[i])
+            return a[i] - b[i];
+    return a.length - b.length;
+}
+export function encode(obj) {
+    if (obj instanceof Link) {
+        const body = new Uint8Array(1 + obj.cid.length);
+        body[0] = 0x00;
+        body.set(obj.cid, 1);
+        return concat([head(6, 42n), encode(body)]);
+    }
+    if (obj instanceof Uint8Array)
+        return concat([head(2, BigInt(obj.length)), obj]);
+    if (typeof obj === "string") {
+        const raw = Buffer.from(obj, "utf8");
+        return concat([head(3, BigInt(raw.length)), raw]);
+    }
+    if (typeof obj === "boolean")
+        throw new TypeError("booleans are not supported in SkillRoot");
+    if (typeof obj === "number" || typeof obj === "bigint") {
+        const v = BigInt(obj);
+        if (typeof obj === "number" && !Number.isInteger(obj))
+            throw new TypeError("floats are not supported in SkillRoot");
+        return v >= 0n ? head(0, v) : head(1, -1n - v);
+    }
+    if (Array.isArray(obj))
+        return concat([head(4, BigInt(obj.length)), ...obj.map(encode)]);
+    if (obj && typeof obj === "object") {
+        const items = Object.entries(obj).map(([k, v]) => [encode(k), encode(v)]);
+        items.sort((x, y) => compareBytes(x[0], y[0]));
+        return concat([head(5, BigInt(items.length)), ...items.flatMap(([k, v]) => [k, v])]);
+    }
+    throw new TypeError(`unsupported type in SkillRoot: ${typeof obj}`);
+}
+export function makeCid(digest, codec) {
+    if (digest.length !== 32)
+        throw new Error("makeCid: sha2-256 digest expected");
+    if (codec >= 128)
+        throw new Error("makeCid: codec varint > 1 byte not needed here");
+    const out = new Uint8Array(36);
+    out[0] = 0x01;
+    out[1] = codec;
+    out[2] = 0x12;
+    out[3] = 0x20;
+    out.set(digest, 4);
+    return out;
+}
+export function leafLink(content) {
+    return new Link(makeCid(sha256Bytes(content), RAW_CODEC));
+}
+export function dagLink(digest) {
+    return new Link(makeCid(digest, DAG_CBOR_CODEC));
+}
+/** "b" + lowercase base32 (RFC 4648, no padding) of the binary CID. */
+export function cidString(cid) {
+    const alphabet = "abcdefghijklmnopqrstuvwxyz234567";
+    let bits = 0;
+    let value = 0;
+    let out = "b";
+    for (const byte of cid) {
+        value = (value << 8) | byte;
+        bits += 8;
+        while (bits >= 5) {
+            out += alphabet[(value >>> (bits - 5)) & 31];
+            bits -= 5;
+        }
+    }
+    if (bits > 0)
+        out += alphabet[(value << (5 - bits)) & 31];
+    return out;
+}
+export function cidDigestHex(cid) {
+    return "0x" + Buffer.from(cid.subarray(4)).toString("hex");
+}

package/dist/core/pack/skillpack.js

@@ -0,0 +1,142 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+import { join, posix, relative } from "node:path";
+import { sha256Hex, sha256Bytes } from "../canonical.js";
+import { cidDigestHex, dagLink, encode, leafLink } from "./cbor.js";
+const LICENSE_NAMES = new Set(["license", "LICENSE", "license.json"]);
+function validatePath(p) {
+    if (!p || p.startsWith("/") || p.includes("\\"))
+        throw new Error(`invalid package path: ${p}`);
+    for (const seg of p.split("/"))
+        if (seg === "" || seg === "." || seg === "..")
+            throw new Error(`invalid package path: ${p}`);
+}
+/** Read a directory into a path -> bytes map (POSIX relative paths, sorted). */
+export function readSkillDir(dir) {
+    const files = {};
+    const walk = (d) => {
+        for (const name of readdirSync(d).sort()) {
+            const p = join(d, name);
+            const st = statSync(p);
+            if (st.isDirectory())
+                walk(p);
+            else
+                files[posix.normalize(relative(dir, p).split("\\").join("/"))] = new Uint8Array(readFileSync(p));
+        }
+    };
+    walk(dir);
+    return files;
+}
+export function detectPrimary(files) {
+    if (files["SKILL.md"])
+        return "SKILL.md";
+    if (files["README.md"])
+        return "README.md";
+    const mds = Object.keys(files).filter((p) => !p.includes("/") && /\.(md|markdown)$/i.test(p));
+    if (mds.length === 1)
+        return mds[0];
+    throw new Error("cannot detect the primary document; pass primaryPath");
+}
+export function buildSkillPackage(files, opts = {}) {
+    for (const p of Object.keys(files))
+        validatePath(p);
+    const primaryPath = opts.primaryPath ?? detectPrimary(files);
+    const md = files[primaryPath];
+    if (!md)
+        throw new Error(`primary document ${primaryPath} missing`);
+    Buffer.from(md).toString("utf8"); // must be text
+    let manifestBytes = files["manifest.json"];
+    let manifest;
+    if (manifestBytes) {
+        manifest = JSON.parse(Buffer.from(manifestBytes).toString("utf8"));
+    }
+    else {
+        const firstLine = Buffer.from(md).toString("utf8").split("\n")[0].replace(/^#+\s*/, "").trim();
+        manifest = { schemaVersion: "1.0", name: "skill", skillVersion: "0.0.1", summary: firstLine, entrypoint: primaryPath };
+        manifestBytes = new Uint8Array(Buffer.from(JSON.stringify(manifest, null, 2)));
+    }
+    for (const k of ["schemaVersion", "name", "skillVersion", "summary", "entrypoint"]) {
+        if (!(k in manifest))
+            throw new Error(`manifest.json lacks required field ${k}`);
+    }
+    const entryPath = manifest.entrypoint;
+    validatePath(entryPath);
+    const profile = typeof manifest["x-entry-profile"] === "string" ? manifest["x-entry-profile"] : "llm-markdown-v1";
+    const leaves = {};
+    const objects = {};
+    const leafOf = (path, bytes) => {
+        const hex = sha256Hex(bytes);
+        leaves[path] = hex;
+        objects[hex.slice(2)] = bytes;
+        return leafLink(bytes);
+    };
+    const mdLink = leafOf(primaryPath, md);
+    const manifestLink = leafOf("manifest.json", manifestBytes);
+    let license;
+    const fileLinks = {};
+    for (const [path, bytes] of Object.entries(files)) {
+        if (path === primaryPath || path === "manifest.json")
+            continue;
+        if (!path.includes("/") && LICENSE_NAMES.has(path)) {
+            license = { path, cid: leafOf(path, bytes) };
+            continue;
+        }
+        fileLinks[path] = leafOf(path, bytes);
+    }
+    let entryCid;
+    if (entryPath === primaryPath)
+        entryCid = mdLink;
+    else if (fileLinks[entryPath])
+        entryCid = fileLinks[entryPath];
+    else
+        throw new Error(`entrypoint ${entryPath} is not a file of the package`);
+    const version = opts.version ?? 1;
+    const root = {
+        md: { path: primaryPath, cid: mdLink },
+        manifest: manifestLink,
+        entry: { path: entryPath, cid: entryCid, profile },
+        files: fileLinks,
+    };
+    if (license)
+        root.license = { path: license.path, cid: license.cid };
+    if (version > 1) {
+        if (!opts.previousPackageHash)
+            throw new Error("version > 1 needs previousPackageHash");
+        root.prev = dagLink(Uint8Array.from(Buffer.from(opts.previousPackageHash.replace(/^0x/, ""), "hex")));
+    }
+    else if (opts.previousPackageHash) {
+        throw new Error("version 1 must not carry prev");
+    }
+    const rootBytes = encode(root);
+    const packageHash = sha256Hex(rootBytes);
+    const rootCid = cidDigestHex(dagLink(sha256Bytes(rootBytes)).cid);
+    return { mdHash: sha256Hex(md), packageHash, rootCid, version, primaryPath, manifest, root, rootBytes, leaves, objects };
+}
+/** Verify a set of files against on-chain commitments; returns the problems found (empty = verified). */
+export function verifySkillPackage(files, expected, primaryPath) {
+    const problems = [];
+    let pkg;
+    try {
+        pkg = buildSkillPackage(files, { primaryPath, version: expected.version ?? 1, previousPackageHash: expected.previousPackageHash });
+    }
+    catch (e) {
+        return [`package does not build: ${e.message}`];
+    }
+    if (pkg.mdHash.toLowerCase() !== expected.mdHash.toLowerCase())
+        problems.push(`mdHash ${pkg.mdHash} != ${expected.mdHash}`);
+    if (pkg.packageHash.toLowerCase() !== expected.packageHash.toLowerCase())
+        problems.push(`packageHash ${pkg.packageHash} != ${expected.packageHash}`);
+    return problems;
+}
+/** The vector.json shape the reference tooling writes next to skillroot.cbor. */
+export function vectorOf(pkg) {
+    return {
+        standard: "KERNEL v4.3",
+        mdHash: pkg.mdHash,
+        packageHash: pkg.packageHash,
+        rootCID_digest: pkg.rootCid,
+        version: pkg.version,
+        confidential: false,
+        encryptedPaths: [],
+        leaves: pkg.leaves,
+    };
+}

package/dist/core/skills.js

@@ -0,0 +1,40 @@
+import { eventArgs } from "./world.js";
+import { buildSkillPackage, readSkillDir } from "./pack/skillpack.js";
+/** ERC-8338 Token-Bound Executable Skills: the cell's capabilities as hash-verified packages. */
+export class Skills {
+    world;
+    address;
+    constructor(world) {
+        this.world = world;
+        this.address = world.address("8338/SkillToken");
+    }
+    contract(runner) {
+        return this.world.contract("8338/SkillToken", runner);
+    }
+    /** Build a package from a directory (pack.py semantics). */
+    packageFromDir(dir, opts) {
+        return buildSkillPackage(readSkillDir(dir), opts);
+    }
+    encodeMint(to, updateAuthority, pkg, packageURI) {
+        return this.contract().interface.encodeFunctionData("mintSkill", [to, updateAuthority, pkg.mdHash, pkg.packageHash, packageURI]);
+    }
+    encodeUpdate(tokenId, pkg) {
+        return this.contract().interface.encodeFunctionData("updateSkill", [tokenId, pkg.mdHash, pkg.packageHash]);
+    }
+    encodeSafeTransfer(from, to, tokenId) {
+        return this.contract().interface.encodeFunctionData("safeTransferFrom(address,address,uint256)", [from, to, tokenId]);
+    }
+    tokenIdFromReceipt(receipt) {
+        return BigInt(eventArgs(this.contract().interface, receipt, "SkillUpdated", this.address).tokenId);
+    }
+    async skillOf(tokenId) {
+        const b = await this.contract().skillOf(tokenId);
+        return { mdHash: b.mdHash, packageHash: b.packageHash, version: BigInt(b.version) };
+    }
+    async ownerOf(tokenId) {
+        return this.contract().ownerOf(tokenId);
+    }
+    async skillURI(tokenId) {
+        return this.contract().skillURI(tokenId);
+    }
+}

package/dist/core/swarm.js

@@ -0,0 +1,206 @@
+import { keccak256, toUtf8Bytes } from "ethers";
+import { abi, dataUriJcs, jcs, sha256Hex } from "./canonical.js";
+import { eventArgs } from "./world.js";
+/** ERC-8447 Swarm AI Framework: how cells organize into purpose-bound swarms. */
+export const Boundary = { OPEN: 0, GATED: 1, CLOSED: 2 };
+export const Admission = { RECRUIT: 0, INHERIT: 1, SELECT: 2 };
+export const AuthorityKind = { NONE: 0, ADDRESS: 1, ROLE: 2, ANY_MEMBER: 3, INITIATOR: 4 };
+export const DecisionPoint = { ACTIVATE: 0, ABORT: 1, SUSPEND: 2, RESUME: 3, ADVANCE: 4, CONCLUDE: 5, DISSOLVE: 6, SUCCEED: 7, ADMIT: 8, REMOVE: 9, REINSTATE: 10, AMEND: 11, ATTACH: 12, DETACH: 13, SET_ACCOUNT: 14, REPRESENT: 15 };
+export const DECISION_POINTS = 16;
+export const Activation = { ROSTER_MET: 0, AUTHORITY: 1, BOTH: 2 };
+export const Contributions = { DISABLED: 0, MEMBERS: 1, OPEN: 2 };
+export const ObjectiveKind = { TERMINAL: 0, MILESTONED: 1, EXPLORATORY: 2, STANDING: 3 };
+export const LifecycleStateName = ["NONE", "FORMING", "ACTIVE", "SUSPENDED", "CONCLUDING", "DISSOLVED"];
+export const OutcomeTypeName = ["NONE", "ACHIEVED", "PARTIAL", "FAILED", "ABANDONED", "SUPERSEDED"];
+export const MemberStatusName = ["NONE", "CANDIDATE", "ACTIVE", "SUSPENDED", "EXITED"];
+export const SuspensionCauseName = ["NONE", "AUTHORITY", "INELIGIBLE"];
+export const ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+export const ZERO32 = "0x" + "00".repeat(32);
+export function saiId(name) {
+    return keccak256(toUtf8Bytes(name));
+}
+export const roleId = (name) => saiId(`sai.role.${name}`);
+export const term = { payoff: (n) => saiId(`sai.payoff.${n}`), topology: (n) => saiId(`sai.topology.${n}`), coordination: (n) => saiId(`sai.coordination.${n}`) };
+export const originKind = (name) => saiId(`sai.origin.${name}`);
+export function bytes32Label(label) {
+    const b = toUtf8Bytes(label);
+    if (b.length > 32)
+        throw new Error(`label ${label} exceeds 32 bytes`);
+    return "0x" + Buffer.from(b).toString("hex").padEnd(64, "0");
+}
+export const none = { kind: AuthorityKind.NONE, target: ZERO_ADDRESS, roleId: ZERO32 };
+export const initiator = { kind: AuthorityKind.INITIATOR, target: ZERO_ADDRESS, roleId: ZERO32 };
+export const byAddress = (target) => ({ kind: AuthorityKind.ADDRESS, target, roleId: ZERO32 });
+export const byRole = (role) => ({ kind: AuthorityKind.ROLE, target: ZERO_ADDRESS, roleId: role });
+/** Sixteen authorities indexed by decision point, from a partial map; the rest are NONE. */
+export function authorities(map) {
+    const out = new Array(DECISION_POINTS).fill(none);
+    for (const [name, a] of Object.entries(map))
+        out[DecisionPoint[name]] = a;
+    return out;
+}
+export const SWARM_SPEC_TUPLE = "tuple(tuple(bytes32 roleId,uint32 min,uint32 max,address eligibility,bool selfJoin)[] roles,tuple(bytes32 name,bytes32 payoff,bytes32 topology,bytes32 coordination,uint8 boundary,uint8 admission,uint64 inputWindow,bytes32 descriptorHash)[] phases,tuple(uint8 kind,address target,bytes32 roleId)[] authorities,uint8 activation,uint8 contributions,uint32 minMembers,uint32 maxMembers,uint64 recruitmentWindow,uint64 maxDuration,uint64 inactivityTimeout,uint64 ineligibleGrace,uint64 settlementWindow,uint64 amendmentExitWindow,bytes32 descriptorHash)";
+/** specHash = keccak256(abi.encode(spec)). */
+export function specHashOf(spec) {
+    return keccak256(abi.encode([SWARM_SPEC_TUPLE], [spec]));
+}
+/** Swarm Pack commitments: SHA-256 over the JCS form of the root, the objective and the commitment members. */
+export function packHashes(pack) {
+    return {
+        charterHash: sha256Hex(jcs(pack)),
+        objectiveHash: sha256Hex(jcs(pack.objective)),
+        commitmentHash: pack.commitment ? sha256Hex(jcs(pack.commitment)) : ZERO32,
+        charterURI: dataUriJcs(pack),
+    };
+}
+export function taskOriginRef(chainId, taskToken, tokenId) {
+    return keccak256(abi.encode(["uint256", "address", "uint256"], [chainId, taskToken, tokenId]));
+}
+export class Swarms {
+    world;
+    address;
+    constructor(world) {
+        this.world = world;
+        this.address = world.address("8447/SwarmRegistry");
+    }
+    contract(runner) {
+        return this.world.contract("8447/SwarmRegistry", runner);
+    }
+    // ---- calldata builders
+    encodeForm(spec, charterHash, commitmentHash, charterURI, origin, objective) {
+        return this.contract().interface.encodeFunctionData("form", [spec, charterHash, commitmentHash, charterURI, ZERO32, origin, objective]);
+    }
+    encodeJoin(swarmId, role, charterHash) {
+        return this.contract().interface.encodeFunctionData("join", [swarmId, role, charterHash]);
+    }
+    encodeActivate(swarmId) {
+        return this.contract().interface.encodeFunctionData("activate", [swarmId]);
+    }
+    encodeSetAccount(swarmId, account) {
+        return this.contract().interface.encodeFunctionData("setAccount", [swarmId, account]);
+    }
+    encodeChallenge(swarmId, account) {
+        return this.contract().interface.encodeFunctionData("challenge", [swarmId, account]);
+    }
+    encodeAmend(swarmId, charterHash, charterURI, objectiveHash = ZERO32, commitmentHash = ZERO32, material = false) {
+        return this.contract().interface.encodeFunctionData("amend", [swarmId, charterHash, charterURI, objectiveHash, commitmentHash, material]);
+    }
+    encodeLeave(swarmId) {
+        return this.contract().interface.encodeFunctionData("leave", [swarmId]);
+    }
+    swarmIdFromReceipt(receipt) {
+        return eventArgs(this.contract().interface, receipt, "SwarmFormed", this.address).swarmId;
+    }
+    selector(fn) {
+        return this.contract().interface.getFunction(fn).selector;
+    }
+    // ---- views
+    async getSwarm(swarmId) {
+        const s = await this.contract().getSwarm(swarmId);
+        const state = Number(s.state);
+        const outcome = Number(s.outcome);
+        return {
+            specHash: s.specHash,
+            charterHash: s.charterHash,
+            commitmentHash: s.commitmentHash,
+            charterVersion: Number(s.charterVersion),
+            commitmentVersion: Number(s.commitmentVersion),
+            charterURI: s.charterURI,
+            initiator: s.initiator,
+            account: s.account,
+            state,
+            stateName: LifecycleStateName[state] ?? String(state),
+            outcome,
+            outcomeName: OutcomeTypeName[outcome] ?? String(outcome),
+            phase: Number(s.phase),
+            resultHash: s.resultHash,
+            activatedAt: BigInt(s.activatedAt),
+        };
+    }
+    async memberStatus(swarmId, account) {
+        const r = await this.contract().memberStatus(swarmId, account);
+        const status = Number(r[0]);
+        return { status, statusName: MemberStatusName[status] ?? String(status), exitReason: Number(r[1]) };
+    }
+    async member(swarmId, account) {
+        const m = await this.contract().getMember(swarmId, account);
+        const suspension = Number(m.suspension);
+        return { roleId: m.roleId, status: Number(m.status), suspension, suspensionName: SuspensionCauseName[suspension] ?? String(suspension), acceptedCharter: m.acceptedCharter, acceptedVersion: Number(m.acceptedVersion) };
+    }
+    async rosterMet(swarmId) {
+        return this.contract().rosterMet(swarmId);
+    }
+    async roleCount(swarmId, role) {
+        const r = await this.contract().roleCount(swarmId, role);
+        return { active: Number(r[0]), suspended: Number(r[1]) };
+    }
+    async isAuthorized(swarmId, dp, account) {
+        return this.contract().isAuthorized(swarmId, dp, account);
+    }
+    async seatEpoch(swarmId, account) {
+        return BigInt(await this.contract().seatEpochOf(swarmId, account));
+    }
+    async hardDeadline(swarmId) {
+        return BigInt(await this.contract().hardDeadlineOf(swarmId));
+    }
+}
+/** The swarm account the SwarmRegistry reference ships: `execute` by whoever holds REPRESENT. */
+export class SwarmAccountRef {
+    world;
+    address;
+    iface;
+    constructor(world, address) {
+        this.world = world;
+        this.address = address;
+        this.iface = world.ifaceOf("swarm-ai-framework:SwarmAccount");
+    }
+    contract(runner) {
+        return this.world.at("swarm-ai-framework:SwarmAccount", this.address, runner);
+    }
+    encodeExecute(target, value, data) {
+        return this.iface.encodeFunctionData("execute", [target, value, data]);
+    }
+    get executeSelector() {
+        return this.iface.getFunction("execute").selector;
+    }
+}
+export class SwarmTenderAdapterRef {
+    world;
+    address;
+    constructor(world, address) {
+        this.world = world;
+        this.address = address;
+    }
+    contract(runner) {
+        return this.world.contract("8447/SwarmTenderAdapter", runner);
+    }
+    encodeSettle(swarmId, submissionId) {
+        return this.contract().interface.encodeFunctionData("settle", [swarmId, submissionId]);
+    }
+}
+export class SwarmDecisionAdapterRef {
+    world;
+    address;
+    iface;
+    constructor(world, address) {
+        this.world = world;
+        this.address = address;
+        this.iface = world.ifaceOf("swarm-ai-framework:SwarmDecisionAdapter");
+    }
+    contract(runner) {
+        return this.world.at("swarm-ai-framework:SwarmDecisionAdapter", this.address, runner);
+    }
+    encodeOpen(swarmId, dp, call, roster) {
+        return this.iface.encodeFunctionData("open", [swarmId, dp, call, roster]);
+    }
+    encodeExecute(issueId) {
+        return this.iface.encodeFunctionData("execute", [issueId]);
+    }
+    issueIdFromReceipt(receipt) {
+        return eventArgs(this.iface, receipt, "ProposalOpened", this.address).issueId;
+    }
+    async proposal(issueId) {
+        const p = await this.contract().proposalOf(issueId);
+        return { exists: Boolean(p.exists), enacted: Boolean(p.enacted), swarmId: p.swarmId, charterVersion: Number(p.charterVersion), phase: Number(p.phase) };
+    }
+}

package/dist/core/tenders.js

@@ -0,0 +1,121 @@
+import { concat, getAddress, sha256, toUtf8Bytes } from "ethers";
+import { eventArgs } from "./world.js";
+export const SubmissionStatus = { Pending: 0, Accepted: 1, Rejected: 2 };
+export function nativeTerms(reward, overrides = {}) {
+    return {
+        asset: "0x0000000000000000000000000000000000000000",
+        rewardPerCompletion: reward,
+        maxCompletions: 1n,
+        submitBy: 0n,
+        settleBy: 0n,
+        epochLength: 0n,
+        maxCompletionsPerEpoch: 0n,
+        judgmentWindow: 7n * 86400n,
+        ...overrides,
+    };
+}
+/** HashlockVerifier profile (x-hashlock-v1): the demander commits sha256(answer); the solver submits sha256(answer ‖ fulfiller). */
+export const hashlock = {
+    answerHash(answer) {
+        return sha256(typeof answer === "string" ? toUtf8Bytes(answer) : answer);
+    },
+    resultHash(answer, fulfiller) {
+        const a = typeof answer === "string" ? toUtf8Bytes(answer) : answer;
+        return sha256(concat([a, getAddress(fulfiller)]));
+    },
+};
+export class Tenders {
+    world;
+    address;
+    constructor(world) {
+        this.world = world;
+        this.address = world.address("8414/TaskToken");
+    }
+    contract(runner) {
+        return this.world.contract("8414/TaskToken", runner);
+    }
+    hashlockVerifier(runner) {
+        return this.world.contract("8414/HashlockVerifier", runner);
+    }
+    get hashlockAddress() {
+        return this.world.address("8414/HashlockVerifier");
+    }
+    // ---- calldata builders (for calls routed through a cell account)
+    encodeMint(p) {
+        return this.contract().interface.encodeFunctionData("mintTask", [p.to, p.updateAuthority, p.acceptanceAuthority, p.tdHash, p.taskHash, p.taskURI, p.terms]);
+    }
+    /** fundTask for a native-asset tender: the call must carry `amount` as value. */
+    encodeFund(tokenId, amount) {
+        return this.contract().interface.encodeFunctionData("fundTask", [tokenId, amount]);
+    }
+    encodeCommitAnswer(tokenId, answerHash) {
+        return this.hashlockVerifier().interface.encodeFunctionData("commitAnswer", [this.address, tokenId, answerHash]);
+    }
+    tokenIdFromReceipt(receipt) {
+        return BigInt(eventArgs(this.contract().interface, receipt, "TaskUpdated", this.address).tokenId);
+    }
+    encodeSubmit(tokenId, resultHash, resultURI) {
+        return this.contract().interface.encodeFunctionData("submitFulfillment", [tokenId, resultHash, resultURI]);
+    }
+    encodeSettle(tokenId, submissionId, proof) {
+        return this.contract().interface.encodeFunctionData("settleFulfillment", [tokenId, submissionId, proof]);
+    }
+    encodeWithdrawCredit(tokenId, account) {
+        return this.contract().interface.encodeFunctionData("withdrawCredit", [tokenId, account]);
+    }
+    selectors() {
+        const i = this.contract().interface;
+        return {
+            submitFulfillment: i.getFunction("submitFulfillment").selector,
+            settleFulfillment: i.getFunction("settleFulfillment").selector,
+            withdrawCredit: i.getFunction("withdrawCredit").selector,
+            fundTask: i.getFunction("fundTask").selector,
+        };
+    }
+    // ---- demander side (EOA signer)
+    async mint(signer, p) {
+        const tx = await this.contract(signer).mintTask(p.to, p.updateAuthority, p.acceptanceAuthority, p.tdHash, p.taskHash, p.taskURI, p.terms);
+        const receipt = await tx.wait();
+        const tokenId = BigInt(eventArgs(this.contract().interface, receipt, "TaskUpdated", this.address).tokenId);
+        return { tokenId, receipt };
+    }
+    async fundNative(signer, tokenId, amount) {
+        const tx = await this.contract(signer).fundTask(tokenId, amount, { value: amount });
+        return tx.wait();
+    }
+    async commitAnswer(signer, tokenId, answerHash) {
+        const tx = await this.hashlockVerifier(signer).commitAnswer(this.address, tokenId, answerHash);
+        return tx.wait();
+    }
+    // ---- views
+    async submissionOf(tokenId, submissionId) {
+        const s = await this.contract().submissionOf(tokenId, submissionId);
+        return { fulfiller: s.fulfiller, resultHash: s.resultHash, taskVersion: BigInt(s.taskVersion), submittedAt: BigInt(s.submittedAt), machineSettled: Boolean(s.machineSettled), status: Number(s.status) };
+    }
+    async submissionCount(tokenId) {
+        return BigInt(await this.contract().submissionCountOf(tokenId));
+    }
+    async terms(tokenId) {
+        const t = await this.contract().tenderTermsOf(tokenId);
+        return { asset: t.asset, rewardPerCompletion: BigInt(t.rewardPerCompletion), maxCompletions: BigInt(t.maxCompletions), submitBy: BigInt(t.submitBy), settleBy: BigInt(t.settleBy), epochLength: BigInt(t.epochLength), maxCompletionsPerEpoch: BigInt(t.maxCompletionsPerEpoch), judgmentWindow: BigInt(t.judgmentWindow) };
+    }
+    async acceptanceAuthorityOf(tokenId) {
+        return this.contract().acceptanceAuthorityOf(tokenId);
+    }
+    async escrowBalanceOf(tokenId) {
+        return BigInt(await this.contract().escrowBalanceOf(tokenId));
+    }
+    async creditOf(tokenId, account) {
+        return BigInt(await this.contract().creditOf(tokenId, account));
+    }
+    async isCancelled(tokenId) {
+        return this.contract().isTenderCancelled(tokenId);
+    }
+    async nextId() {
+        return BigInt(await this.contract().nextId());
+    }
+    /** Submission id of a FulfillmentSubmitted event in a receipt (receipts of execute() calls carry the token's logs). */
+    submissionIdFromReceipt(receipt) {
+        return BigInt(eventArgs(this.contract().interface, receipt, "FulfillmentSubmitted", this.address).submissionId);
+    }
+}