web5-cli 0.1.0

package/dist/utils/did.js

@@ -0,0 +1,252 @@
+import { CKB_SK_PATH, readKey, error, success, writeJsonFile } from './common.js';
+import { ccc } from '@ckb-ccc/ccc';
+import { base32 } from '@scure/base';
+function getNetwork() {
+    const network = process.env.CKB_NETWORK;
+    if (network === 'ckb')
+        return 'ckb';
+    return 'ckb_testnet';
+}
+async function getClient() {
+    const network = getNetwork();
+    if (network === 'ckb') {
+        return new ccc.ClientPublicMainnet();
+    }
+    return new ccc.ClientPublicTestnet();
+}
+async function getSigner() {
+    const privateKey = await readKey(CKB_SK_PATH);
+    if (!privateKey)
+        return null;
+    const client = await getClient();
+    return new ccc.SignerCkbPrivateKey(client, privateKey);
+}
+function didFromArgs(args) {
+    const argsBytes = ccc.bytesFrom(args.slice(0, 42));
+    return `did:ckb:${base32.encode(argsBytes).toLowerCase()}`;
+}
+export const didManager = {
+    async buildCreateTx(username, pds, didkey, outputPath) {
+        const signer = await getSigner();
+        if (!signer) {
+            error('No wallet found. Use "wallet new" or "wallet import" first.');
+            return;
+        }
+        try {
+            const address = await signer.getRecommendedAddressObj();
+            const handle = `${username.toLowerCase()}.${pds}`;
+            const metadata = {
+                document: {
+                    alsoKnownAs: [`at://${handle}`],
+                    verificationMethods: {
+                        atproto: didkey
+                    },
+                    services: {
+                        atproto_pds: {
+                            type: 'AtprotoPersonalDataServer',
+                            endpoint: `https://${pds}`
+                        }
+                    }
+                }
+            };
+            const { tx, id } = await ccc.didCkb.createDidCkb({
+                signer,
+                data: { value: metadata },
+                receiver: address.script,
+            });
+            await tx.completeInputsByCapacity(signer);
+            await tx.completeFeeBy(signer);
+            const rawTx = ccc.stringify(tx);
+            const did = didFromArgs(id);
+            await writeJsonFile(outputPath, JSON.parse(rawTx));
+            success({ did, txPath: outputPath });
+        }
+        catch (e) {
+            error(`Failed to build create transaction: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async buildDestroyTx(args, outputPath) {
+        const signer = await getSigner();
+        if (!signer) {
+            error('No wallet found. Use "wallet new" or "wallet import" first.');
+            return;
+        }
+        try {
+            const { tx } = await ccc.didCkb.destroyDidCkb({ client: signer.client, id: args });
+            await tx.completeInputsByCapacity(signer);
+            await tx.completeFeeBy(signer);
+            const rawTx = ccc.stringify(tx);
+            await writeJsonFile(outputPath, JSON.parse(rawTx));
+            success({ txPath: outputPath });
+        }
+        catch (e) {
+            error(`Failed to build destroy transaction: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async buildUpdateDidKeyTx(args, newDidKey, outputPath) {
+        const signer = await getSigner();
+        if (!signer) {
+            error('No wallet found. Use "wallet new" or "wallet import" first.');
+            return;
+        }
+        try {
+            const address = await signer.getRecommendedAddressObj();
+            const { tx } = await ccc.didCkb.transferDidCkb({
+                client: signer.client,
+                id: args,
+                receiver: address.script,
+                data: (_, data) => {
+                    if (!data)
+                        throw new Error('data is undefined');
+                    const doc = data.value.document;
+                    if (!doc.verificationMethods)
+                        doc.verificationMethods = {};
+                    doc.verificationMethods.atproto = newDidKey;
+                    return data;
+                },
+            });
+            await tx.completeInputsByCapacity(signer);
+            await tx.completeFeeBy(signer);
+            const rawTx = ccc.stringify(tx);
+            await writeJsonFile(outputPath, JSON.parse(rawTx));
+            success({ txPath: outputPath });
+        }
+        catch (e) {
+            error(`Failed to build update didKey transaction: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async buildUpdateHandleTx(args, newHandle, outputPath) {
+        const signer = await getSigner();
+        if (!signer) {
+            error('No wallet found. Use "wallet new" or "wallet import" first.');
+            return;
+        }
+        try {
+            const address = await signer.getRecommendedAddressObj();
+            const parts = newHandle.split('.');
+            const pdsHost = parts.slice(1).join('.');
+            const serviceEndpoint = `https://${pdsHost}`;
+            const { tx } = await ccc.didCkb.transferDidCkb({
+                client: signer.client,
+                id: args,
+                receiver: address.script,
+                data: (_, data) => {
+                    if (!data)
+                        throw new Error('data is undefined');
+                    const doc = data.value.document;
+                    doc.alsoKnownAs = [`at://${newHandle}`];
+                    if (!doc.services)
+                        doc.services = {};
+                    if (!doc.services.atproto_pds)
+                        doc.services.atproto_pds = { type: 'AtprotoPersonalDataServer' };
+                    doc.services.atproto_pds.endpoint = serviceEndpoint;
+                    return data;
+                },
+            });
+            await tx.completeInputsByCapacity(signer);
+            await tx.completeFeeBy(signer);
+            const rawTx = ccc.stringify(tx);
+            await writeJsonFile(outputPath, JSON.parse(rawTx));
+            success({ txPath: outputPath });
+        }
+        catch (e) {
+            error(`Failed to build update handle transaction: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async buildTransferTx(args, receiver, outputPath) {
+        const signer = await getSigner();
+        if (!signer) {
+            error('No wallet found. Use "wallet new" or "wallet import" first.');
+            return;
+        }
+        try {
+            const receiverAddr = await ccc.Address.fromString(receiver.trim(), signer.client);
+            const { tx } = await ccc.didCkb.transferDidCkb({
+                client: signer.client,
+                id: args,
+                receiver: receiverAddr.script,
+            });
+            await tx.completeInputsByCapacity(signer);
+            await tx.completeFeeBy(signer);
+            const rawTx = ccc.stringify(tx);
+            await writeJsonFile(outputPath, JSON.parse(rawTx));
+            success({ txPath: outputPath });
+        }
+        catch (e) {
+            error(`Failed to build transfer transaction: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async list(ckbAddr) {
+        try {
+            const client = await getClient();
+            const address = await ccc.Address.fromString(ckbAddr, client);
+            const didScriptInfo = await client.getKnownScript(ccc.KnownScript.DidCkb);
+            const didCodeHash = didScriptInfo?.codeHash;
+            if (!didCodeHash) {
+                error('DidCkb script codeHash not found');
+                return;
+            }
+            const signer = await new ccc.SignerCkbScriptReadonly(client, address.script);
+            if (!signer) {
+                error('No wallet found. Use "wallet new" or "wallet import" first.');
+                return;
+            }
+            const cells = await signer.findCells({
+                script: {
+                    codeHash: didCodeHash,
+                    hashType: 'type',
+                    args: "0x",
+                },
+            }, true, 'desc', 10);
+            const result = [];
+            for await (const cell of cells) {
+                const txHash = cell.outPoint.txHash;
+                const index = Number(cell.outPoint.index);
+                try {
+                    const data = cell.outputData ?? '0x';
+                    const didData = ccc.didCkb.DidCkbData.decode(data);
+                    const didDoc = didData.value.document;
+                    const didMetadata = JSON.stringify(didDoc);
+                    if (!cell.cellOutput.type)
+                        throw new Error('cell.cellOutput.type is undefined');
+                    const args = ccc.bytesFrom(cell.cellOutput.type.args.slice(0, 42)); // 20 bytes Type args
+                    const did = `did:ckb:${base32.encode(args).toLowerCase()}`;
+                    result.push({
+                        txHash,
+                        index,
+                        capacity: ccc.fixedPointToString(cell.cellOutput.capacity),
+                        args: cell.cellOutput.type.args,
+                        did,
+                        didMetadata,
+                    });
+                }
+                catch (error) {
+                    console.error(`Error processing cell ${txHash}:${index}:`, error);
+                }
+            }
+            success(result);
+        }
+        catch (e) {
+            error(`Failed to list DID cells: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+};
+// Wrap methods that need process exit
+function exitAfter(fn) {
+    return async (...args) => {
+        try {
+            await fn(...args);
+        }
+        finally {
+            process.exit(0);
+        }
+    };
+}
+export const didManagerWithExit = {
+    buildCreateTx: exitAfter(didManager.buildCreateTx),
+    buildDestroyTx: exitAfter(didManager.buildDestroyTx),
+    buildUpdateDidKeyTx: exitAfter(didManager.buildUpdateDidKeyTx),
+    buildUpdateHandleTx: exitAfter(didManager.buildUpdateHandleTx),
+    buildTransferTx: exitAfter(didManager.buildTransferTx),
+    list: exitAfter(didManager.list),
+};

package/dist/utils/keystore.d.ts

@@ -0,0 +1,9 @@
+export interface KeystoreManager {
+    newKey(): Promise<void>;
+    importKey(sk: string): Promise<void>;
+    clean(): Promise<void>;
+    getDIDKey(): Promise<void>;
+    sign(message: string): Promise<void>;
+    verify(message: string, signature: string, didKey?: string): Promise<void>;
+}
+export declare const keystoreManager: KeystoreManager;

package/dist/utils/keystore.js

@@ -0,0 +1,94 @@
+import { SIGNKEY_PATH, keyExists, readKey, writeKey, removeKey, error, success, bytesFromHex, hexFromBytes } from './common.js';
+import { Secp256k1Keypair, verifySignature as verifySignatureAtproto } from '@atproto/crypto';
+export const keystoreManager = {
+    async newKey() {
+        if (keyExists(SIGNKEY_PATH)) {
+            error('Keypair already exists. Use "clean" first to remove it.');
+            return;
+        }
+        try {
+            const keypair = await Secp256k1Keypair.create({ exportable: true });
+            const exportedBytes = await keypair.export();
+            const privateKey = hexFromBytes(exportedBytes);
+            await writeKey(SIGNKEY_PATH, privateKey);
+            const didKey = keypair.did();
+            success(didKey);
+        }
+        catch (e) {
+            error(`Failed to create keypair: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async importKey(sk) {
+        if (keyExists(SIGNKEY_PATH)) {
+            error('Keypair already exists. Use "clean" first to remove it.');
+            return;
+        }
+        try {
+            const keypair = await Secp256k1Keypair.import(bytesFromHex(sk), { exportable: true });
+            await writeKey(SIGNKEY_PATH, sk);
+            const didKey = keypair.did();
+            success(didKey);
+        }
+        catch (e) {
+            error(`Failed to import key: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async clean() {
+        const result = await removeKey(SIGNKEY_PATH);
+        success(result);
+    },
+    async getDIDKey() {
+        const privateKey = await readKey(SIGNKEY_PATH);
+        if (!privateKey) {
+            error('No keypair found. Use "new" or "import" first.');
+            return;
+        }
+        try {
+            const keypair = await Secp256k1Keypair.import(bytesFromHex(privateKey));
+            success(keypair.did());
+        }
+        catch (e) {
+            error(`Failed to get DID key: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async sign(message) {
+        const privateKey = await readKey(SIGNKEY_PATH);
+        if (!privateKey) {
+            error('No keypair found. Use "new" or "import" first.');
+            return;
+        }
+        try {
+            const keypair = await Secp256k1Keypair.import(bytesFromHex(privateKey));
+            const messageBytes = bytesFromHex(message);
+            const signature = await keypair.sign(messageBytes);
+            success(hexFromBytes(signature));
+        }
+        catch (e) {
+            error(`Failed to sign message: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    },
+    async verify(message, signature, didKey) {
+        try {
+            let pubDidKey;
+            if (didKey) {
+                pubDidKey = didKey;
+            }
+            else {
+                const privateKey = await readKey(SIGNKEY_PATH);
+                if (!privateKey) {
+                    error('No keypair found and no didKey provided.');
+                    return;
+                }
+                const keypair = await Secp256k1Keypair.import(bytesFromHex(privateKey));
+                pubDidKey = keypair.did();
+            }
+            const messageBytes = bytesFromHex(message);
+            const signatureBytes = bytesFromHex(signature);
+            const verified = await verifySignatureAtproto(pubDidKey, messageBytes, signatureBytes);
+            success(verified);
+        }
+        catch (e) {
+            success(false);
+        }
+    }
+};

package/dist/utils/pds.d.ts

@@ -0,0 +1,53 @@
+export type userInfo = {
+    accessJwt: string;
+    refreshJwt: string;
+    handle: string;
+    did: string;
+};
+export type sessionInfo = {
+    accessJwt: string;
+    refreshJwt: string;
+    handle: string;
+    did: string;
+    didMetadata: string;
+};
+export type RepoInfo = {
+    handle: string;
+    did: string;
+    didDoc: {
+        verificationMethods: Record<string, string>;
+        alsoKnownAs: string[];
+        services: Record<string, {
+            type: string;
+            endpoint: string;
+        }>;
+    };
+    collections: string[];
+    handleIsCorrect: boolean;
+};
+export type RepoRecords = {
+    cursor?: string;
+    records: {
+        uri: string;
+        cid: string;
+        value: Record<string, any>;
+    }[];
+};
+export type RepoBlobs = {
+    cursor?: string;
+    cids: string[];
+};
+export interface PdsManager {
+    checkUsername(username: string): Promise<void>;
+    getDidByUsername(username: string, pds: string): Promise<void>;
+    createAccount(pds: string, username: string, didKey: string, did: string, ckbAddress: string, signKey: string): Promise<void>;
+    deleteAccount(pds: string, didKey: string, did: string, ckbAddress: string, signKey: string): Promise<void>;
+    login(pds: string, didKey: string, did: string, ckbAddress: string, signKey: string): Promise<void>;
+    write(pds: string, accessJwt: string, didKey: string, did: string, data: string, signKey: string, rkey?: string, type?: 'update' | 'create' | 'delete'): Promise<void>;
+    repo(pds: string, did: string): Promise<void>;
+    records(pds: string, did: string, collection: string, limit?: number, cursor?: string): Promise<void>;
+    blobs(pds: string, did: string, limit?: number, cursor?: string): Promise<void>;
+    exportRepo(pds: string, did: string, dataFile: string, since?: string): Promise<void>;
+    importRepo(pds: string, did: string, accessJwt: string, dataFile: string): Promise<void>;
+}
+export declare const pdsManager: PdsManager;