@tokono.ma/firkin 0.2.0 → 0.3.0

package/README.md

@@ -46,7 +46,7 @@ signs directly); delegates mint with [`invocation()`](#delegation--sessions).
 ## API
 
 ```ts
-// blobs — reads are authenticated automatically (for PUBLIC_READS=false)
+// blobs — reads are authenticated automatically (read tokens)
 rb.upload(data, { codec?, hash?: "sha256" | "blake3" }) → { cid, deduplicated }
 rb.get(cid) → Uint8Array
 rb.getRange(cid, { start?, end?, suffix? }) → { data, start, end, total }
@@ -67,6 +67,7 @@ rb.pushFile(chunks)           // ordered chunks → dag-cbor list root
 rb.pullFile(root)             // inverse of pushFile
 rb.dagPush(root, blocks)      // an existing DAG, as-is: [cid, bytes][] | Map
 rb.dagPull(root)              // Map<cid, bytes> — only the root is needed
+rb.ingestCar(carBytes)        // rootless CARv1: verify + claim each block (no DAG)
 
 // account
 rb.revoke({ cids? , all? })   // kill delegations (account key only)

package/dist/client.d.ts

@@ -1,4 +1,7 @@
 import { CID } from "multiformats";
+/** Wire version prefix for every API path (`/health` and `/.well-known/*`
+ * live outside it). */
+export declare const API_PREFIX = "/v1";
 import type { Signer } from "./keys.ts";
 /** Per-call options a TokenSource may honor. */
 export interface TokenOptions {
@@ -14,6 +17,20 @@ export type TokenSource = (command: string, options?: TokenOptions) => Promise<U
 export declare function signerToken(signer: Signer, expireIn?: number): TokenSource;
 /** Fixed-token source: only appropriate for public/read-only usage. */
 export declare function staticToken(token: Uint8Array): TokenSource;
+export interface CarIngestResult {
+    /** Blocks found in the CAR. */
+    blocks: number;
+    /** Blocks written by this call. */
+    stored: number;
+    /** Blocks that were already stored (claim joined). */
+    already: number;
+    /** Total rejected blocks (the `failed` list may be capped). */
+    failed_total: number;
+    failed: {
+        cid: string;
+        error: string;
+    }[];
+}
 export interface UploadResult {
     cid: string;
     /** True when the blob was already stored (dedup; claim joined). */
@@ -60,10 +77,10 @@ export declare class Firkin {
         codec?: number;
         hash?: "sha256" | "blake3";
     }): Promise<UploadResult>;
-    /** Fetch a whole blob. Authenticated reads: the server's reads are public
-     * by default, but a `PUBLIC_READS=false` deployment requires the
-     * `/firkin/blob/read` capability — read tokens are reusable (reads are
-     * not replay-tracked), so sending one is always correct and cheap. */
+    /** Fetch a whole blob. Reads are authenticated: the server requires the
+     * `/firkin/blob/read` capability (an operator can opt into anonymous
+     * reads with `PUBLIC_READS=true`, in which case the header is ignored).
+     * Read tokens are reusable — reads are not replay-tracked. */
     get(cid: string): Promise<Uint8Array>;
     /** Fetch a byte range (206 responses; server-trusted verification).
      * Authenticated like [`get`](#get). */
@@ -113,19 +130,6 @@ export declare class Firkin {
         id: string;
         spki: string;
     }): Promise<void>;
-    /** (Account key) attest a session delegation with the bound passkey. */
-    attest(body: {
-        credential_id: string;
-        auth_data: string;
-        client_data: string;
-        signature: string;
-        delegation_cid: string;
-    }): Promise<void>;
-    /** (Account key) bind a WebAuthn credential to this account. */
-    bindCredential(credential: {
-        id: string;
-        spki: string;
-    }): Promise<void>;
     /** Resolve a passkey assertion to its account DID — the login primitive
      * for passkey-native accounts on a fresh browser. The client performs a
      * discoverable-credentials WebAuthn get (no `allowCredentials`); the
@@ -152,6 +156,14 @@ export declare class Firkin {
     registryDelete(name: string): Promise<void>;
     /** The account's whole registry: name → CID (sorted). */
     registryList(): Promise<Record<string, string>>;
+    /**
+     * Ingest a rootless CARv1 — "upload a `.car` file". Every block is verified
+     * against its own CID, policy-checked and claimed by the account; there is
+     * no DAG traversal and no root requirement (unlike [`dagPush`](#dagpush),
+     * which syncs one DAG over multiple rounds). Partial success is normal:
+     * `failed` lists the rejected blocks (digest mismatch, policy, size).
+     */
+    ingestCar(car: Uint8Array): Promise<CarIngestResult>;
     /**
      * Push a flat file as an ordered list of chunks: each chunk is stored as
      * a raw block, and a dag-cbor list of their CIDs becomes the root — the
@@ -201,7 +213,7 @@ export declare class Firkin {
      */
     pullFile(root: string): Promise<Uint8Array>;
 }
-export declare function carFile(root: CID, entries: [CID, Uint8Array][]): Uint8Array;
+export declare function carFile(root: CID | null, entries: [CID, Uint8Array][]): Uint8Array;
 export declare function multihashSha256(data: Uint8Array): MultihashDigest;
 type MultihashDigest = {
     code: number;

package/dist/client.js

@@ -4,6 +4,9 @@ import { CID } from "multiformats";
 import { sha256 } from "@noble/hashes/sha2";
 import { cidForBytes, CODEC_DAG_CBOR, CODEC_DAG_PB, CODEC_RAW } from "./cid.js";
 import { BloomFilter } from "./bloom.js";
+/** Wire version prefix for every API path (`/health` and `/.well-known/*`
+ * live outside it). */
+export const API_PREFIX = "/v1";
 import { CMD, mintInvocation } from "./ucan.js";
 /** Signer-backed source: mints a fresh direct invocation per request. */
 export function signerToken(signer, expireIn = 600) {
@@ -54,7 +57,7 @@ export class Firkin {
             cid = cidForBytes(data, opts);
             body = new Blob([data]);
         }
-        const res = await this.fetchImpl(`${this.base}/blob/${cid}`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/blob/${cid}`, {
             method: "PUT",
             headers: {
                 Authorization: `Bearer ${toBase64Url(await this.token(CMD.blobUpload))}`,
@@ -67,12 +70,12 @@ export class Firkin {
         const json = (await res.json());
         return { cid, deduplicated: json.status === "already_stored" };
     }
-    /** Fetch a whole blob. Authenticated reads: the server's reads are public
-     * by default, but a `PUBLIC_READS=false` deployment requires the
-     * `/firkin/blob/read` capability — read tokens are reusable (reads are
-     * not replay-tracked), so sending one is always correct and cheap. */
+    /** Fetch a whole blob. Reads are authenticated: the server requires the
+     * `/firkin/blob/read` capability (an operator can opt into anonymous
+     * reads with `PUBLIC_READS=true`, in which case the header is ignored).
+     * Read tokens are reusable — reads are not replay-tracked. */
     async get(cid) {
-        const res = await this.fetchImpl(`${this.base}/blob/${cid}`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/blob/${cid}`, {
             headers: { Authorization: `Bearer ${toBase64Url(await this.token(CMD.blobRead))}` },
         });
         if (!res.ok)
@@ -82,7 +85,7 @@ export class Firkin {
     /** Fetch a byte range (206 responses; server-trusted verification).
      * Authenticated like [`get`](#get). */
     async getRange(cid, range = {}) {
-        const res = await this.fetchImpl(`${this.base}/blob/${cid}`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/blob/${cid}`, {
             headers: {
                 Authorization: `Bearer ${toBase64Url(await this.token(CMD.blobRead))}`,
                 Range: rangeHeader(range),
@@ -109,7 +112,7 @@ export class Firkin {
      * caller's own chain is not stored yet. */
     async publishDelegation(minted, opts = {}) {
         const token = opts.token ?? (await this.token(CMD.blobUpload));
-        const res = await this.fetchImpl(`${this.base}/delegation/${minted.cid}`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/delegation/${minted.cid}`, {
             method: "PUT",
             headers: { Authorization: `Bearer ${toBase64Url(token)}` },
             body: new Blob([minted.proof]),
@@ -129,12 +132,12 @@ export class Firkin {
         const token = await this.token(`${CMD.blobRead}/${cid}`, {
             expireIn: opts.expireIn ?? 60,
         });
-        return `${this.base}/blob/${cid}?token=${toBase64Url(token)}`;
+        return `${this.base}${API_PREFIX}/blob/${cid}?token=${toBase64Url(token)}`;
     }
     /** Attach an already-stored CID to the signer's account. */
     async claim(cid) {
         const token = await this.token(CMD.blobClaim);
-        const res = await this.fetchImpl(`${this.base}/blob/${cid}/claim`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/blob/${cid}/claim`, {
             method: "POST",
             headers: { Authorization: `Bearer ${toBase64Url(token)}` },
         });
@@ -143,7 +146,7 @@ export class Firkin {
     }
     /** Detach the signer's claim; bytes die with the last claimant. */
     async delete(cid) {
-        const res = await this.fetchImpl(`${this.base}/blob/${cid}`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/blob/${cid}`, {
             method: "DELETE",
             headers: { Authorization: `Bearer ${toBase64Url(await this.token(CMD.blobDelete))}` },
         });
@@ -157,7 +160,7 @@ export class Firkin {
      * (passkey-native accounts; the server caps its lifetime at 10 minutes).
      * A plain delegated session cannot revoke. */
     async revoke(opts) {
-        const res = await this.fetchImpl(`${this.base}/account/revoke`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/account/revoke`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${toBase64Url(await this.token(CMD.accountRevoke))}`,
@@ -175,7 +178,7 @@ export class Firkin {
      * other record of the credential↔account link. */
     async register(did, credential) {
         const token = await this.token(CMD.accountRegister);
-        const res = await this.fetchImpl(`${this.base}/accounts`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/accounts`, {
             method: "POST",
             headers: {
                 Authorization: `Bearer ${toBase64Url(token)}`,
@@ -186,32 +189,6 @@ export class Firkin {
         if (!res.ok)
             throw await ApiError.of(res);
     }
-    /** (Account key) attest a session delegation with the bound passkey. */
-    async attest(body) {
-        const res = await this.fetchImpl(`${this.base}/account/attest`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${toBase64Url(await this.token(CMD.accountAttest))}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify(body),
-        });
-        if (!res.ok)
-            throw await ApiError.of(res);
-    }
-    /** (Account key) bind a WebAuthn credential to this account. */
-    async bindCredential(credential) {
-        const res = await this.fetchImpl(`${this.base}/account/bind`, {
-            method: "POST",
-            headers: {
-                Authorization: `Bearer ${toBase64Url(await this.token(CMD.accountBind))}`,
-                "Content-Type": "application/json",
-            },
-            body: JSON.stringify({ credential }),
-        });
-        if (!res.ok)
-            throw await ApiError.of(res);
-    }
     /** Resolve a passkey assertion to its account DID — the login primitive
      * for passkey-native accounts on a fresh browser. The client performs a
      * discoverable-credentials WebAuthn get (no `allowCredentials`); the
@@ -220,7 +197,7 @@ export class Firkin {
      * the endpoint is unauthenticated by design: the verified signature IS
      * the authentication. */
     static async whoami(base, assertion, fetchImpl = globalThis.fetch) {
-        const res = await fetchImpl(`${base}/account/whoami`, {
+        const res = await fetchImpl(`${base}${API_PREFIX}/account/whoami`, {
             method: "POST",
             headers: { "Content-Type": "application/json" },
             body: JSON.stringify({
@@ -237,7 +214,7 @@ export class Firkin {
     }
     /** (Admin) list registered accounts. */
     async listAccounts() {
-        const res = await this.fetchImpl(`${this.base}/accounts`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/accounts`, {
             headers: {
                 Authorization: `Bearer ${toBase64Url(await this.token(CMD.accountList))}`,
             },
@@ -253,7 +230,7 @@ export class Firkin {
     // a resolved CID may be dangling (not yet uploaded or already GC'd).
     /** Set `name` → `cid`. Overwrites silently (last-writer-wins). */
     async registrySet(name, cid) {
-        const res = await this.fetchImpl(`${this.base}/registry/${encodeURIComponent(name)}`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/registry/${encodeURIComponent(name)}`, {
             method: "PUT",
             headers: {
                 Authorization: `Bearer ${toBase64Url(await this.token(CMD.registryWrite))}`,
@@ -266,7 +243,7 @@ export class Firkin {
     }
     /** Resolve `name`; returns null when unset. */
     async registryGet(name) {
-        const res = await this.fetchImpl(`${this.base}/registry/${encodeURIComponent(name)}`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/registry/${encodeURIComponent(name)}`, {
             headers: { Authorization: `Bearer ${toBase64Url(await this.token(CMD.registryRead))}` },
         });
         if (res.status === 404)
@@ -278,7 +255,7 @@ export class Firkin {
     }
     /** Unset `name` (idempotent). */
     async registryDelete(name) {
-        const res = await this.fetchImpl(`${this.base}/registry/${encodeURIComponent(name)}`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/registry/${encodeURIComponent(name)}`, {
             method: "DELETE",
             headers: { Authorization: `Bearer ${toBase64Url(await this.token(CMD.registryWrite))}` },
         });
@@ -287,7 +264,7 @@ export class Firkin {
     }
     /** The account's whole registry: name → CID (sorted). */
     async registryList() {
-        const res = await this.fetchImpl(`${this.base}/registry`, {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/registry`, {
             headers: { Authorization: `Bearer ${toBase64Url(await this.token(CMD.registryRead))}` },
         });
         if (!res.ok)
@@ -296,6 +273,26 @@ export class Firkin {
         return json.names;
     }
     // --- CAR Mirror batch sync ---------------------------------------------------
+    /**
+     * Ingest a rootless CARv1 — "upload a `.car` file". Every block is verified
+     * against its own CID, policy-checked and claimed by the account; there is
+     * no DAG traversal and no root requirement (unlike [`dagPush`](#dagpush),
+     * which syncs one DAG over multiple rounds). Partial success is normal:
+     * `failed` lists the rejected blocks (digest mismatch, policy, size).
+     */
+    async ingestCar(car) {
+        const res = await this.fetchImpl(`${this.base}${API_PREFIX}/car`, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${toBase64Url(await this.token(CMD.blobUpload))}`,
+                "Content-Type": "application/vnd.ipld.car",
+            },
+            body: new Blob([car]),
+        });
+        if (!res.ok)
+            throw await ApiError.of(res);
+        return (await res.json());
+    }
     /**
      * Push a flat file as an ordered list of chunks: each chunk is stored as
      * a raw block, and a dag-cbor list of their CIDs becomes the root — the
@@ -392,7 +389,7 @@ export class Firkin {
                 throw new Error("push round has no blocks");
             const first = send[0];
             const car = carFile(first === rootCid.toString() ? rootCid : CID.parse(first), send.map((c) => [CID.parse(c), all.get(c)]));
-            const res = await this.fetchImpl(`${this.base}/dag/push/${rootCid}`, {
+            const res = await this.fetchImpl(`${this.base}${API_PREFIX}/dag/push/${rootCid}`, {
                 method: "POST",
                 headers: {
                     Authorization: `Bearer ${toBase64Url(await this.token(CMD.blobUpload))}`,
@@ -447,7 +444,7 @@ export class Firkin {
             };
             if (body)
                 headers["Content-Type"] = "application/vnd.ipld.dag-cbor";
-            const res = await this.fetchImpl(`${this.base}/dag/pull/${root}`, {
+            const res = await this.fetchImpl(`${this.base}${API_PREFIX}/dag/pull/${root}`, {
                 method: "POST",
                 headers,
                 ...(body ? { body: new Blob([body]) } : {}),
@@ -522,10 +519,11 @@ function rangeHeader(range) {
 }
 // --- CARv1 framing -----------------------------------------------------------
 export function carFile(root, entries) {
-    // Header roots = the DAG root; entries = exactly the blocks being sent
-    // this round. Never repeat a block the server already has: the receiver
-    // interrupts the round at the first Have block.
-    const header = dagcbor.encode({ roots: [root], version: 1 });
+    // Header roots = the DAG root (`null` for a rootless bag — the DASL CAR
+    // format allows an empty roots array); entries = exactly the blocks being
+    // sent this round. Never repeat a block the server already has: the
+    // receiver interrupts the round at the first Have block.
+    const header = dagcbor.encode({ roots: root ? [root] : [], version: 1 });
     const parts = [uvarintFrame(header.length), header];
     for (const [cid, block] of entries) {
         const entry = new Uint8Array(cid.bytes.length + block.length);

package/dist/index.d.ts

@@ -4,5 +4,6 @@ export * from "./ucan.ts";
 export * from "./client.ts";
 export * from "./bloom.ts";
 export * from "./webauthn.ts";
+export * from "./rasl.ts";
 export * from "./bip39.ts";
 export * from "./bloom.ts";

package/dist/index.js

@@ -4,5 +4,6 @@ export * from "./ucan.js";
 export * from "./client.js";
 export * from "./bloom.js";
 export * from "./webauthn.js";
+export * from "./rasl.js";
 export * from "./bip39.js";
 export * from "./bloom.js";

package/dist/rasl.d.ts

@@ -0,0 +1,30 @@
+export interface RaslUrl {
+    /** The DASL/BDASL CID (the URL's authority). */
+    cid: string;
+    /** Hosts that may serve it (`?hint=` values, invalid ones dropped). */
+    hints: string[];
+}
+/** Build a `rasl://` URL for a CID and optional hint hosts. */
+export declare function raslUrl(cid: string, hints?: string[]): string;
+/** Parse a `rasl://` URL per the spec: the host is the CID, `hint` entries
+ * are the (valid) hint hosts; everything else, including the path, is
+ * ignored. */
+export declare function parseRasl(url: string): RaslUrl;
+/** Check that `bytes` hash to `cid` (SHA-256 and BLAKE3 multihashes).
+ * Compares the digest, so CIDv0/CIDv1 spelling doesn't matter. */
+export declare function verifyCid(cid: string, bytes: Uint8Array): boolean;
+export interface ResolveOptions {
+    fetchImpl?: typeof fetch;
+    /** Cancels the whole resolution (including in-flight hint requests). */
+    signal?: AbortSignal;
+}
+/**
+ * Resolve a `rasl://` URL: request every hint's
+ * `https://<hint>/.well-known/rasl/<cid>` in parallel (statelessly), take the
+ * first response whose bytes hash to the CID. Failing or mismatching hints
+ * are skipped; if none verify, it throws.
+ */
+export declare function resolveRasl(url: string, opts?: ResolveOptions): Promise<{
+    cid: string;
+    bytes: Uint8Array;
+}>;

package/dist/rasl.js

@@ -0,0 +1,107 @@
+// RASL (Retrieval of Arbitrary Structures & Links) — https://dasl.ing/rasl.html
+//
+// A `rasl://<cid>/?hint=<host>&hint=<host>` URL names a CID plus optional
+// places to fetch it. Retrieval is stateless (no cookies, no credentials —
+// the hash is the authority) and self-verifying: whatever comes back must
+// hash to the CID.
+import { sha256 } from "@noble/hashes/sha2";
+import { blake3 } from "@noble/hashes/blake3";
+import { CID } from "multiformats";
+import { HASH_BLAKE3, HASH_SHA256 } from "./cid.js";
+/** A valid `https` host: DNS labels + optional port (IPv6 literals too). */
+const HOST_RE = /^(\[[0-9a-fA-F:]+\]|[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?(\.[a-zA-Z0-9]([a-zA-Z0-9-]*[a-zA-Z0-9])?)*)(:\d{1,5})?$/;
+/** Build a `rasl://` URL for a CID and optional hint hosts. */
+export function raslUrl(cid, hints = []) {
+    const query = hints.map((hint) => `hint=${encodeURIComponent(hint)}`).join("&");
+    return `rasl://${cid}/${query ? `?${query}` : ""}`;
+}
+/** Parse a `rasl://` URL per the spec: the host is the CID, `hint` entries
+ * are the (valid) hint hosts; everything else, including the path, is
+ * ignored. */
+export function parseRasl(url) {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "rasl:") {
+        throw new Error(`not a rasl:// URL: ${url}`);
+    }
+    const cid = parsed.host;
+    if (!cid)
+        throw new Error(`rasl:// URL lacks a CID: ${url}`);
+    CID.parse(cid); // must be a well-formed CID
+    const hints = parsed.searchParams
+        .getAll("hint")
+        .map((hint) => hint.trim())
+        .filter((hint) => HOST_RE.test(hint));
+    return { cid, hints };
+}
+/** Check that `bytes` hash to `cid` (SHA-256 and BLAKE3 multihashes).
+ * Compares the digest, so CIDv0/CIDv1 spelling doesn't matter. */
+export function verifyCid(cid, bytes) {
+    const parsed = CID.parse(cid);
+    const digest = parsed.multihash.code === HASH_SHA256
+        ? sha256(bytes)
+        : parsed.multihash.code === HASH_BLAKE3
+            ? blake3(bytes)
+            : undefined;
+    if (!digest || digest.length !== parsed.multihash.size)
+        return false;
+    return parsed.multihash.digest.every((byte, i) => byte === digest[i]);
+}
+/**
+ * Resolve a `rasl://` URL: request every hint's
+ * `https://<hint>/.well-known/rasl/<cid>` in parallel (statelessly), take the
+ * first response whose bytes hash to the CID. Failing or mismatching hints
+ * are skipped; if none verify, it throws.
+ */
+export async function resolveRasl(url, opts = {}) {
+    const { cid, hints } = parseRasl(url);
+    if (hints.length === 0) {
+        throw new Error("rasl:// URL has no usable hints");
+    }
+    const fetchImpl = opts.fetchImpl ?? globalThis.fetch;
+    const controller = new AbortController();
+    const signals = [controller.signal];
+    if (opts.signal) {
+        if (opts.signal.aborted)
+            throw new Error("rasl resolution aborted");
+        opts.signal.addEventListener("abort", () => controller.abort(), { once: true });
+        signals.push(opts.signal);
+    }
+    const attempts = hints.map(async (hint) => {
+        const res = await fetchImpl(`https://${hint}/.well-known/rasl/${cid}`, {
+            method: "GET",
+            // RASL is stateless: no cookies, no credentials, no content negotiation.
+            credentials: "omit",
+            headers: { Accept: "*/*" },
+            signal: controller.signal,
+        });
+        if (!res.ok)
+            throw new Error(`${hint}: HTTP ${res.status}`);
+        const bytes = new Uint8Array(await res.arrayBuffer());
+        if (!verifyCid(cid, bytes))
+            throw new Error(`${hint}: bytes do not hash to ${cid}`);
+        return { cid, bytes };
+    });
+    try {
+        return await firstSuccess(attempts);
+    }
+    finally {
+        controller.abort(); // stop the losers
+    }
+}
+/** The first fulfilled promise; rejects when all fail. */
+async function firstSuccess(promises) {
+    return new Promise((resolve, reject) => {
+        let pending = promises.length;
+        const errors = [];
+        for (const promise of promises) {
+            promise.then(resolve, (error) => {
+                errors.push(error);
+                if (--pending === 0) {
+                    reject(new Error(`RASL retrieval failed for all hints: ${errors
+                        .map((e) => (e instanceof Error ? e.message : String(e)))
+                        .join("; ")}`));
+                }
+            });
+        }
+    });
+}

package/dist/ucan.d.ts

@@ -21,8 +21,6 @@ export declare const CMD: {
     readonly accountList: "/firkin/account/list";
     readonly accountRevoke: "/firkin/account/revoke";
     readonly accountRecover: "/firkin/account/recover";
-    readonly accountAttest: "/firkin/account/attest";
-    readonly accountBind: "/firkin/account/bind";
     readonly registryRead: "/firkin/registry/read";
     readonly registryWrite: "/firkin/registry/write";
 };

package/dist/ucan.js

@@ -46,8 +46,6 @@ export const CMD = {
     accountList: "/firkin/account/list",
     accountRevoke: "/firkin/account/revoke",
     accountRecover: "/firkin/account/recover",
-    accountAttest: "/firkin/account/attest",
-    accountBind: "/firkin/account/bind",
     registryRead: "/firkin/registry/read",
     registryWrite: "/firkin/registry/write",
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tokono.ma/firkin",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "Browser-first TypeScript client SDK for the Firkin API (UCAN 1.0, DASL CIDs, CAR Mirror sync)",
   "license": "Apache-2.0 OR MIT",
   "repository": {