cojson 0.0.10 → 0.0.12

package/src/crypto.ts

@@ -5,45 +5,47 @@ import { base58, base64url } from "@scure/base";
 import stableStringify from "fast-json-stable-stringify";
 import { blake3 } from "@noble/hashes/blake3";
 import { randomBytes } from "@noble/ciphers/webcrypto/utils";
-import { RawCoValueID, TransactionID } from './ids.js';
+import { AgentID, RawCoID, TransactionID } from './ids.js';
 
-export type SignatorySecret = `signatorySecret_z${string}`;
-export type SignatoryID = `signatory_z${string}`;
+export type SignerSecret = `signerSecret_z${string}`;
+export type SignerID = `signer_z${string}`;
 export type Signature = `signature_z${string}`;
 
-export type RecipientSecret = `recipientSecret_z${string}`;
-export type RecipientID = `recipient_z${string}`;
+export type SealerSecret = `sealerSecret_z${string}`;
+export type SealerID = `sealer_z${string}`;
 export type Sealed<T> = `sealed_U${string}` & { __type: T };
 
+export type AgentSecret = `${SealerSecret}/${SignerSecret}`;
+
 const textEncoder = new TextEncoder();
 const textDecoder = new TextDecoder();
 
-export function newRandomSignatory(): SignatorySecret {
-    return `signatorySecret_z${base58.encode(
+export function newRandomSigner(): SignerSecret {
+    return `signerSecret_z${base58.encode(
         ed25519.utils.randomPrivateKey()
     )}`;
 }
 
-export function signatorySecretToBytes(secret: SignatorySecret): Uint8Array {
-    return base58.decode(secret.substring("signatorySecret_z".length));
+export function signerSecretToBytes(secret: SignerSecret): Uint8Array {
+    return base58.decode(secret.substring("signerSecret_z".length));
 }
 
-export function signatorySecretFromBytes(bytes: Uint8Array): SignatorySecret {
-    return `signatorySecret_z${base58.encode(bytes)}`;
+export function signerSecretFromBytes(bytes: Uint8Array): SignerSecret {
+    return `signerSecret_z${base58.encode(bytes)}`;
 }
 
-export function getSignatoryID(secret: SignatorySecret): SignatoryID {
-    return `signatory_z${base58.encode(
+export function getSignerID(secret: SignerSecret): SignerID {
+    return `signer_z${base58.encode(
         ed25519.getPublicKey(
-            base58.decode(secret.substring("signatorySecret_z".length))
+            base58.decode(secret.substring("signerSecret_z".length))
         )
     )}`;
 }
 
-export function sign(secret: SignatorySecret, message: JsonValue): Signature {
+export function sign(secret: SignerSecret, message: JsonValue): Signature {
     const signature = ed25519.sign(
         textEncoder.encode(stableStringify(message)),
-        base58.decode(secret.substring("signatorySecret_z".length))
+        base58.decode(secret.substring("signerSecret_z".length))
     );
     return `signature_z${base58.encode(signature)}`;
 }
@@ -51,105 +53,131 @@ export function sign(secret: SignatorySecret, message: JsonValue): Signature {
 export function verify(
     signature: Signature,
     message: JsonValue,
-    id: SignatoryID
+    id: SignerID
 ): boolean {
     return ed25519.verify(
         base58.decode(signature.substring("signature_z".length)),
         textEncoder.encode(stableStringify(message)),
-        base58.decode(id.substring("signatory_z".length))
+        base58.decode(id.substring("signer_z".length))
     );
 }
 
-export function newRandomRecipient(): RecipientSecret {
-    return `recipientSecret_z${base58.encode(x25519.utils.randomPrivateKey())}`;
+export function newRandomSealer(): SealerSecret {
+    return `sealerSecret_z${base58.encode(x25519.utils.randomPrivateKey())}`;
 }
 
-export function recipientSecretToBytes(secret: RecipientSecret): Uint8Array {
-    return base58.decode(secret.substring("recipientSecret_z".length));
+export function sealerSecretToBytes(secret: SealerSecret): Uint8Array {
+    return base58.decode(secret.substring("sealerSecret_z".length));
 }
 
-export function recipientSecretFromBytes(bytes: Uint8Array): RecipientSecret {
-    return `recipientSecret_z${base58.encode(bytes)}`;
+export function sealerSecretFromBytes(bytes: Uint8Array): SealerSecret {
+    return `sealerSecret_z${base58.encode(bytes)}`;
 }
 
-export function getRecipientID(secret: RecipientSecret): RecipientID {
-    return `recipient_z${base58.encode(
+export function getSealerID(secret: SealerSecret): SealerID {
+    return `sealer_z${base58.encode(
         x25519.getPublicKey(
-            base58.decode(secret.substring("recipientSecret_z".length))
+            base58.decode(secret.substring("sealerSecret_z".length))
         )
     )}`;
 }
 
-export type SealedSet<T> = {
-    [recipient: RecipientID]: Sealed<T>;
-};
+export function newRandomAgentSecret(): AgentSecret {
+    return `${newRandomSealer()}/${newRandomSigner()}`;
+}
+
+export function agentSecretToBytes(secret: AgentSecret): Uint8Array {
+    const [sealerSecret, signerSecret] = secret.split("/");
+    return new Uint8Array([
+        ...sealerSecretToBytes(sealerSecret as SealerSecret),
+        ...signerSecretToBytes(signerSecret as SignerSecret),
+    ]);
+}
+
+export function agentSecretFromBytes(bytes: Uint8Array): AgentSecret {
+    const sealerSecret = sealerSecretFromBytes(
+        bytes.slice(0, 32)
+    );
+    const signerSecret = signerSecretFromBytes(
+        bytes.slice(32)
+    );
+    return `${sealerSecret}/${signerSecret}`;
+}
+
+export function getAgentID(secret: AgentSecret): AgentID {
+    const [sealerSecret, signerSecret] = secret.split("/");
+    return `${getSealerID(
+        sealerSecret as SealerSecret
+    )}/${getSignerID(signerSecret as SignerSecret)}`;
+}
+
+export function getAgentSignerID(agentId: AgentID): SignerID {
+    return agentId.split("/")[1] as SignerID;
+}
+
+export function getAgentSignerSecret(agentSecret: AgentSecret): SignerSecret {
+    return agentSecret.split("/")[1] as SignerSecret;
+}
+
+export function getAgentSealerID(agentId: AgentID): SealerID {
+    return agentId.split("/")[0] as SealerID;
+}
+
+export function getAgentSealerSecret(agentSecret: AgentSecret): SealerSecret {
+    return agentSecret.split("/")[0] as SealerSecret;
+}
 
 export function seal<T extends JsonValue>(
     message: T,
-    from: RecipientSecret,
-    to: Set<RecipientID>,
-    nOnceMaterial: { in: RawCoValueID; tx: TransactionID }
-): SealedSet<T> {
+    from: SealerSecret,
+    to: SealerID,
+    nOnceMaterial: { in: RawCoID; tx: TransactionID }
+): Sealed<T> {
     const nOnce = blake3(
         textEncoder.encode(stableStringify(nOnceMaterial))
     ).slice(0, 24);
 
-    const recipientsSorted = Array.from(to).sort();
-    const recipientPubs = recipientsSorted.map((recipient) => {
-        return base58.decode(recipient.substring("recipient_z".length));
-    });
+    const sealerPub = base58.decode(to.substring("sealer_z".length));
+
     const senderPriv = base58.decode(
-        from.substring("recipientSecret_z".length)
+        from.substring("sealerSecret_z".length)
     );
 
     const plaintext = textEncoder.encode(stableStringify(message));
 
-    const sealedSet: SealedSet<T> = {};
-
-    for (let i = 0; i < recipientsSorted.length; i++) {
-        const recipient = recipientsSorted[i]!;
-        const sharedSecret = x25519.getSharedSecret(
-            senderPriv,
-            recipientPubs[i]!
-        );
-
-        const sealedBytes = xsalsa20_poly1305(sharedSecret, nOnce).encrypt(
-            plaintext
-        );
+    const sharedSecret = x25519.getSharedSecret(
+        senderPriv,
+        sealerPub
+    );
 
-        sealedSet[recipient] = `sealed_U${base64url.encode(
-            sealedBytes
-        )}` as Sealed<T>;
-    }
+    const sealedBytes = xsalsa20_poly1305(sharedSecret, nOnce).encrypt(
+        plaintext
+    );
 
-    return sealedSet;
+    return `sealed_U${base64url.encode(
+        sealedBytes
+    )}` as Sealed<T>
 }
 
-export function openAs<T extends JsonValue>(
-    sealedSet: SealedSet<T>,
-    recipient: RecipientSecret,
-    from: RecipientID,
-    nOnceMaterial: { in: RawCoValueID; tx: TransactionID }
+export function unseal<T extends JsonValue>(
+    sealed: Sealed<T>,
+    sealer: SealerSecret,
+    from: SealerID,
+    nOnceMaterial: { in: RawCoID; tx: TransactionID }
 ): T | undefined {
     const nOnce = blake3(
         textEncoder.encode(stableStringify(nOnceMaterial))
     ).slice(0, 24);
 
-    const recipientPriv = base58.decode(
-        recipient.substring("recipientSecret_z".length)
+    const sealerPriv = base58.decode(
+        sealer.substring("sealerSecret_z".length)
     );
 
-    const senderPub = base58.decode(from.substring("recipient_z".length));
-
-    const sealed = sealedSet[getRecipientID(recipient)];
-
-    if (!sealed) {
-        return undefined;
-    }
+    const senderPub = base58.decode(from.substring("sealer_z".length));
 
     const sealedBytes = base64url.decode(sealed.substring("sealed_U".length));
 
-    const sharedSecret = x25519.getSharedSecret(recipientPriv, senderPub);
+    const sharedSecret = x25519.getSharedSecret(sealerPriv, senderPub);
 
     const plaintext = xsalsa20_poly1305(sharedSecret, nOnce).decrypt(
         sealedBytes
@@ -235,30 +263,30 @@ function encrypt<T extends JsonValue, N extends JsonValue>(
 export function encryptForTransaction<T extends JsonValue>(
     value: T,
     keySecret: KeySecret,
-    nOnceMaterial: { in: RawCoValueID; tx: TransactionID }
-): Encrypted<T, { in: RawCoValueID; tx: TransactionID }> {
+    nOnceMaterial: { in: RawCoID; tx: TransactionID }
+): Encrypted<T, { in: RawCoID; tx: TransactionID }> {
     return encrypt(value, keySecret, nOnceMaterial);
 }
 
-export function sealKeySecret(keys: {
-    toSeal: { id: KeyID; secret: KeySecret };
-    sealing: { id: KeyID; secret: KeySecret };
+export function encryptKeySecret(keys: {
+    toEncrypt: { id: KeyID; secret: KeySecret };
+    encrypting: { id: KeyID; secret: KeySecret };
 }): {
-    sealed: KeyID;
-    sealing: KeyID;
-    encrypted: Encrypted<KeySecret, { sealed: KeyID; sealing: KeyID }>;
+    encryptedID: KeyID;
+    encryptingID: KeyID;
+    encrypted: Encrypted<KeySecret, { encryptedID: KeyID; encryptingID: KeyID }>;
 } {
     const nOnceMaterial = {
-        sealed: keys.toSeal.id,
-        sealing: keys.sealing.id,
+        encryptedID: keys.toEncrypt.id,
+        encryptingID: keys.encrypting.id,
     };
 
     return {
-        sealed: keys.toSeal.id,
-        sealing: keys.sealing.id,
+        encryptedID: keys.toEncrypt.id,
+        encryptingID: keys.encrypting.id,
         encrypted: encrypt(
-            keys.toSeal.secret,
-            keys.sealing.secret,
+            keys.toEncrypt.secret,
+            keys.encrypting.secret,
             nOnceMaterial
         ),
     };
@@ -289,27 +317,27 @@ function decrypt<T extends JsonValue, N extends JsonValue>(
 }
 
 export function decryptForTransaction<T extends JsonValue>(
-    encrypted: Encrypted<T, { in: RawCoValueID; tx: TransactionID }>,
+    encrypted: Encrypted<T, { in: RawCoID; tx: TransactionID }>,
     keySecret: KeySecret,
-    nOnceMaterial: { in: RawCoValueID; tx: TransactionID }
+    nOnceMaterial: { in: RawCoID; tx: TransactionID }
 ): T | undefined {
     return decrypt(encrypted, keySecret, nOnceMaterial);
 }
 
-export function unsealKeySecret(
-    sealedInfo: {
-        sealed: KeyID;
-        sealing: KeyID;
-        encrypted: Encrypted<KeySecret, { sealed: KeyID; sealing: KeyID }>;
+export function decryptKeySecret(
+    encryptedInfo: {
+        encryptedID: KeyID;
+        encryptingID: KeyID;
+        encrypted: Encrypted<KeySecret, { encryptedID: KeyID; encryptingID: KeyID }>;
     },
     sealingSecret: KeySecret
 ): KeySecret | undefined {
     const nOnceMaterial = {
-        sealed: sealedInfo.sealed,
-        sealing: sealedInfo.sealing,
+        encryptedID: encryptedInfo.encryptedID,
+        encryptingID: encryptedInfo.encryptingID,
     };
 
-    return decrypt(sealedInfo.encrypted, sealingSecret, nOnceMaterial);
+    return decrypt(encryptedInfo.encrypted, sealingSecret, nOnceMaterial);
 }
 
 export function uniquenessForHeader(): `z${string}` {

package/src/ids.ts

@@ -1,7 +1,13 @@
-export type RawCoValueID = `co_z${string}` | `co_${string}_z${string}`;
+import { AccountIDOrAgentID } from './account.js';
+
+export type RawCoID = `co_z${string}`;
 
 export type TransactionID = { sessionID: SessionID; txIndex: number };
 
-export type AgentID = `co_agent${string}_z${string}`;
+export type AgentID = `sealer_z${string}/signer_z${string}`;
+
+export function isAgentID(id: string): id is AgentID {
+    return typeof id === "string" && id.startsWith("sealer_") && id.includes("/signer_");
+}
 
-export type SessionID = `${AgentID}_session_z${string}`;
+export type SessionID = `${AccountIDOrAgentID}_session_z${string}`;

package/src/index.ts

@@ -1,29 +1,19 @@
-import {
-    CoValue,
-    agentCredentialFromBytes,
-    agentCredentialToBytes,
-    getAgent,
-    getAgentID,
-    newRandomAgentCredential,
-    newRandomSessionID,
-} from './coValue.js';
-import { LocalNode } from './node.js';
-import { CoMap } from './contentTypes/coMap.js';
+import { CoValue, newRandomSessionID } from "./coValue.js";
+import { LocalNode } from "./node.js";
+import { CoMap } from "./contentTypes/coMap.js";
+import { agentSecretFromBytes, agentSecretToBytes } from "./crypto.js";
 
-import type { AgentCredential } from './coValue.js';
-import type { AgentID, SessionID } from './ids.js';
-import type { CoValueID, ContentType } from './contentType.js';
-import type { JsonValue } from './jsonValue.js';
-import type { SyncMessage } from './sync.js';
+import type { SessionID } from "./ids.js";
+import type { CoID, ContentType } from "./contentType.js";
+import type { JsonValue } from "./jsonValue.js";
+import type { SyncMessage } from "./sync.js";
+import type { AgentSecret } from "./crypto.js";
 
 type Value = JsonValue | ContentType;
 
 const internals = {
-    agentCredentialToBytes,
-    agentCredentialFromBytes,
-    getAgent,
-    getAgentID,
-    newRandomAgentCredential,
+    agentSecretFromBytes,
+    agentSecretToBytes,
     newRandomSessionID,
 };
 
@@ -33,9 +23,8 @@ export type {
     Value,
     JsonValue,
     ContentType,
-    CoValueID,
-    AgentCredential,
+    CoID,
+    AgentSecret,
     SessionID,
-    AgentID,
-    SyncMessage
+    SyncMessage,
 };

package/src/jsonValue.ts

@@ -1,6 +1,6 @@
-import { CoValueID, ContentType } from './contentType.js';
+import { CoID, ContentType } from './contentType.js';
 
 export type JsonAtom = string | number | boolean | null;
-export type JsonValue = JsonAtom | JsonArray | JsonObject | CoValueID<ContentType>;
+export type JsonValue = JsonAtom | JsonArray | JsonObject | CoID<ContentType>;
 export type JsonArray = JsonValue[];
 export type JsonObject = { [key: string]: JsonValue; };