@hashgraphonline/standards-sdk 0.1.180 → 0.1.181

package/dist/es/standards-sdk.es179.js

@@ -1,122 +1,199 @@
-import { adaptersResponseSchema, adapterDetailsResponseSchema, adapterRegistryCategoriesResponseSchema, adapterRegistryAdaptersResponseSchema, adapterRegistryCreateCategoryResponseSchema, adapterRegistrySubmitAdapterAcceptedResponseSchema, adapterRegistrySubmissionStatusResponseSchema } from "./standards-sdk.es160.js";
-import { toJsonObject } from "./standards-sdk.es185.js";
-async function adapters(client) {
-  const raw = await client.requestJson("/adapters", {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    adaptersResponseSchema,
-    "adapters response"
-  );
-}
-async function adaptersDetailed(client) {
-  const raw = await client.requestJson("/adapters/details", {
-    method: "GET"
+import { Buffer } from "buffer";
+import { secp256k1 } from "@noble/curves/secp256k1.js";
+import { registerEncryptionKeyResponseSchema } from "./standards-sdk.es162.js";
+import { optionalImport } from "./standards-sdk.es164.js";
+const getFs = async () => {
+  const fsModule = await optionalImport("node:fs") ?? await optionalImport("fs");
+  if (fsModule && typeof fsModule.existsSync === "function" && typeof fsModule.readFileSync === "function" && typeof fsModule.writeFileSync === "function" && typeof fsModule.appendFileSync === "function") {
+    return fsModule;
+  }
+  return null;
+};
+const getNodePath = async () => {
+  const pathModule = await optionalImport("node:path") ?? await optionalImport("path");
+  if (pathModule && typeof pathModule.resolve === "function") {
+    return pathModule;
+  }
+  return null;
+};
+const getNodeCrypto = async () => {
+  const cryptoModule = await optionalImport("node:crypto") ?? await optionalImport("crypto");
+  if (cryptoModule && typeof cryptoModule.randomBytes === "function") {
+    return cryptoModule;
+  }
+  return null;
+};
+async function registerEncryptionKey(client, payload) {
+  const raw = await client.requestJson("/encryption/keys", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: payload
   });
   return client.parseWithSchema(
     raw,
-    adapterDetailsResponseSchema,
-    "adapter details response"
+    registerEncryptionKeyResponseSchema,
+    "register encryption key response"
   );
 }
-async function adapterRegistryCategories(client) {
-  const raw = await client.requestJson(
-    "/adapters/registry/categories",
-    {
-      method: "GET"
+function normalizeAutoRegisterIdentity(config) {
+  const identity = {};
+  if (config.uaid) {
+    identity.uaid = config.uaid;
+  }
+  if (config.ledgerAccountId) {
+    identity.ledgerAccountId = config.ledgerAccountId;
+    if (config.ledgerNetwork) {
+      identity.ledgerNetwork = config.ledgerNetwork;
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    adapterRegistryCategoriesResponseSchema,
-    "adapter registry categories response"
-  );
+  }
+  if (config.email) {
+    identity.email = config.email;
+  }
+  if (identity.uaid || identity.ledgerAccountId || identity.email) {
+    return identity;
+  }
+  return null;
+}
+function derivePublicKeyFromPrivateKey(client, privateKey) {
+  const normalized = client.hexToBuffer(privateKey);
+  const publicKey = secp256k1.getPublicKey(normalized, true);
+  return Buffer.from(publicKey).toString("hex");
 }
-async function adapterRegistryAdapters(client, filters = {}) {
-  const params = new URLSearchParams();
-  if (filters.category) {
-    params.set("category", filters.category);
+async function resolveAutoRegisterKeyMaterial(client, config) {
+  if (config.publicKey?.trim()) {
+    return { publicKey: config.publicKey.trim() };
   }
-  if (filters.entity) {
-    params.set("entity", filters.entity);
+  let privateKey = config.privateKey?.trim();
+  const envVar = config.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
+  if (!privateKey && envVar && process?.env?.[envVar]?.trim()) {
+    privateKey = process.env[envVar]?.trim();
   }
-  if (filters.keywords?.length) {
-    params.set("keywords", filters.keywords.join(","));
+  if (!privateKey && config.generateIfMissing) {
+    const pair = await client.generateEncryptionKeyPair({
+      keyType: config.keyType ?? "secp256k1",
+      envVar,
+      envPath: config.envPath,
+      overwrite: config.overwriteEnv
+    });
+    return { publicKey: pair.publicKey, privateKey: pair.privateKey };
   }
-  if (filters.query) {
-    params.set("query", filters.query);
+  if (privateKey) {
+    const publicKey = derivePublicKeyFromPrivateKey(client, privateKey);
+    return { publicKey, privateKey };
   }
-  if (typeof filters.limit === "number") {
-    params.set("limit", String(filters.limit));
+  return null;
+}
+async function autoRegisterEncryptionKey(client, config) {
+  const identity = normalizeAutoRegisterIdentity(config);
+  if (!identity) {
+    throw new Error(
+      "Auto-registration requires uaid, ledgerAccountId, or email"
+    );
   }
-  if (typeof filters.offset === "number") {
-    params.set("offset", String(filters.offset));
+  const material = await resolveAutoRegisterKeyMaterial(client, config);
+  if (!material) {
+    throw new Error(
+      "Unable to resolve encryption public key for auto-registration"
+    );
   }
-  const suffix = params.size > 0 ? `?${params.toString()}` : "";
-  const raw = await client.requestJson(
-    `/adapters/registry/adapters${suffix}`,
-    {
-      method: "GET"
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    adapterRegistryAdaptersResponseSchema,
-    "adapter registry adapters response"
-  );
+  await registerEncryptionKey(client, {
+    keyType: config.keyType ?? "secp256k1",
+    publicKey: material.publicKey,
+    ...identity
+  });
+  return material;
 }
-async function createAdapterRegistryCategory(client, payload) {
-  const raw = await client.requestJson(
-    "/adapters/registry/categories",
-    {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: toJsonObject(payload)
-    }
-  );
-  const parsed = client.parseWithSchema(
-    raw,
-    adapterRegistryCreateCategoryResponseSchema,
-    "adapter registry create category response"
-  );
-  return parsed.category;
+async function ensureAgentEncryptionKey(client, options) {
+  return autoRegisterEncryptionKey(client, {
+    ...options,
+    uaid: options.uaid
+  });
 }
-async function submitAdapterRegistryAdapter(client, payload) {
-  const raw = await client.requestJson(
-    "/adapters/registry/adapters",
-    {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: toJsonObject(payload)
-    }
-  );
-  return client.parseWithSchema(
-    raw,
-    adapterRegistrySubmitAdapterAcceptedResponseSchema,
-    "adapter registry submit adapter response"
-  );
+function createEncryptionApi(client) {
+  return {
+    registerKey: (payload) => registerEncryptionKey(client, payload),
+    generateEphemeralKeyPair: () => client.createEphemeralKeyPair(),
+    deriveSharedSecret: (options) => client.deriveSharedSecret(options),
+    encryptCipherEnvelope: (options) => client.buildCipherEnvelope(options),
+    decryptCipherEnvelope: (options) => client.openCipherEnvelope(options),
+    ensureAgentKey: (options) => ensureAgentEncryptionKey(client, options)
+  };
+}
+async function bootstrapEncryptionOptions(client, options) {
+  if (!options?.autoRegister || options.autoRegister.enabled === false) {
+    return null;
+  }
+  return autoRegisterEncryptionKey(client, options.autoRegister);
 }
-async function adapterRegistrySubmissionStatus(client, submissionId) {
-  const raw = await client.requestJson(
-    `/adapters/registry/submissions/${encodeURIComponent(submissionId)}`,
-    {
-      method: "GET"
+async function generateEncryptionKeyPair(client, options = {}) {
+  client.assertNodeRuntime("generateEncryptionKeyPair");
+  const keyType = options.keyType ?? "secp256k1";
+  if (keyType !== "secp256k1") {
+    throw new Error("Only secp256k1 key generation is supported currently");
+  }
+  const cryptoModule = await getNodeCrypto();
+  if (!cryptoModule) {
+    throw new Error(
+      "Node.js crypto module is not available; cannot generate encryption key pair"
+    );
+  }
+  const privateKeyBytes = cryptoModule.randomBytes(32);
+  const privateKey = Buffer.from(privateKeyBytes).toString("hex");
+  const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);
+  const publicKey = Buffer.from(publicKeyBytes).toString("hex");
+  const envVar = options.envVar ?? "RB_ENCRYPTION_PRIVATE_KEY";
+  const pathModule = options.envPath ? await getNodePath() : null;
+  const resolvedPath = options.envPath && pathModule ? pathModule.resolve(options.envPath) : void 0;
+  if (options.envPath && !resolvedPath) {
+    throw new Error(
+      "Node.js path module is not available; cannot resolve encryption key env path"
+    );
+  }
+  if (resolvedPath) {
+    const fsModule = await getFs();
+    if (!fsModule) {
+      throw new Error(
+        "File system module is not available; cannot write encryption key env file"
+      );
     }
-  );
-  return client.parseWithSchema(
-    raw,
-    adapterRegistrySubmissionStatusResponseSchema,
-    "adapter registry submission status response"
-  );
+    const envLine = `${envVar}=${privateKey}`;
+    if (fsModule.existsSync(resolvedPath)) {
+      const content = fsModule.readFileSync(resolvedPath, "utf-8");
+      const lineRegex = new RegExp(`^${envVar}=.*$`, "m");
+      if (lineRegex.test(content)) {
+        if (!options.overwrite) {
+          throw new Error(
+            `${envVar} already exists in ${resolvedPath}; set overwrite=true to replace it`
+          );
+        }
+        const updated = content.replace(lineRegex, envLine);
+        fsModule.writeFileSync(resolvedPath, updated);
+      } else {
+        const needsNewline = !content.endsWith("\n");
+        fsModule.appendFileSync(
+          resolvedPath,
+          `${needsNewline ? "\n" : ""}${envLine}
+`
+        );
+      }
+    } else {
+      fsModule.writeFileSync(resolvedPath, `${envLine}
+`);
+    }
+  }
+  return {
+    privateKey,
+    publicKey,
+    envPath: resolvedPath,
+    envVar
+  };
 }
 export {
-  adapterRegistryAdapters,
-  adapterRegistryCategories,
-  adapterRegistrySubmissionStatus,
-  adapters,
-  adaptersDetailed,
-  createAdapterRegistryCategory,
-  submitAdapterRegistryAdapter
+  autoRegisterEncryptionKey,
+  bootstrapEncryptionOptions,
+  createEncryptionApi,
+  ensureAgentEncryptionKey,
+  generateEncryptionKeyPair,
+  registerEncryptionKey
 };
 //# sourceMappingURL=standards-sdk.es179.js.map

package/dist/es/standards-sdk.es179.js.map

@@ -1 +1 @@
-{"version":3,"file":"standards-sdk.es179.js","sources":["../../src/services/registry-broker/client/adapters.ts"],"sourcesContent":["import type {\n  AdapterDetailsResponse,\n  AdapterRegistryAdaptersResponse,\n  AdapterRegistryCategoriesResponse,\n  AdapterRegistryCategory,\n  AdapterRegistrySubmitAdapterAcceptedResponse,\n  AdapterRegistrySubmissionStatusResponse,\n  AdaptersResponse,\n  CreateAdapterRegistryCategoryRequest,\n  JsonValue,\n  SubmitAdapterRegistryAdapterRequest,\n} from '../types';\nimport {\n  adapterDetailsResponseSchema,\n  adapterRegistryAdaptersResponseSchema,\n  adapterRegistryCategoriesResponseSchema,\n  adapterRegistryCreateCategoryResponseSchema,\n  adapterRegistrySubmitAdapterAcceptedResponseSchema,\n  adapterRegistrySubmissionStatusResponseSchema,\n  adaptersResponseSchema,\n} from '../schemas';\nimport type { RegistryBrokerClient } from './base-client';\nimport { toJsonObject } from './utils';\n\nexport async function adapters(\n  client: RegistryBrokerClient,\n): Promise<AdaptersResponse> {\n  const raw = await client.requestJson<JsonValue>('/adapters', {\n    method: 'GET',\n  });\n  return client.parseWithSchema(\n    raw,\n    adaptersResponseSchema,\n    'adapters response',\n  );\n}\n\nexport async function adaptersDetailed(\n  client: RegistryBrokerClient,\n): Promise<AdapterDetailsResponse> {\n  const raw = await client.requestJson<JsonValue>('/adapters/details', {\n    method: 'GET',\n  });\n  return client.parseWithSchema(\n    raw,\n    adapterDetailsResponseSchema,\n    'adapter details response',\n  );\n}\n\nexport async function adapterRegistryCategories(\n  client: RegistryBrokerClient,\n): Promise<AdapterRegistryCategoriesResponse> {\n  const raw = await client.requestJson<JsonValue>(\n    '/adapters/registry/categories',\n    {\n      method: 'GET',\n    },\n  );\n  return client.parseWithSchema(\n    raw,\n    adapterRegistryCategoriesResponseSchema,\n    'adapter registry categories response',\n  );\n}\n\nexport async function adapterRegistryAdapters(\n  client: RegistryBrokerClient,\n  filters: {\n    category?: string;\n    entity?: string;\n    keywords?: string[];\n    query?: string;\n    limit?: number;\n    offset?: number;\n  } = {},\n): Promise<AdapterRegistryAdaptersResponse> {\n  const params = new URLSearchParams();\n  if (filters.category) {\n    params.set('category', filters.category);\n  }\n  if (filters.entity) {\n    params.set('entity', filters.entity);\n  }\n  if (filters.keywords?.length) {\n    params.set('keywords', filters.keywords.join(','));\n  }\n  if (filters.query) {\n    params.set('query', filters.query);\n  }\n  if (typeof filters.limit === 'number') {\n    params.set('limit', String(filters.limit));\n  }\n  if (typeof filters.offset === 'number') {\n    params.set('offset', String(filters.offset));\n  }\n\n  const suffix = params.size > 0 ? `?${params.toString()}` : '';\n  const raw = await client.requestJson<JsonValue>(\n    `/adapters/registry/adapters${suffix}`,\n    {\n      method: 'GET',\n    },\n  );\n  return client.parseWithSchema(\n    raw,\n    adapterRegistryAdaptersResponseSchema,\n    'adapter registry adapters response',\n  );\n}\n\nexport async function createAdapterRegistryCategory(\n  client: RegistryBrokerClient,\n  payload: CreateAdapterRegistryCategoryRequest,\n): Promise<AdapterRegistryCategory> {\n  const raw = await client.requestJson<JsonValue>(\n    '/adapters/registry/categories',\n    {\n      method: 'POST',\n      headers: { 'content-type': 'application/json' },\n      body: toJsonObject(payload),\n    },\n  );\n  const parsed = client.parseWithSchema(\n    raw,\n    adapterRegistryCreateCategoryResponseSchema,\n    'adapter registry create category response',\n  );\n  return parsed.category;\n}\n\nexport async function submitAdapterRegistryAdapter(\n  client: RegistryBrokerClient,\n  payload: SubmitAdapterRegistryAdapterRequest,\n): Promise<AdapterRegistrySubmitAdapterAcceptedResponse> {\n  const raw = await client.requestJson<JsonValue>(\n    '/adapters/registry/adapters',\n    {\n      method: 'POST',\n      headers: { 'content-type': 'application/json' },\n      body: toJsonObject(payload),\n    },\n  );\n  return client.parseWithSchema(\n    raw,\n    adapterRegistrySubmitAdapterAcceptedResponseSchema,\n    'adapter registry submit adapter response',\n  );\n}\n\nexport async function adapterRegistrySubmissionStatus(\n  client: RegistryBrokerClient,\n  submissionId: string,\n): Promise<AdapterRegistrySubmissionStatusResponse> {\n  const raw = await client.requestJson<JsonValue>(\n    `/adapters/registry/submissions/${encodeURIComponent(submissionId)}`,\n    {\n      method: 'GET',\n    },\n  );\n  return client.parseWithSchema(\n    raw,\n    adapterRegistrySubmissionStatusResponseSchema,\n    'adapter registry submission status response',\n  );\n}\n"],"names":[],"mappings":";;AAwBA,eAAsB,SACpB,QAC2B;AAC3B,QAAM,MAAM,MAAM,OAAO,YAAuB,aAAa;AAAA,IAC3D,QAAQ;AAAA,EAAA,CACT;AACD,SAAO,OAAO;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAEA,eAAsB,iBACpB,QACiC;AACjC,QAAM,MAAM,MAAM,OAAO,YAAuB,qBAAqB;AAAA,IACnE,QAAQ;AAAA,EAAA,CACT;AACD,SAAO,OAAO;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAEA,eAAsB,0BACpB,QAC4C;AAC5C,QAAM,MAAM,MAAM,OAAO;AAAA,IACvB;AAAA,IACA;AAAA,MACE,QAAQ;AAAA,IAAA;AAAA,EACV;AAEF,SAAO,OAAO;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAEA,eAAsB,wBACpB,QACA,UAOI,IACsC;AAC1C,QAAM,SAAS,IAAI,gBAAA;AACnB,MAAI,QAAQ,UAAU;AACpB,WAAO,IAAI,YAAY,QAAQ,QAAQ;AAAA,EACzC;AACA,MAAI,QAAQ,QAAQ;AAClB,WAAO,IAAI,UAAU,QAAQ,MAAM;AAAA,EACrC;AACA,MAAI,QAAQ,UAAU,QAAQ;AAC5B,WAAO,IAAI,YAAY,QAAQ,SAAS,KAAK,GAAG,CAAC;AAAA,EACnD;AACA,MAAI,QAAQ,OAAO;AACjB,WAAO,IAAI,SAAS,QAAQ,KAAK;AAAA,EACnC;AACA,MAAI,OAAO,QAAQ,UAAU,UAAU;AACrC,WAAO,IAAI,SAAS,OAAO,QAAQ,KAAK,CAAC;AAAA,EAC3C;AACA,MAAI,OAAO,QAAQ,WAAW,UAAU;AACtC,WAAO,IAAI,UAAU,OAAO,QAAQ,MAAM,CAAC;AAAA,EAC7C;AAEA,QAAM,SAAS,OAAO,OAAO,IAAI,IAAI,OAAO,UAAU,KAAK;AAC3D,QAAM,MAAM,MAAM,OAAO;AAAA,IACvB,8BAA8B,MAAM;AAAA,IACpC;AAAA,MACE,QAAQ;AAAA,IAAA;AAAA,EACV;AAEF,SAAO,OAAO;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAEA,eAAsB,8BACpB,QACA,SACkC;AAClC,QAAM,MAAM,MAAM,OAAO;AAAA,IACvB;AAAA,IACA;AAAA,MACE,QAAQ;AAAA,MACR,SAAS,EAAE,gBAAgB,mBAAA;AAAA,MAC3B,MAAM,aAAa,OAAO;AAAA,IAAA;AAAA,EAC5B;AAEF,QAAM,SAAS,OAAO;AAAA,IACpB;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEF,SAAO,OAAO;AAChB;AAEA,eAAsB,6BACpB,QACA,SACuD;AACvD,QAAM,MAAM,MAAM,OAAO;AAAA,IACvB;AAAA,IACA;AAAA,MACE,QAAQ;AAAA,MACR,SAAS,EAAE,gBAAgB,mBAAA;AAAA,MAC3B,MAAM,aAAa,OAAO;AAAA,IAAA;AAAA,EAC5B;AAEF,SAAO,OAAO;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAEA,eAAsB,gCACpB,QACA,cACkD;AAClD,QAAM,MAAM,MAAM,OAAO;AAAA,IACvB,kCAAkC,mBAAmB,YAAY,CAAC;AAAA,IAClE;AAAA,MACE,QAAQ;AAAA,IAAA;AAAA,EACV;AAEF,SAAO,OAAO;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;"}
+{"version":3,"file":"standards-sdk.es179.js","sources":["../../src/services/registry-broker/client/encryption.ts"],"sourcesContent":["import { Buffer } from 'buffer';\nimport { secp256k1 } from '@noble/curves/secp256k1.js';\nimport type {\n  AutoRegisterEncryptionKeyOptions,\n  CipherEnvelope,\n  ClientEncryptionOptions,\n  DecryptCipherEnvelopeOptions,\n  DeriveSharedSecretOptions,\n  EncryptCipherEnvelopeOptions,\n  EphemeralKeyPair,\n  EnsureAgentKeyOptions,\n  RegisterEncryptionKeyPayload,\n  RegisterEncryptionKeyResponse,\n  SharedSecretInput,\n} from '../types';\nimport { registerEncryptionKeyResponseSchema } from '../schemas';\nimport { optionalImport } from '../../../utils/dynamic-import';\nimport type {\n  RegistryBrokerClient,\n  GenerateEncryptionKeyPairOptions,\n} from './base-client';\n\ntype FsModule = {\n  existsSync: (path: string) => boolean;\n  readFileSync: (path: string, encoding: BufferEncoding) => string;\n  writeFileSync: (path: string, data: string) => void;\n  appendFileSync: (path: string, data: string) => void;\n};\n\ntype NodePathModule = {\n  resolve: (...segments: string[]) => string;\n};\n\ntype NodeCryptoModule = {\n  randomBytes: (size: number) => Buffer;\n};\n\nconst getFs = async (): Promise<FsModule | null> => {\n  const fsModule =\n    (await optionalImport<Partial<FsModule>>('node:fs')) ??\n    (await optionalImport<Partial<FsModule>>('fs'));\n\n  if (\n    fsModule &&\n    typeof fsModule.existsSync === 'function' &&\n    typeof fsModule.readFileSync === 'function' &&\n    typeof fsModule.writeFileSync === 'function' &&\n    typeof fsModule.appendFileSync === 'function'\n  ) {\n    return fsModule as FsModule;\n  }\n\n  return null;\n};\n\nconst getNodePath = async (): Promise<NodePathModule | null> => {\n  const pathModule =\n    (await optionalImport<Partial<NodePathModule>>('node:path')) ??\n    (await optionalImport<Partial<NodePathModule>>('path'));\n  if (pathModule && typeof pathModule.resolve === 'function') {\n    return pathModule as NodePathModule;\n  }\n  return null;\n};\n\nconst getNodeCrypto = async (): Promise<NodeCryptoModule | null> => {\n  const cryptoModule =\n    (await optionalImport<Partial<NodeCryptoModule>>('node:crypto')) ??\n    (await optionalImport<Partial<NodeCryptoModule>>('crypto'));\n  if (cryptoModule && typeof cryptoModule.randomBytes === 'function') {\n    return cryptoModule as NodeCryptoModule;\n  }\n  return null;\n};\n\nexport interface RegistryBrokerEncryptionApi {\n  registerKey: (\n    payload: RegisterEncryptionKeyPayload,\n  ) => Promise<RegisterEncryptionKeyResponse>;\n  generateEphemeralKeyPair: () => EphemeralKeyPair;\n  deriveSharedSecret: (options: DeriveSharedSecretOptions) => Buffer;\n  encryptCipherEnvelope: (\n    options: EncryptCipherEnvelopeOptions,\n  ) => CipherEnvelope;\n  decryptCipherEnvelope: (options: DecryptCipherEnvelopeOptions) => string;\n  ensureAgentKey: (\n    options: EnsureAgentKeyOptions,\n  ) => Promise<{ publicKey: string; privateKey?: string }>;\n}\n\nexport async function registerEncryptionKey(\n  client: RegistryBrokerClient,\n  payload: RegisterEncryptionKeyPayload,\n): Promise<RegisterEncryptionKeyResponse> {\n  const raw = await client.requestJson('/encryption/keys', {\n    method: 'POST',\n    headers: { 'content-type': 'application/json' },\n    body: payload,\n  });\n  return client.parseWithSchema(\n    raw,\n    registerEncryptionKeyResponseSchema,\n    'register encryption key response',\n  );\n}\n\nfunction normalizeAutoRegisterIdentity(\n  config: AutoRegisterEncryptionKeyOptions,\n): Pick<\n  RegisterEncryptionKeyPayload,\n  'uaid' | 'ledgerAccountId' | 'ledgerNetwork' | 'email'\n> | null {\n  const identity: Pick<\n    RegisterEncryptionKeyPayload,\n    'uaid' | 'ledgerAccountId' | 'ledgerNetwork' | 'email'\n  > = {};\n  if (config.uaid) {\n    identity.uaid = config.uaid;\n  }\n  if (config.ledgerAccountId) {\n    identity.ledgerAccountId = config.ledgerAccountId;\n    if (config.ledgerNetwork) {\n      identity.ledgerNetwork = config.ledgerNetwork;\n    }\n  }\n  if (config.email) {\n    identity.email = config.email;\n  }\n  if (identity.uaid || identity.ledgerAccountId || identity.email) {\n    return identity;\n  }\n  return null;\n}\n\nfunction derivePublicKeyFromPrivateKey(\n  client: RegistryBrokerClient,\n  privateKey: string,\n): string {\n  const normalized = client.hexToBuffer(privateKey);\n  const publicKey = secp256k1.getPublicKey(normalized, true);\n  return Buffer.from(publicKey).toString('hex');\n}\n\nasync function resolveAutoRegisterKeyMaterial(\n  client: RegistryBrokerClient,\n  config: AutoRegisterEncryptionKeyOptions,\n): Promise<{ publicKey: string; privateKey?: string } | null> {\n  if (config.publicKey?.trim()) {\n    return { publicKey: config.publicKey.trim() };\n  }\n  let privateKey = config.privateKey?.trim();\n  const envVar = config.envVar ?? 'RB_ENCRYPTION_PRIVATE_KEY';\n  if (!privateKey && envVar && process?.env?.[envVar]?.trim()) {\n    privateKey = process.env[envVar]?.trim();\n  }\n  if (!privateKey && config.generateIfMissing) {\n    const pair = await client.generateEncryptionKeyPair({\n      keyType: config.keyType ?? 'secp256k1',\n      envVar,\n      envPath: config.envPath,\n      overwrite: config.overwriteEnv,\n    });\n    return { publicKey: pair.publicKey, privateKey: pair.privateKey };\n  }\n  if (privateKey) {\n    const publicKey = derivePublicKeyFromPrivateKey(client, privateKey);\n    return { publicKey, privateKey };\n  }\n  return null;\n}\n\nexport async function autoRegisterEncryptionKey(\n  client: RegistryBrokerClient,\n  config: AutoRegisterEncryptionKeyOptions,\n): Promise<{ publicKey: string; privateKey?: string }> {\n  const identity = normalizeAutoRegisterIdentity(config);\n  if (!identity) {\n    throw new Error(\n      'Auto-registration requires uaid, ledgerAccountId, or email',\n    );\n  }\n  const material = await resolveAutoRegisterKeyMaterial(client, config);\n  if (!material) {\n    throw new Error(\n      'Unable to resolve encryption public key for auto-registration',\n    );\n  }\n  await registerEncryptionKey(client, {\n    keyType: config.keyType ?? 'secp256k1',\n    publicKey: material.publicKey,\n    ...identity,\n  });\n  return material;\n}\n\nexport async function ensureAgentEncryptionKey(\n  client: RegistryBrokerClient,\n  options: EnsureAgentKeyOptions,\n): Promise<{ publicKey: string; privateKey?: string }> {\n  return autoRegisterEncryptionKey(client, {\n    ...options,\n    uaid: options.uaid,\n    enabled: true,\n  });\n}\n\nexport function createEncryptionApi(\n  client: RegistryBrokerClient,\n): RegistryBrokerEncryptionApi {\n  return {\n    registerKey: (payload: RegisterEncryptionKeyPayload) =>\n      registerEncryptionKey(client, payload),\n    generateEphemeralKeyPair: () => client.createEphemeralKeyPair(),\n    deriveSharedSecret: (options: DeriveSharedSecretOptions) =>\n      client.deriveSharedSecret(options),\n    encryptCipherEnvelope: (options: EncryptCipherEnvelopeOptions) =>\n      client.buildCipherEnvelope(options),\n    decryptCipherEnvelope: (options: DecryptCipherEnvelopeOptions) =>\n      client.openCipherEnvelope(options),\n    ensureAgentKey: (options: EnsureAgentKeyOptions) =>\n      ensureAgentEncryptionKey(client, options),\n  };\n}\n\nexport async function bootstrapEncryptionOptions(\n  client: RegistryBrokerClient,\n  options?: ClientEncryptionOptions,\n): Promise<{ publicKey: string; privateKey?: string } | null> {\n  if (!options?.autoRegister || options.autoRegister.enabled === false) {\n    return null;\n  }\n  return autoRegisterEncryptionKey(client, options.autoRegister);\n}\n\nexport async function generateEncryptionKeyPair(\n  client: RegistryBrokerClient,\n  options: GenerateEncryptionKeyPairOptions = {},\n): Promise<{\n  privateKey: string;\n  publicKey: string;\n  envPath?: string;\n  envVar: string;\n}> {\n  client.assertNodeRuntime('generateEncryptionKeyPair');\n\n  const keyType = options.keyType ?? 'secp256k1';\n  if (keyType !== 'secp256k1') {\n    throw new Error('Only secp256k1 key generation is supported currently');\n  }\n\n  const cryptoModule = await getNodeCrypto();\n  if (!cryptoModule) {\n    throw new Error(\n      'Node.js crypto module is not available; cannot generate encryption key pair',\n    );\n  }\n  const privateKeyBytes = cryptoModule.randomBytes(32);\n  const privateKey = Buffer.from(privateKeyBytes).toString('hex');\n  const publicKeyBytes = secp256k1.getPublicKey(privateKeyBytes, true);\n  const publicKey = Buffer.from(publicKeyBytes).toString('hex');\n\n  const envVar = options.envVar ?? 'RB_ENCRYPTION_PRIVATE_KEY';\n  const pathModule = options.envPath ? await getNodePath() : null;\n  const resolvedPath =\n    options.envPath && pathModule\n      ? pathModule.resolve(options.envPath)\n      : undefined;\n\n  if (options.envPath && !resolvedPath) {\n    throw new Error(\n      'Node.js path module is not available; cannot resolve encryption key env path',\n    );\n  }\n\n  if (resolvedPath) {\n    const fsModule = await getFs();\n\n    if (!fsModule) {\n      throw new Error(\n        'File system module is not available; cannot write encryption key env file',\n      );\n    }\n\n    const envLine = `${envVar}=${privateKey}`;\n    if (fsModule.existsSync(resolvedPath)) {\n      const content = fsModule.readFileSync(resolvedPath, 'utf-8');\n      const lineRegex = new RegExp(`^${envVar}=.*$`, 'm');\n      if (lineRegex.test(content)) {\n        if (!options.overwrite) {\n          throw new Error(\n            `${envVar} already exists in ${resolvedPath}; set overwrite=true to replace it`,\n          );\n        }\n        const updated = content.replace(lineRegex, envLine);\n        fsModule.writeFileSync(resolvedPath, updated);\n      } else {\n        const needsNewline = !content.endsWith('\\n');\n        fsModule.appendFileSync(\n          resolvedPath,\n          `${needsNewline ? '\\n' : ''}${envLine}\\n`,\n        );\n      }\n    } else {\n      fsModule.writeFileSync(resolvedPath, `${envLine}\\n`);\n    }\n  }\n\n  return {\n    privateKey,\n    publicKey,\n    envPath: resolvedPath,\n    envVar,\n  };\n}\n"],"names":[],"mappings":";;;;AAqCA,MAAM,QAAQ,YAAsC;AAClD,QAAM,WACH,MAAM,eAAkC,SAAS,KACjD,MAAM,eAAkC,IAAI;AAE/C,MACE,YACA,OAAO,SAAS,eAAe,cAC/B,OAAO,SAAS,iBAAiB,cACjC,OAAO,SAAS,kBAAkB,cAClC,OAAO,SAAS,mBAAmB,YACnC;AACA,WAAO;AAAA,EACT;AAEA,SAAO;AACT;AAEA,MAAM,cAAc,YAA4C;AAC9D,QAAM,aACH,MAAM,eAAwC,WAAW,KACzD,MAAM,eAAwC,MAAM;AACvD,MAAI,cAAc,OAAO,WAAW,YAAY,YAAY;AAC1D,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,MAAM,gBAAgB,YAA8C;AAClE,QAAM,eACH,MAAM,eAA0C,aAAa,KAC7D,MAAM,eAA0C,QAAQ;AAC3D,MAAI,gBAAgB,OAAO,aAAa,gBAAgB,YAAY;AAClE,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAiBA,eAAsB,sBACpB,QACA,SACwC;AACxC,QAAM,MAAM,MAAM,OAAO,YAAY,oBAAoB;AAAA,IACvD,QAAQ;AAAA,IACR,SAAS,EAAE,gBAAgB,mBAAA;AAAA,IAC3B,MAAM;AAAA,EAAA,CACP;AACD,SAAO,OAAO;AAAA,IACZ;AAAA,IACA;AAAA,IACA;AAAA,EAAA;AAEJ;AAEA,SAAS,8BACP,QAIO;AACP,QAAM,WAGF,CAAA;AACJ,MAAI,OAAO,MAAM;AACf,aAAS,OAAO,OAAO;AAAA,EACzB;AACA,MAAI,OAAO,iBAAiB;AAC1B,aAAS,kBAAkB,OAAO;AAClC,QAAI,OAAO,eAAe;AACxB,eAAS,gBAAgB,OAAO;AAAA,IAClC;AAAA,EACF;AACA,MAAI,OAAO,OAAO;AAChB,aAAS,QAAQ,OAAO;AAAA,EAC1B;AACA,MAAI,SAAS,QAAQ,SAAS,mBAAmB,SAAS,OAAO;AAC/D,WAAO;AAAA,EACT;AACA,SAAO;AACT;AAEA,SAAS,8BACP,QACA,YACQ;AACR,QAAM,aAAa,OAAO,YAAY,UAAU;AAChD,QAAM,YAAY,UAAU,aAAa,YAAY,IAAI;AACzD,SAAO,OAAO,KAAK,SAAS,EAAE,SAAS,KAAK;AAC9C;AAEA,eAAe,+BACb,QACA,QAC4D;AAC5D,MAAI,OAAO,WAAW,QAAQ;AAC5B,WAAO,EAAE,WAAW,OAAO,UAAU,OAAK;AAAA,EAC5C;AACA,MAAI,aAAa,OAAO,YAAY,KAAA;AACpC,QAAM,SAAS,OAAO,UAAU;AAChC,MAAI,CAAC,cAAc,UAAU,SAAS,MAAM,MAAM,GAAG,QAAQ;AAC3D,iBAAa,QAAQ,IAAI,MAAM,GAAG,KAAA;AAAA,EACpC;AACA,MAAI,CAAC,cAAc,OAAO,mBAAmB;AAC3C,UAAM,OAAO,MAAM,OAAO,0BAA0B;AAAA,MAClD,SAAS,OAAO,WAAW;AAAA,MAC3B;AAAA,MACA,SAAS,OAAO;AAAA,MAChB,WAAW,OAAO;AAAA,IAAA,CACnB;AACD,WAAO,EAAE,WAAW,KAAK,WAAW,YAAY,KAAK,WAAA;AAAA,EACvD;AACA,MAAI,YAAY;AACd,UAAM,YAAY,8BAA8B,QAAQ,UAAU;AAClE,WAAO,EAAE,WAAW,WAAA;AAAA,EACtB;AACA,SAAO;AACT;AAEA,eAAsB,0BACpB,QACA,QACqD;AACrD,QAAM,WAAW,8BAA8B,MAAM;AACrD,MAAI,CAAC,UAAU;AACb,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AACA,QAAM,WAAW,MAAM,+BAA+B,QAAQ,MAAM;AACpE,MAAI,CAAC,UAAU;AACb,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AACA,QAAM,sBAAsB,QAAQ;AAAA,IAClC,SAAS,OAAO,WAAW;AAAA,IAC3B,WAAW,SAAS;AAAA,IACpB,GAAG;AAAA,EAAA,CACJ;AACD,SAAO;AACT;AAEA,eAAsB,yBACpB,QACA,SACqD;AACrD,SAAO,0BAA0B,QAAQ;AAAA,IACvC,GAAG;AAAA,IACH,MAAM,QAAQ;AAAA,EAEhB,CAAC;AACH;AAEO,SAAS,oBACd,QAC6B;AAC7B,SAAO;AAAA,IACL,aAAa,CAAC,YACZ,sBAAsB,QAAQ,OAAO;AAAA,IACvC,0BAA0B,MAAM,OAAO,uBAAA;AAAA,IACvC,oBAAoB,CAAC,YACnB,OAAO,mBAAmB,OAAO;AAAA,IACnC,uBAAuB,CAAC,YACtB,OAAO,oBAAoB,OAAO;AAAA,IACpC,uBAAuB,CAAC,YACtB,OAAO,mBAAmB,OAAO;AAAA,IACnC,gBAAgB,CAAC,YACf,yBAAyB,QAAQ,OAAO;AAAA,EAAA;AAE9C;AAEA,eAAsB,2BACpB,QACA,SAC4D;AAC5D,MAAI,CAAC,SAAS,gBAAgB,QAAQ,aAAa,YAAY,OAAO;AACpE,WAAO;AAAA,EACT;AACA,SAAO,0BAA0B,QAAQ,QAAQ,YAAY;AAC/D;AAEA,eAAsB,0BACpB,QACA,UAA4C,IAM3C;AACD,SAAO,kBAAkB,2BAA2B;AAEpD,QAAM,UAAU,QAAQ,WAAW;AACnC,MAAI,YAAY,aAAa;AAC3B,UAAM,IAAI,MAAM,sDAAsD;AAAA,EACxE;AAEA,QAAM,eAAe,MAAM,cAAA;AAC3B,MAAI,CAAC,cAAc;AACjB,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AACA,QAAM,kBAAkB,aAAa,YAAY,EAAE;AACnD,QAAM,aAAa,OAAO,KAAK,eAAe,EAAE,SAAS,KAAK;AAC9D,QAAM,iBAAiB,UAAU,aAAa,iBAAiB,IAAI;AACnE,QAAM,YAAY,OAAO,KAAK,cAAc,EAAE,SAAS,KAAK;AAE5D,QAAM,SAAS,QAAQ,UAAU;AACjC,QAAM,aAAa,QAAQ,UAAU,MAAM,gBAAgB;AAC3D,QAAM,eACJ,QAAQ,WAAW,aACf,WAAW,QAAQ,QAAQ,OAAO,IAClC;AAEN,MAAI,QAAQ,WAAW,CAAC,cAAc;AACpC,UAAM,IAAI;AAAA,MACR;AAAA,IAAA;AAAA,EAEJ;AAEA,MAAI,cAAc;AAChB,UAAM,WAAW,MAAM,MAAA;AAEvB,QAAI,CAAC,UAAU;AACb,YAAM,IAAI;AAAA,QACR;AAAA,MAAA;AAAA,IAEJ;AAEA,UAAM,UAAU,GAAG,MAAM,IAAI,UAAU;AACvC,QAAI,SAAS,WAAW,YAAY,GAAG;AACrC,YAAM,UAAU,SAAS,aAAa,cAAc,OAAO;AAC3D,YAAM,YAAY,IAAI,OAAO,IAAI,MAAM,QAAQ,GAAG;AAClD,UAAI,UAAU,KAAK,OAAO,GAAG;AAC3B,YAAI,CAAC,QAAQ,WAAW;AACtB,gBAAM,IAAI;AAAA,YACR,GAAG,MAAM,sBAAsB,YAAY;AAAA,UAAA;AAAA,QAE/C;AACA,cAAM,UAAU,QAAQ,QAAQ,WAAW,OAAO;AAClD,iBAAS,cAAc,cAAc,OAAO;AAAA,MAC9C,OAAO;AACL,cAAM,eAAe,CAAC,QAAQ,SAAS,IAAI;AAC3C,iBAAS;AAAA,UACP;AAAA,UACA,GAAG,eAAe,OAAO,EAAE,GAAG,OAAO;AAAA;AAAA,QAAA;AAAA,MAEzC;AAAA,IACF,OAAO;AACL,eAAS,cAAc,cAAc,GAAG,OAAO;AAAA,CAAI;AAAA,IACrD;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA,SAAS;AAAA,IACT;AAAA,EAAA;AAEJ;"}

package/dist/es/standards-sdk.es18.js

@@ -9,13 +9,13 @@ import "@hashgraph/proto";
 import "buffer";
 import "@noble/curves/secp256k1.js";
 import "zod";
-import "./standards-sdk.es160.js";
-import "./standards-sdk.es149.js";
+import "./standards-sdk.es162.js";
+import "./standards-sdk.es150.js";
 import "ethers";
 import "./standards-sdk.es140.js";
 import { detectKeyTypeFromString } from "./standards-sdk.es131.js";
 import { getTopicId } from "./standards-sdk.es132.js";
-import { createNodeOperatorContext, NodeOperatorResolver } from "./standards-sdk.es158.js";
+import { createNodeOperatorContext, NodeOperatorResolver } from "./standards-sdk.es159.js";
 import { HCS10BaseClient, Hcs10MemoType } from "./standards-sdk.es16.js";
 import * as mime from "mime-types";
 import { AgentBuilder } from "./standards-sdk.es23.js";
@@ -23,7 +23,7 @@ import { InboundTopicType } from "./standards-sdk.es28.js";
 import { HCS11Client } from "./standards-sdk.es27.js";
 import { inscribe } from "./standards-sdk.es142.js";
 import { addSeconds } from "date-fns";
-import { buildTopicCreateTx, buildMessageTx } from "./standards-sdk.es159.js";
+import { buildTopicCreateTx, buildMessageTx } from "./standards-sdk.es160.js";
 import { buildHcs10CreateInboundTopicTx, buildHcs10CreateConnectionTopicTx, buildHcs10ConfirmConnectionTx, buildHcs10SendMessageTx, buildHcs10RegistryRegisterTx, buildHcs10CreateOutboundTopicTx, buildHcs10CreateRegistryTopicTx } from "./standards-sdk.es22.js";
 class HCS10Client extends HCS10BaseClient {
   constructor(config) {

package/dist/es/standards-sdk.es180.js

@@ -1,155 +1,122 @@
-import { registerStatusResponseSchema, moltbookOwnerRegistrationUpdateResponseSchema, verificationStatusResponseSchema, verificationChallengeResponseSchema, verificationChallengeDetailsResponseSchema, verificationVerifyResponseSchema, verificationOwnershipResponseSchema, verificationVerifySenderResponseSchema, verificationDnsStatusResponseSchema } from "./standards-sdk.es160.js";
-async function getVerificationStatus(client, uaid) {
-  const raw = await client.requestJson(
-    `/verification/status/${encodeURIComponent(uaid)}`,
-    { method: "GET" }
-  );
+import { adaptersResponseSchema, adapterDetailsResponseSchema, adapterRegistryCategoriesResponseSchema, adapterRegistryAdaptersResponseSchema, adapterRegistryCreateCategoryResponseSchema, adapterRegistrySubmitAdapterAcceptedResponseSchema, adapterRegistrySubmissionStatusResponseSchema } from "./standards-sdk.es162.js";
+import { toJsonObject } from "./standards-sdk.es186.js";
+async function adapters(client) {
+  const raw = await client.requestJson("/adapters", {
+    method: "GET"
+  });
   return client.parseWithSchema(
     raw,
-    verificationStatusResponseSchema,
-    "verification status response"
+    adaptersResponseSchema,
+    "adapters response"
   );
 }
-async function createVerificationChallenge(client, uaid) {
-  const raw = await client.requestJson("/verification/challenge", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: { uaid }
+async function adaptersDetailed(client) {
+  const raw = await client.requestJson("/adapters/details", {
+    method: "GET"
   });
   return client.parseWithSchema(
     raw,
-    verificationChallengeResponseSchema,
-    "verification challenge response"
+    adapterDetailsResponseSchema,
+    "adapter details response"
   );
 }
-async function getVerificationChallenge(client, challengeId) {
+async function adapterRegistryCategories(client) {
   const raw = await client.requestJson(
-    `/verification/challenge/${encodeURIComponent(challengeId)}`,
-    { method: "GET" }
-  );
-  return client.parseWithSchema(
-    raw,
-    verificationChallengeDetailsResponseSchema,
-    "verification challenge details response"
-  );
-}
-async function verifyVerificationChallenge(client, params) {
-  const raw = await client.requestJson("/verification/verify", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: {
-      challengeId: params.challengeId,
-      method: params.method ?? "moltbook-post"
+    "/adapters/registry/categories",
+    {
+      method: "GET"
     }
-  });
+  );
   return client.parseWithSchema(
     raw,
-    verificationVerifyResponseSchema,
-    "verification verify response"
+    adapterRegistryCategoriesResponseSchema,
+    "adapter registry categories response"
   );
 }
-async function getVerificationOwnership(client, uaid) {
+async function adapterRegistryAdapters(client, filters = {}) {
+  const params = new URLSearchParams();
+  if (filters.category) {
+    params.set("category", filters.category);
+  }
+  if (filters.entity) {
+    params.set("entity", filters.entity);
+  }
+  if (filters.keywords?.length) {
+    params.set("keywords", filters.keywords.join(","));
+  }
+  if (filters.query) {
+    params.set("query", filters.query);
+  }
+  if (typeof filters.limit === "number") {
+    params.set("limit", String(filters.limit));
+  }
+  if (typeof filters.offset === "number") {
+    params.set("offset", String(filters.offset));
+  }
+  const suffix = params.size > 0 ? `?${params.toString()}` : "";
   const raw = await client.requestJson(
-    `/verification/ownership/${encodeURIComponent(uaid)}`,
-    { method: "GET" }
+    `/adapters/registry/adapters${suffix}`,
+    {
+      method: "GET"
+    }
   );
   return client.parseWithSchema(
     raw,
-    verificationOwnershipResponseSchema,
-    "verification ownership response"
+    adapterRegistryAdaptersResponseSchema,
+    "adapter registry adapters response"
   );
 }
-async function verifySenderOwnership(client, uaid) {
+async function createAdapterRegistryCategory(client, payload) {
   const raw = await client.requestJson(
-    "/verification/verify-sender",
+    "/adapters/registry/categories",
     {
       method: "POST",
       headers: { "content-type": "application/json" },
-      body: { uaid }
+      body: toJsonObject(payload)
     }
   );
-  return client.parseWithSchema(
+  const parsed = client.parseWithSchema(
     raw,
-    verificationVerifySenderResponseSchema,
-    "verification sender response"
+    adapterRegistryCreateCategoryResponseSchema,
+    "adapter registry create category response"
   );
+  return parsed.category;
 }
-async function verifyUaidDnsTxt(client, payload) {
-  const raw = await client.requestJson("/verification/dns/verify", {
-    method: "POST",
-    headers: { "content-type": "application/json" },
-    body: {
-      uaid: payload.uaid,
-      ...payload.persist !== void 0 ? { persist: payload.persist } : {}
-    }
-  });
-  return client.parseWithSchema(
-    raw,
-    verificationDnsStatusResponseSchema,
-    "verification dns verify response"
-  );
-}
-async function getVerificationDnsStatus(client, uaid, query) {
-  const params = new URLSearchParams();
-  if (query?.refresh !== void 0) {
-    params.set("refresh", String(query.refresh));
-  }
-  if (query?.persist !== void 0) {
-    params.set("persist", String(query.persist));
-  }
-  const queryString = params.toString();
-  const path = `/verification/dns/status/${encodeURIComponent(uaid)}${queryString ? `?${queryString}` : ""}`;
-  const raw = await client.requestJson(path, {
-    method: "GET"
-  });
-  return client.parseWithSchema(
-    raw,
-    verificationDnsStatusResponseSchema,
-    "verification dns status response"
-  );
-}
-async function getRegisterStatus(client, uaid) {
+async function submitAdapterRegistryAdapter(client, payload) {
   const raw = await client.requestJson(
-    `/register/status/${encodeURIComponent(uaid)}`,
-    { method: "GET" }
+    "/adapters/registry/adapters",
+    {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: toJsonObject(payload)
+    }
   );
   return client.parseWithSchema(
     raw,
-    registerStatusResponseSchema,
-    "register status response"
+    adapterRegistrySubmitAdapterAcceptedResponseSchema,
+    "adapter registry submit adapter response"
   );
 }
-async function registerOwnedMoltbookAgent(client, uaid, request) {
+async function adapterRegistrySubmissionStatus(client, submissionId) {
   const raw = await client.requestJson(
-    `/register/${encodeURIComponent(uaid)}`,
+    `/adapters/registry/submissions/${encodeURIComponent(submissionId)}`,
     {
-      method: "PUT",
-      headers: { "content-type": "application/json" },
-      body: {
-        registered: request.registered ?? true,
-        ...request.name ? { name: request.name } : {},
-        ...request.description ? { description: request.description } : {},
-        ...request.endpoint ? { endpoint: request.endpoint } : {},
-        ...request.metadata ? { metadata: request.metadata } : {}
-      }
+      method: "GET"
     }
   );
   return client.parseWithSchema(
     raw,
-    moltbookOwnerRegistrationUpdateResponseSchema,
-    "moltbook owner registration update response"
+    adapterRegistrySubmissionStatusResponseSchema,
+    "adapter registry submission status response"
   );
 }
 export {
-  createVerificationChallenge,
-  getRegisterStatus,
-  getVerificationChallenge,
-  getVerificationDnsStatus,
-  getVerificationOwnership,
-  getVerificationStatus,
-  registerOwnedMoltbookAgent,
-  verifySenderOwnership,
-  verifyUaidDnsTxt,
-  verifyVerificationChallenge
+  adapterRegistryAdapters,
+  adapterRegistryCategories,
+  adapterRegistrySubmissionStatus,
+  adapters,
+  adaptersDetailed,
+  createAdapterRegistryCategory,
+  submitAdapterRegistryAdapter
 };
 //# sourceMappingURL=standards-sdk.es180.js.map