@ckbfs/api 2.0.18 → 2.0.19

package/dist/utils/transactions/v3.js

@@ -222,7 +222,7 @@ async function prepareAppendV3Transaction(options) {
     const combinedContent = Buffer.concat(contentChunks);
     const newChecksum = await (0, checksum_1.updateChecksum)(previousChecksum, combinedContent);
     // Calculate the actual witness indices where our content is placed
-    const contentStartIndex = witnessStartIndex || from?.witnesses.length || 1;
+    const contentStartIndex = witnessStartIndex || from?.witnesses.length || 0;
     // Create CKBFS v3 witnesses with backlink info
     const ckbfsWitnesses = (0, witness_1.createChunkedCKBFSV3Witnesses)(contentChunks, {
         previousTxHash,

package/examples/nervape.ts

@@ -0,0 +1,503 @@
+import fs from "fs"
+import path, { parse } from 'path';
+import { 
+  CKBFS, 
+  NetworkType, 
+  CKBFSDataType, 
+  ProtocolVersion,
+  CKBFSData,
+  getFileContentFromChain,
+  getCKBFSScriptConfig,
+  extractCKBFSV3WitnessContent,
+  isCKBFSV3Witness,
+  resolveCKBFSCell,
+  createAppendV3Transaction
+} from '../src';
+import { 
+  Script, 
+  Address, 
+  ClientPublicTestnet, 
+  ClientPublicMainnet, 
+  Transaction,
+  ccc
+} from "@ckb-ccc/core";
+import { 
+  transferSpore
+} from "@ckb-ccc/spore";
+//import { isMainnet, network, CKB_PRIVATE_KEY } from "../config"
+
+const isMainnet = false
+const CKB_PRIVATE_KEY = "0x1733e6f7825f99eb41ca26f8569fa90c2cb8c5ae199bbd38a97562291f784983"
+
+const network = isMainnet ? NetworkType.Mainnet : NetworkType.Testnet
+const client = isMainnet ? new ClientPublicMainnet() : new ClientPublicTestnet()
+
+export const TestnetTraceLockDep = {
+  outPoint: {
+    // txHash: "0xb60c07715089877b238a60559ff4c15b46991ddcf1cfd2f9a40c32d6fff668ee",
+    txHash: "0x7a3e492188438ca4b260fed0f7a00d18ec9e4671a8c3b54fc2b3b49447ab2e2f",
+    index: 0x0,
+  },
+  depType: "code",
+}
+
+export const MainnetTraceLockDep = {
+  outPoint: {
+    txHash: "0xd00a0222a12ae202d68fa4e90650ba560b325a3707c901395966a191372c47f7",
+    index: 0x0,
+  },
+  depType: "code",
+}
+
+export const TestnetShadowDep = {
+  outPoint: {
+    txHash: "0x2d8a311a55e42d7d6810610149f6e125f0d292112f8ed4a21177aec05da2b905",
+    index: 0x0,
+  },
+  depType: "code",
+}
+
+export const MainnetShadowDep = {
+  outPoint: {
+    txHash: "0x5b20ec7d7d5c6410ac4924c57d1eac1dd50129b6263be3dc93055397b5724dc2",
+    index: 0x0,
+  },
+  depType: "code",
+}
+
+
+const TraceLockDep = isMainnet ? MainnetTraceLockDep : TestnetTraceLockDep
+const ShadowDep = isMainnet ? MainnetShadowDep : TestnetShadowDep
+
+const TraceLogCodeHash = "0xbd7e56daaa4cc9ecf488a50d2f4db2a55a7c86eb2df2157d24a62be9be5b34ab"
+const ShadowSporeCodeHash = "0x6361d4b20d845953d9c9431bbba08905573005a71e2a2432e7e0e7c685666f24"
+
+const ckbfs = new CKBFS(
+  CKB_PRIVATE_KEY,
+  isMainnet ? NetworkType.Mainnet : NetworkType.Testnet,
+  {
+    version: ProtocolVersion.V3,
+    chunkSize: 30 * 1024, // 30KB chunks
+    useTypeID: false // Use code hash instead of type ID
+  }
+);
+
+async function getAddressScriptHash(addr: string | Address) {
+  if (typeof addr === 'string') {
+    addr = await Address.fromString(addr, client)
+    console.log("addr=", addr)
+  }
+  return `0x03${addr.script.hash().slice(2)}`
+}
+
+export async function mint(physicalArtifactNo: string) {
+  // Get address info
+  const address = await ckbfs.getAddress();
+  const ownerHash = await getAddressScriptHash(address)
+  
+  const content = `MINT,TO:${ownerHash}\n`
+
+  // You can provide additional options
+  const options = {
+    contentType: 'text/plain',
+    filename: `${physicalArtifactNo}.LOGS`,
+  };
+  const tx = await ckbfs.createPublishContentTransaction(content, options);
+  const signer = ckbfs['signer']
+  const txHash = await signer.sendTransaction(tx)
+  const ckbfsId = tx.outputs[0].type?.args.toString()
+  return { txHash, log: content, ckbfsId };
+}
+
+export async function claim(to: string, sporeId: string, ckbfsId: string) {
+  const from = await ckbfs.getAddress();
+  const ckbfsCell = await getCkbfsCellInfo(ckbfsId);
+  console.log("ckbfsCell=", ckbfsCell)
+  const fromHash = await getAddressScriptHash(from)
+  const toHash = await getAddressScriptHash(to)
+
+  const content = `TRANSFER,FROM:${fromHash},TO:${toHash}\n`
+
+  const tx = await ckbfs.createAppendContentTransaction(content, ckbfsCell);
+
+  tx.addCellDeps(TraceLockDep)
+
+  const sizeBefore = tx.outputs[0].lock.occupiedSize
+  const traceLogLock = Script.from({
+    codeHash: TraceLogCodeHash,
+    hashType: "type",
+    args: toHash
+  })
+  tx.outputs[0].lock = traceLogLock
+  const sizeAfter = traceLogLock.occupiedSize
+  
+  const diffSize = BigInt(sizeAfter - sizeBefore) * BigInt(100000000)
+  tx.outputs[0].capacity = tx.outputs[0].capacity + diffSize
+  
+  const sporeLockArgs = `0x01${ tx.outputs[0].type?.hash().slice(2) }`
+  const newSporeLock = Script.from({
+    codeHash: ShadowSporeCodeHash,
+    args: sporeLockArgs,
+    hashType: "data1",
+  })
+
+  tx.outputs = [
+    tx.outputs[0]
+  ]
+
+  const signer = ckbfs['signer']
+  const sporeTx = await transferSpore({
+    signer: signer as any,
+    id: sporeId,
+    to: newSporeLock,
+    tx: tx,
+  })
+
+  tx.addCellDeps(ShadowDep)
+
+  const finalTx = sporeTx.tx
+  await finalTx.completeFeeBy(signer as any)
+  console.log("finalTx=", finalTx)
+  const txHash = await signer.sendTransaction(finalTx)
+  console.log(`File appended successfully! Transaction Hash: ${txHash}`);
+  return { txHash, log: content }
+}
+
+export async function giveName(name: string, ckbfsId: string) {
+  const ckbfsCell = await getCkbfsCellInfo(ckbfsId)
+  const content = `GIVE_NAME,NEW_NAME:${name}\n`
+
+  console.log("ckbfsCell=", ckbfsCell)
+  
+  const signer = ckbfs['signer']
+  let tx = await ckbfs.createAppendContentTransaction(content, ckbfsCell);
+  tx.addCellDeps(TraceLockDep)
+
+  
+  parseCkbfsData(tx.outputsData[0])
+  
+  
+  //tx.witnesses = tx.witnesses.reverse()
+  // tx.witnesses[0] = '0x'
+  // tx.witnesses[0] = tx.witnesses[0]
+
+  console.log("tx=", tx)
+
+  tx = await signer.signTransaction(tx)
+
+  console.log("signed tx=", tx)
+  // await signer.sendTransaction(tx)
+  const txHash = await signer.sendTransaction(tx)
+  console.log(`File appended successfully! Transaction Hash: ${txHash}`);
+  return { txHash, log: content }
+}
+
+export async function transfer(to: string, ckbfsId: string) {
+  const ckbfsCell = await getCkbfsCellInfo(ckbfsId)
+  const from = await ckbfs.getAddress();
+  const fromHash = await getAddressScriptHash(from)
+  const toHash = await getAddressScriptHash(to)
+  const content = `TRANSFER,FROM:${fromHash},TO:${toHash}\n`
+  
+  const signer = ckbfs['signer']
+  let tx = await ckbfs.createAppendContentTransaction(content, ckbfsCell);
+  tx.outputs[0].lock.args = toHash as `0x{string}`;
+  // tx.addCellDeps(TestnetTraceLockDep)
+  const txHash = await signer.sendTransaction(tx)
+  console.log(`File appended successfully! Transaction Hash: ${txHash}`);
+
+  return { txHash, log: content };
+}
+
+// export async function release(from: string, ckbfsId: string) {
+//   const ckbfsCell = await await getCkbfsCellInfo(ckbfsId)
+//   const fromHash = await getAddressScriptHash(from)
+//   const content = `RELEASE,FROM:${fromHash}\n`
+//   const signer = ckbfs['signer']
+//   let tx = await ckbfs.createAppendContentTransaction(content, ckbfsCell);
+ 
+//   tx.addCellDeps(TestnetTraceLockDep)
+//   const txHash = await signer.sendTransaction(tx)
+//   console.log(`File appended successfully! Transaction Hash: ${txHash}`);
+//   return { txHash, log: content };
+// }
+
+// export async function retrieveLogsFromChain(ckbfsId: string) {
+//   const { outPoint, data } = await getCkbfsCellInfo(ckbfsId)
+//   const content = await getFileContentFromChain(client, outPoint, data)
+//   const logs = content.toString().trim().split("\n")
+//   return logs
+// }
+
+export async function getCkbfsCellInfo(ckbfsId: string) {
+  const { codeHash, hashType } = getCKBFSScriptConfig(isMainnet ? NetworkType.Mainnet : NetworkType.Testnet, ProtocolVersion.V3)
+  console.log("codeHash, hashType=", codeHash, hashType, ckbfsId)
+  const cell = await client.findSingletonCellByType({
+    codeHash,
+    hashType,
+    args: ckbfsId
+  }, true)
+
+  if (!cell || !cell.cellOutput.type) {
+    throw new Error('No CKBFS cell found');
+  }
+
+  const rawData = cell.outputData.startsWith('0x')
+    ? Buffer.from(cell.outputData.slice(2), 'hex')
+    : Buffer.from(cell.outputData, 'hex');
+
+  const ckbfsData = CKBFSData.unpack(rawData, ProtocolVersion.V3)
+
+  return {
+    outPoint: { txHash: cell.outPoint.txHash as string, index: Number(cell.outPoint.index) },
+    type: cell.cellOutput.type,
+    lock: cell.cellOutput.lock,
+    capacity: cell.cellOutput.capacity,
+    data: ckbfsData,
+  };
+}
+
+
+export function getCkbfsList() {
+  const file = path.join(__dirname, `./data/${isMainnet ? 'mainnet' : 'testnet'}/ckbfs-list-x3.json`)
+  return JSON.parse(fs.readFileSync(file).toString())
+}
+
+export async function mintAll() {
+  const ckbfsList = getCkbfsList()
+  for(const no of ckbfsList) {
+    const { txHash, ckbfsId } = await mint(no)
+    console.log(`minted ckbfs no=${no}, ckbfsId=${ckbfsId}, txHash=${txHash}`);
+
+    const interval = setInterval(async () => {
+      try {
+        const tx = await client.getTransaction(txHash)
+        if (tx && tx.status === 'committed') {
+          clearInterval(interval)
+          console.info(`tx confirmed, https://explorer.nervos.org/transaction/${txHash}`);
+        }
+      } catch (error) {
+        console.error(error)
+      }
+    }, 5 * 1000)
+  }
+}
+
+async function getCellInfoFromV3Transaction(txHash: string): Promise<{ 
+  outPoint: { txHash: string; index: number };
+  type: Script; 
+  data: CKBFSDataType;
+  lock: Script;
+  capacity: bigint;
+  previousTxHash: string;
+  previousWitnessIndex: number;
+  previousChecksum: number;
+}> {
+  console.log(`Retrieving v3 transaction data for: ${txHash}`);
+  
+  try {
+    // Get transaction from RPC
+    const txWithStatus = await client.getTransaction(txHash);
+    if (!txWithStatus || !txWithStatus.transaction) {
+      throw new Error(`Transaction ${txHash} not found`);
+    }
+    
+    const tx = Transaction.from(txWithStatus.transaction);
+    console.log(`Transaction found with ${tx.outputs.length} outputs`);
+    
+    // Find the CKBFS cell output (first output with type script)
+    let ckbfsCellIndex = 0;
+    const output = tx.outputs[ckbfsCellIndex];
+    if (!output || !output.type) {
+      throw new Error('No CKBFS cell found in the transaction');
+    }
+    
+    console.log(`Found CKBFS v3 cell at index ${ckbfsCellIndex}`);
+    console.log(`Cell type script hash: ${output.type.hash()}`);
+    
+    // Get output data
+    const outputData = tx.outputsData[ckbfsCellIndex];
+    if (!outputData) {
+      throw new Error('Output data not found');
+    }
+    
+    // Parse the output data as CKBFS v3 data
+    const rawData = outputData.startsWith('0x') 
+      ? ccc.bytesFrom(outputData.slice(2), 'hex')
+      : Buffer.from(outputData, 'hex');
+    
+    // Unpack the raw data using v3 format
+    const version = ProtocolVersion.V3;
+    console.log(`Using protocol version ${version} for unpacking v3 cell data`);
+    
+    let ckbfsData: CKBFSDataType;
+    try {
+      ckbfsData = CKBFSData.unpack(rawData, version);
+      
+      console.log('Successfully unpacked CKBFS v3 cell data:');
+      console.log(`- Checksum: ${ckbfsData.checksum}`);
+      console.log(`- File: ${ckbfsData.filename}`);
+      console.log(`- Content Type: ${ckbfsData.contentType}`);
+      console.log(`- Index: ${ckbfsData.index}`);
+    } catch (error) {
+      console.error('Error unpacking CKBFS v3 data:', error);
+      throw new Error(`Failed to unpack CKBFS v3 data: ${error}`);
+    }
+    
+    // Extract backlink information from v3 witness
+    let previousTxHash = '0x' + '00'.repeat(32);
+    let previousWitnessIndex = 0;
+    let previousChecksum = 0;
+    
+    if (ckbfsData.index !== undefined && ckbfsData.index < tx.witnesses.length) {
+      const witnessHex = tx.witnesses[ckbfsData.index];
+      const witness = Buffer.from(witnessHex.slice(2), 'hex');
+      
+      if (isCKBFSV3Witness(witness)) {
+        try {
+          const witnessData = extractCKBFSV3WitnessContent(witness, true);
+          previousTxHash = witnessData.previousTxHash || previousTxHash;
+          previousWitnessIndex = witnessData.previousWitnessIndex || 0;
+          previousChecksum = witnessData.previousChecksum || 0;
+          
+          console.log('Extracted v3 backlink information:');
+          console.log(`- Previous TX Hash: ${previousTxHash}`);
+          console.log(`- Previous Witness Index: ${previousWitnessIndex}`);
+          console.log(`- Previous Checksum: ${previousChecksum}`);
+        } catch (error) {
+          console.warn('Could not extract backlink info from witness:', error);
+        }
+      }
+    }
+    
+    return {
+      outPoint: {
+        txHash,
+        index: ckbfsCellIndex
+      },
+      type: output.type,
+      lock: output.lock,
+      capacity: output.capacity,
+      data: ckbfsData,
+      previousTxHash,
+      previousWitnessIndex,
+      previousChecksum
+    };
+  } catch (error) {
+    console.error('Error retrieving v3 transaction data:', error);
+    throw new Error(`Failed to retrieve or parse v3 cell data: ${error}`);
+  }
+}
+
+export async function getCkbfsTxContent(txHash: string, index = 0) {
+  const tx = await client.getTransaction(txHash);
+  const {
+    transaction,
+    status: txStatus,
+    blockNumber,
+  } = tx!;
+
+  let timestamp: number = 0;
+  if (txStatus === 'committed') {
+    const header = await client.getHeaderByNumber(blockNumber!);
+    timestamp = Number(header?.timestamp);
+  }
+  const toAddress = Address.fromScript(
+    transaction.outputs[0].lock,
+    client,
+  ).toString();
+  const outputData = transaction.outputsData[index];
+
+  const rawData = outputData.startsWith('0x')
+    ? Buffer.from(outputData.slice(2), 'hex')
+    : Buffer.from(outputData, 'hex');
+  const ckbfsData = CKBFSData.unpack(rawData as any, ProtocolVersion.V3);
+  const contentChunks = [];
+
+  // const indexes =
+  //   ckbfsData.indexes ||
+  //   (ckbfsData.index !== undefined ? [ckbfsData.index] : []);
+  // if (indexes.length > 0) {
+  //   // Get content from each witness index
+  //   for (const idx of indexes) {
+  //     if (idx >= transaction.witnesses.length) {
+  //       console.warn(`Witness index ${idx} out of range`);
+  //       continue;
+  //     }
+  //     const witnessHex = transaction.witnesses[idx];
+  //     const witness = Buffer.from(witnessHex.slice(2), 'hex'); // Remove 0x prefix
+  //     // Extract content (skip CKBFS header + version byte)
+  //     if (witness.length >= 6 && witness.slice(0, 5).toString() === 'CKBFS') {
+  //       const content = witness.slice(6);
+  //       contentChunks.push(content); // Add to beginning of array (we're going backwards)
+  //     } else {
+  //       console.warn(`Witness at index ${idx} is not a valid CKBFS witness`);
+  //     }
+  //   }
+  // }
+  const witnessHex = transaction.witnesses[ckbfsData.index!];
+  const witness = Buffer.from(witnessHex.slice(2), 'hex');
+  const witnessData = extractCKBFSV3WitnessContent(new Uint8Array(witness), true);
+
+  // const witnessData = extractCKBFSV3WitnessContent(witness as any, true);
+
+  console.log("witnessData=", witnessData)
+  console.log("content=", Buffer.from(witnessData.content).toString())
+
+  const ckbfsId = transaction.outputs[0].type?.args.toString();
+
+  // const content = Buffer.concat(contentChunks).toString().trim();
+  return {
+    data: ckbfsData,
+    toAddress,
+    content: "",
+    ckbfsId,
+    txStatus,
+    committedAt: timestamp,
+  };
+}
+
+function parseCkbfsData(outputData: string){
+  // const outputData = "0x4500000014000000180000001c0000002a000000010000002614cb020a000000746578742f706c61696e170000003358303132354e4d4e5641503030303130312e4c4f4753"
+  // const outputData = "0x4500000014000000180000001c0000002a000000010000009443df5b0a000000746578742f706c61696e170000003358303132354e4d4e5641503030303130322e4c4f4753"
+  const rawData = outputData.startsWith('0x')
+    ? Buffer.from(outputData.slice(2), 'hex')
+    : Buffer.from(outputData, 'hex');
+  const ckbfsData = CKBFSData.unpack(rawData as any, ProtocolVersion.V3);
+  console.log(ckbfsData)
+}
+
+
+// mintAll()
+
+// mint("3X0125NMNVAP000102").then(console.log)
+
+// claim("ckt1qyqtaymen8quq9r3sf7x20uuq4pl5t8r4x8qqunj4q", 
+//   "0x2b3cbd4c86a42e3ea1d092daab2f213e1600203906f33645f825159e1071d1e4", // sporeId
+//   "0x33fd0f19f411eec7cc84d32577a015612afc00cd008225a2ed34a8fda475e498" // ckbfsId
+// );
+
+// getCellInfoFromV3Transaction("0x54c86dbdc6bdafb4616221d54cfc0ff186a4a772eba509838684f8e1ea271b40").then(console.log)
+
+// parseCkbfsData()
+
+giveName(
+  "aaa", 
+  "0x33fd0f19f411eec7cc84d32577a015612afc00cd008225a2ed34a8fda475e498" // ckbfsId
+).then(console.log)
+
+// transfer(
+//   "ckt1qyqtaymen8quq9r3sf7x20uuq4pl5t8r4x8qqunj4q", 
+//   "0xe58baa82c4844add60911bb890487fea3c45436b9d7b203cc1065301d0a9c503"
+// ).then(console.log)
+
+// getCkbfsCellInfo("0x52315569e5ff0d6d6392f047fcbea97bae1b32b688c29aca5251a157157278d3").then((data) => {
+//   console.log("ckbfs data=", data)
+// })
+
+// getCkbfsTxContent("0xecc76092e301d15a808ee91570bc8c71ea448d17e9dc186c699db716878f116a").then(console.log)
+// getCellInfoFromV3Transaction("0x8dc79a7630145e2a220e2363beca2781c6a4f0f79ef7a01ab73f17dc90571fb7").then(console.log)
+
+// getCkbfsCellInfo("0x0084106b9bea08f512e35b725c4a710ebf09cb65c05601ebde8d911bc6c662bf").then(console.log)
+
+// testReresolve("0x0084106b9bea08f512e35b725c4a710ebf09cb65c05601ebde8d911bc6c662bf").then(console.log)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ckbfs/api",
-  "version": "2.0.18",
+  "version": "2.0.19",
   "description": "SDK for CKBFS protocol on CKB",
   "license": "MIT",
   "author": "Code Monad<code@lab-11.org>",
@@ -29,7 +29,7 @@
     "sdk"
   ],
   "devDependencies": {
-    "@ckb-ccc/spore": "^1.5.5",
+    "@ckb-ccc/spore": "1.5.5",
     "@types/jest": "^29.5.12",
     "@types/node": "^22.7.9",
     "jest": "^29.7.0",

package/src/index.ts

@@ -712,6 +712,8 @@ export class CKBFS {
         ckbfsCell.data.index !== undefined && 
         ckbfsCell.data.checksum !== undefined) {
       
+      
+      
       return createAppendV3Transaction(this.signer, {
         ckbfsCell,
         contentChunks,

package/src/utils/transactions/v3.ts

@@ -366,7 +366,7 @@ export async function prepareAppendV3Transaction(
   const newChecksum = await updateChecksum(previousChecksum, combinedContent);
 
   // Calculate the actual witness indices where our content is placed
-  const contentStartIndex = witnessStartIndex || from?.witnesses.length || 1;
+  const contentStartIndex = witnessStartIndex || from?.witnesses.length ||  0;
 
   // Create CKBFS v3 witnesses with backlink info
   const ckbfsWitnesses = createChunkedCKBFSV3Witnesses(contentChunks, {