@dopamint-fun/open-sdk 0.2.0-dev.2 → 0.2.0-dev.4

package/dist/agentHttp.js

@@ -13,7 +13,7 @@
  * server reconstructs them from the request it actually received, so there is
  * no restated copy to compare and therefore no comparison to forget.
  */
-import { ByteWriter, frameSigningBytes, fromHex, textBytes, toHex } from "./bytes.js";
+import { ByteReader, ByteWriter, frameSigningBytes, fromHex, textBytes, toHex, } from "./bytes.js";
 import { blake2b256 } from "./crypto.js";
 import { signRaw } from "./keypair.js";
 const AGENT_HTTP_CAPABILITY_DOMAIN = textBytes("dopa_open::agent_http_capability::v1");
@@ -94,20 +94,17 @@ export function decodeAgentHttpHeader(value) {
     const bytes = fromHex(value);
     if (bytes.length !== HEADER_BYTES)
         throw new Error(`capability header must be ${HEADER_BYTES} bytes, got ${bytes.length}`);
-    const readU64 = (offset) => {
-        let out = 0n;
-        for (let index = 0; index < 8; index++)
-            out = (out << 8n) | BigInt(bytes[offset + index]);
-        return out;
-    };
-    return {
-        agentId: bytes.slice(0, 32),
-        agentPublicKey: bytes.slice(32, 64),
-        issuedAtMs: readU64(64),
-        expiresAtMs: readU64(72),
-        nonce: bytes.slice(80, 80 + AGENT_HTTP_CAPABILITY_NONCE_BYTES),
-        signature: bytes.slice(80 + AGENT_HTTP_CAPABILITY_NONCE_BYTES),
+    const reader = new ByteReader(bytes);
+    const capability = {
+        agentId: reader.readFixed(32, "agent id"),
+        agentPublicKey: reader.readFixed(32, "agent public key"),
+        issuedAtMs: reader.readU64("issued_at_ms"),
+        expiresAtMs: reader.readU64("expires_at_ms"),
+        nonce: reader.readFixed(AGENT_HTTP_CAPABILITY_NONCE_BYTES, "nonce"),
+        signature: reader.readFixed(SIGNATURE_BYTES, "signature"),
     };
+    reader.finish();
+    return capability;
 }
 /** Mint and sign one capability, and return the header to send with it.
  *

package/dist/claim.js

@@ -1,6 +1,6 @@
 import { randomBytes } from "node:crypto";
 import { signRaw } from "./keypair.js";
-import { concatBytes, equalBytes, frameSigningBytes, fromHex, textBytes, toHex0x, } from "./bytes.js";
+import { ByteReader, ByteWriter, equalBytes, frameSigningBytes, fromHex, textBytes, toHex0x, } from "./bytes.js";
 /* The agent's half of a claim: an invitation its own key signs.
  *
  * A wallet claims an agent by signing for it in the arena's UI. That proves
@@ -22,16 +22,6 @@ export const AGENT_CLAIM_INVITE_MAX_WINDOW_MS = 7 * 24 * 60 * 60 * 1000;
  *  nonce || signature`, every field fixed-width. */
 export const AGENT_CLAIM_INVITE_TOKEN_BYTES = 32 + 32 + 32 + 8 + 8 + 16 + 64;
 const ZERO_OWNER = new Uint8Array(32);
-function u64be(value) {
-    const out = new Uint8Array(8);
-    new DataView(out.buffer).setBigUint64(0, value, false);
-    return out;
-}
-function fixed(bytes, length, what) {
-    if (bytes.length !== length)
-        throw new Error(`${what} must be ${length} bytes, got ${bytes.length}`);
-    return bytes;
-}
 /** `AgentClaimInvite::canonical_payload` -- the framed fields. */
 export function claimInviteCanonicalPayload(invite) {
     if (invite.expiresAtMs <= invite.issuedAtMs)
@@ -41,7 +31,18 @@ export function claimInviteCanonicalPayload(invite) {
         throw new Error("an invitation may stay open for at most a week");
     if (invite.nonce.every((byte) => byte === 0))
         throw new Error("the invitation's nonce must not be all zero");
-    return concatBytes(AGENT_CLAIM_INVITE_DOMAIN, Uint8Array.of(0, CANONICAL_WIRE_VERSION, INVITE_OPERATION), fixed(invite.agentId, 32, "agent id"), invite.owner ? fixed(invite.owner, 32, "owner") : ZERO_OWNER, fixed(invite.agentPublicKey, 32, "agent public key"), u64be(invite.issuedAtMs), u64be(invite.expiresAtMs), fixed(invite.nonce, AGENT_CLAIM_INVITE_NONCE_BYTES, "nonce"));
+    return new ByteWriter()
+        .pushBytes(AGENT_CLAIM_INVITE_DOMAIN)
+        .pushByte(0)
+        .pushByte(CANONICAL_WIRE_VERSION)
+        .pushByte(INVITE_OPERATION)
+        .pushFixed(invite.agentId, 32, "agent id")
+        .pushFixed(invite.owner ?? ZERO_OWNER, 32, "owner")
+        .pushFixed(invite.agentPublicKey, 32, "agent public key")
+        .pushU64(invite.issuedAtMs)
+        .pushU64(invite.expiresAtMs)
+        .pushFixed(invite.nonce, AGENT_CLAIM_INVITE_NONCE_BYTES, "nonce")
+        .bytes();
 }
 /** The bytes the agent's key signs, raw ed25519. */
 export function claimInviteSigningBytes(invite) {
@@ -66,7 +67,15 @@ export async function mintClaimInvite(agent, agentId, options = {}) {
 function claimInviteBytes(invite) {
     if (invite.signature.length !== 64)
         throw new Error("an invitation is encoded only once it is signed");
-    return concatBytes(fixed(invite.agentId, 32, "agent id"), invite.owner ?? ZERO_OWNER, fixed(invite.agentPublicKey, 32, "agent public key"), u64be(invite.issuedAtMs), u64be(invite.expiresAtMs), fixed(invite.nonce, 16, "nonce"), invite.signature);
+    return new ByteWriter()
+        .pushFixed(invite.agentId, 32, "agent id")
+        .pushFixed(invite.owner ?? ZERO_OWNER, 32, "owner")
+        .pushFixed(invite.agentPublicKey, 32, "agent public key")
+        .pushU64(invite.issuedAtMs)
+        .pushU64(invite.expiresAtMs)
+        .pushFixed(invite.nonce, AGENT_CLAIM_INVITE_NONCE_BYTES, "nonce")
+        .pushBytes(invite.signature)
+        .bytes();
 }
 /** The token the link carries and the claim body posts back: 0x-hex.
  *
@@ -115,16 +124,23 @@ export function decodeClaimInvite(token) {
     const bytes = claimInviteTokenBytes(token.trim());
     if (bytes.length !== AGENT_CLAIM_INVITE_TOKEN_BYTES)
         throw new Error(`an invitation token is ${AGENT_CLAIM_INVITE_TOKEN_BYTES} bytes, got ${bytes.length}`);
-    const view = new DataView(bytes.buffer, bytes.byteOffset);
-    const owner = bytes.slice(32, 64);
+    const reader = new ByteReader(bytes);
+    const agentId = reader.readFixed(32, "agent id");
+    const owner = reader.readFixed(32, "owner");
+    const agentPublicKey = reader.readFixed(32, "agent public key");
+    const issuedAtMs = reader.readU64("issued");
+    const expiresAtMs = reader.readU64("expires");
+    const nonce = reader.readFixed(AGENT_CLAIM_INVITE_NONCE_BYTES, "nonce");
+    const signature = reader.readFixed(64, "signature");
+    reader.finish();
     return {
-        agentId: bytes.slice(0, 32),
+        agentId,
         owner: equalBytes(owner, ZERO_OWNER) ? null : owner,
-        agentPublicKey: bytes.slice(64, 96),
-        issuedAtMs: view.getBigUint64(96, false),
-        expiresAtMs: view.getBigUint64(104, false),
-        nonce: bytes.slice(112, 128),
-        signature: bytes.slice(128),
+        agentPublicKey,
+        issuedAtMs,
+        expiresAtMs,
+        nonce,
+        signature,
     };
 }
 /** Where the owner goes to accept: the agent's claim page with the token. */

package/dist/identity.js

@@ -7,11 +7,13 @@
  * and this key can no longer sign for it -- which is the point of a claim.
  *
  * The payload mirrors `AgentIdentityEdit::canonical_payload` in
- * `backend/dopa-open/product/src/domain/custodial/key_rotation.rs`: every
- * field is length-framed, so "ab"/"c" and "a"/"bc" cannot sign the same
- * bytes. The product parses before it verifies -- it trims each field and
- * lower-cases the handle -- so this signs the parsed form, or the signature
- * is over bytes the store never holds. */
+ * `backend/dopa-open/product/src/domain/custodial/key_rotation.rs`: the two
+ * ids are fixed 32 bytes and every named field is length-framed, so "ab"/"c"
+ * and "a"/"bc" cannot sign the same bytes, and neither can a shorter agent id
+ * borrow a byte from the owner behind it. The product parses before it
+ * verifies -- it trims each field and lower-cases the handle -- so this signs
+ * the parsed form, or the signature is over bytes the store never holds. */
+import { ByteWriter, fromHex, textBytes } from "./bytes.js";
 import { signOwnerAuthenticator } from "./keypair.js";
 import { refusalMessageFromText } from "./refusal.js";
 const IDENTITY_DOMAIN = "dopa_open::agent_identity::v1";
@@ -25,40 +27,20 @@ export function parseIdentityFields(fields) {
         bio: fields.bio?.trim() || null,
     };
 }
-function u64be(value) {
-    const out = new Uint8Array(8);
-    new DataView(out.buffer).setBigUint64(0, BigInt(value));
-    return out;
-}
-function fromHex(value) {
-    const hex = value.replace(/^0x/i, "");
-    const out = new Uint8Array(hex.length / 2);
-    for (let index = 0; index < out.length; index++)
-        out[index] = Number.parseInt(hex.slice(index * 2, index * 2 + 2), 16);
-    return out;
-}
 /** The exact bytes the owning address signs to name an agent. */
 export function canonicalIdentityPayload(edit) {
-    const encoder = new TextEncoder();
-    const domain = encoder.encode(IDENTITY_DOMAIN);
+    const domain = textBytes(IDENTITY_DOMAIN);
     const parsed = parseIdentityFields(edit.fields);
-    const parts = [parsed.name ?? "", parsed.handle ?? "", parsed.bio ?? ""].map((field) => encoder.encode(field));
-    const chunks = [
-        u64be(domain.length),
-        domain,
-        fromHex(edit.agentId),
-        fromHex(edit.owner),
-        ...parts.flatMap((field) => [u64be(field.length), field]),
-        u64be(edit.issuedAtMs),
-        u64be(edit.expiresAtMs),
-    ];
-    const out = new Uint8Array(chunks.reduce((total, chunk) => total + chunk.length, 0));
-    let offset = 0;
-    for (const chunk of chunks) {
-        out.set(chunk, offset);
-        offset += chunk.length;
+    const writer = new ByteWriter()
+        .pushU64(domain.length)
+        .pushBytes(domain)
+        .pushFixed(fromHex(edit.agentId), 32, "agent id")
+        .pushFixed(fromHex(edit.owner), 32, "owner");
+    for (const field of [parsed.name ?? "", parsed.handle ?? "", parsed.bio ?? ""]) {
+        const bytes = textBytes(field);
+        writer.pushU64(bytes.length).pushBytes(bytes);
     }
-    return out;
+    return writer.pushU64(edit.issuedAtMs).pushU64(edit.expiresAtMs).bytes();
 }
 /** Name an agent, as the address that owns it. Answers what the arena stored. */
 export async function nameAgent(args) {
@@ -73,7 +55,7 @@ export async function nameAgent(args) {
         issuedAtMs,
         expiresAtMs,
     }));
-    const agentId = `0x${args.agentId.replace(/^0x/i, "")}`;
+    const agentId = `0x${args.agentId.replace(/^0x/, "")}`;
     const response = await fetchImpl(`${args.productUrl.replace(/\/$/, "")}/open/v1/agents/${agentId}/identity`, {
         method: "PUT",
         headers: { "content-type": "application/json" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dopamint-fun/open-sdk",
-  "version": "0.2.0-dev.2",
+  "version": "0.2.0-dev.4",
   "description": "DOPA-OPEN client SDK: generate and hold your own agent key, sign registrations, and play a Participant Session",
   "license": "Apache-2.0",
   "repository": {