@iqlabs-official/git-sdk 0.1.12 → 0.1.15

package/dist/chunk-EZNMA5NJ.js

@@ -0,0 +1,635 @@
+import { IQGIT_ROOT_ID, commitTableHint, notifyGateways, repoListHint, pagesDeployId, IQPAGES_CONFIG_FILENAME, IQPAGES_DEPLOYED_HINT, setSolanaGatewayNetwork, REGISTRY_HINT, IQPAGES_ROOT_ID, readCodeInViaGateway, readRowsViaGateway, IQPAGES_PROFILE_FILENAME, PAGES_FEE_WEI, PAGES_FEE_RECIPIENT_EVM, PAGES_FEE_LAMPORTS, PAGES_FEE_RECIPIENT, setEthGatewayNetwork } from './chunk-WHYUXIRW.js';
+import { setRpcUrl } from '@iqlabs-official/solana-sdk';
+import { Transaction, SystemProgram, PublicKey, Keypair } from '@solana/web3.js';
+import { getDbRootPda, createInstructionBuilder, initializeDbRootInstruction, getTablePda } from '@iqlabs-official/solana-sdk/contract';
+import { readCodeIn as readCodeIn$1, readTableRows } from '@iqlabs-official/solana-sdk/reader';
+import { toSeedBytes } from '@iqlabs-official/solana-sdk/utils';
+export { DEFAULT_SESSION_SPEED, SESSION_SPEED_PROFILES, resolveSessionSpeed } from '@iqlabs-official/solana-sdk/utils';
+import { writeRow as writeRow$1, createTable as createTable$1, codeIn as codeIn$1 } from '@iqlabs-official/solana-sdk/writer';
+
+// src/core/hash.ts
+var impl;
+function setSha256(fn) {
+  if (impl) {
+    throw new Error(
+      "@iqlabs-official/git-sdk: sha256 implementation already installed. Import exactly one of '@iqlabs-official/git-sdk/node' or '@iqlabs-official/git-sdk/browser'."
+    );
+  }
+  impl = fn;
+}
+async function sha256Hex(input) {
+  if (!impl) {
+    throw new Error(
+      "@iqlabs-official/git-sdk: sha256 not installed. Import '@iqlabs-official/git-sdk/node' (Node) or '@iqlabs-official/git-sdk/browser' (browser) before using the SDK."
+    );
+  }
+  return impl(input);
+}
+var DB_ROOT_SEED = toSeedBytes(IQGIT_ROOT_ID);
+var DB_ROOT = getDbRootPda(DB_ROOT_SEED);
+var connection = null;
+function conn() {
+  if (!connection) {
+    throw new Error("solana adapter not initialized \u2014 call init({ chain: 'solana', connection })");
+  }
+  return connection;
+}
+function asSolana(signer) {
+  return signer;
+}
+async function signTx(signer, tx) {
+  if (signer instanceof Keypair || "secretKey" in signer) {
+    tx.partialSign(signer);
+    return tx;
+  }
+  return signer.signTransaction(tx);
+}
+function dbRootPda(dbRootId) {
+  return dbRootId === IQGIT_ROOT_ID ? DB_ROOT : getDbRootPda(toSeedBytes(dbRootId));
+}
+function tablePda(hint, dbRootId = IQGIT_ROOT_ID) {
+  return getTablePda(dbRootPda(dbRootId), toSeedBytes(hint));
+}
+async function accountExists(pda) {
+  return await conn().getAccountInfo(pda) !== null;
+}
+async function readRowsByPda(pda, options) {
+  const viaGateway = await readRowsViaGateway(pda.toBase58(), options);
+  if (viaGateway !== null) return viaGateway;
+  return readTableRows(pda, options);
+}
+var solanaAdapter = {
+  kind: "solana",
+  init(cfg) {
+    if (cfg.chain !== "solana") return;
+    connection = cfg.connection;
+  },
+  async codeIn(signer, data, filename, filetype, onProgress, speed = "light") {
+    return codeIn$1(
+      { connection: conn(), signer: asSolana(signer) },
+      data,
+      filename,
+      0,
+      filetype,
+      onProgress,
+      speed
+    );
+  },
+  async readCodeIn(txSig) {
+    const viaGateway = await readCodeInViaGateway(txSig);
+    if (viaGateway !== null) return viaGateway;
+    return readCodeIn$1(txSig);
+  },
+  async readRows(hint, options) {
+    return readRowsByPda(tablePda(hint), options);
+  },
+  async readRowsByRef(ref, options) {
+    return readRowsByPda(ref, options);
+  },
+  async readLatestRow(hint) {
+    const rows = await this.readRows(hint, { limit: 1 });
+    return rows[0] ?? null;
+  },
+  async signerAddress(signer) {
+    return asSolana(signer).publicKey.toBase58();
+  },
+  async ensureDbRoot(signer, dbRootId = IQGIT_ROOT_ID) {
+    const s = asSolana(signer);
+    const rootPda = dbRootPda(dbRootId);
+    if (await accountExists(rootPda)) return null;
+    const builder = createInstructionBuilder();
+    const ix = initializeDbRootInstruction(
+      builder,
+      {
+        db_root: rootPda,
+        signer: s.publicKey,
+        system_program: SystemProgram.programId
+      },
+      { db_root_id: toSeedBytes(dbRootId) }
+    );
+    const tx = new Transaction().add(ix);
+    const c = conn();
+    const { blockhash, lastValidBlockHeight } = await c.getLatestBlockhash();
+    tx.recentBlockhash = blockhash;
+    tx.feePayer = s.publicKey;
+    const signed = await signTx(s, tx);
+    const signature = await c.sendRawTransaction(signed.serialize());
+    await c.confirmTransaction({ signature, blockhash, lastValidBlockHeight });
+    return signature;
+  },
+  async createTable(signer, hint, columns, idColumn, options) {
+    const s = asSolana(signer);
+    const writers = options?.writers?.map((w) => new PublicKey(w));
+    return createTable$1(
+      conn(),
+      s,
+      options?.dbRootId ?? IQGIT_ROOT_ID,
+      hint,
+      hint,
+      columns,
+      idColumn,
+      [],
+      void 0,
+      writers,
+      hint
+    );
+  },
+  async writeRow(signer, hint, rowJson, dbRootId = IQGIT_ROOT_ID) {
+    return writeRow$1(conn(), asSolana(signer), dbRootId, hint, rowJson);
+  },
+  async transferNative(signer, to, amount) {
+    const s = asSolana(signer);
+    const c = conn();
+    const tx = new Transaction().add(
+      SystemProgram.transfer({
+        fromPubkey: s.publicKey,
+        toPubkey: new PublicKey(to),
+        lamports: Number(amount)
+      })
+    );
+    tx.feePayer = s.publicKey;
+    const { blockhash, lastValidBlockHeight } = await c.getLatestBlockhash();
+    tx.recentBlockhash = blockhash;
+    const signed = await signTx(s, tx);
+    const signature = await c.sendRawTransaction(signed.serialize());
+    await c.confirmTransaction(
+      { signature, blockhash, lastValidBlockHeight },
+      "confirmed"
+    );
+    return signature;
+  },
+  async tableExists(hint, dbRootId = IQGIT_ROOT_ID) {
+    return accountExists(tablePda(hint, dbRootId));
+  },
+  tableRef(hint, dbRootId = IQGIT_ROOT_ID) {
+    return tablePda(hint, dbRootId);
+  },
+  tableKey(hint, dbRootId = IQGIT_ROOT_ID) {
+    return tablePda(hint, dbRootId).toBase58();
+  }
+};
+
+// src/layers/chain/eth-lazy.ts
+var real = null;
+var pending = null;
+async function load() {
+  if (!real) {
+    real = (await import('./eth-BQ57E7OY.js')).ethAdapter;
+    if (pending) real.init(pending);
+  }
+  return real;
+}
+var ethAdapter = {
+  kind: "eth",
+  init(cfg) {
+    pending = cfg;
+    if (cfg.chain === "eth") setEthGatewayNetwork(cfg.network);
+    if (real) real.init(cfg);
+  },
+  async codeIn(signer, data, filename, filetype, onProgress, speed) {
+    return (await load()).codeIn(signer, data, filename, filetype, onProgress, speed);
+  },
+  async readCodeIn(txId) {
+    return (await load()).readCodeIn(txId);
+  },
+  async readRows(hint, options) {
+    return (await load()).readRows(hint, options);
+  },
+  async readRowsByRef(ref, options) {
+    return (await load()).readRowsByRef(ref, options);
+  },
+  async readLatestRow(hint) {
+    return (await load()).readLatestRow(hint);
+  },
+  async signerAddress(signer) {
+    return (await load()).signerAddress(signer);
+  },
+  async ensureDbRoot(signer, dbRootId) {
+    return (await load()).ensureDbRoot(signer, dbRootId);
+  },
+  async createTable(signer, hint, columns, idColumn, options) {
+    return (await load()).createTable(signer, hint, columns, idColumn, options);
+  },
+  async writeRow(signer, hint, rowJson, dbRootId) {
+    return (await load()).writeRow(signer, hint, rowJson, dbRootId);
+  },
+  async transferNative(signer, to, amount) {
+    return (await load()).transferNative(signer, to, amount);
+  },
+  async tableExists(hint, dbRootId) {
+    return (await load()).tableExists(hint, dbRootId);
+  },
+  // Sync — same coordinates the real adapter returns, no ethereum-sdk needed.
+  tableRef(hint, dbRootId = IQGIT_ROOT_ID) {
+    return { dbRootId, tableName: hint };
+  },
+  tableKey(hint) {
+    return hint;
+  }
+};
+
+// src/layers/chain/index.ts
+var active = solanaAdapter;
+function setChain(kind) {
+  active = kind === "eth" ? ethAdapter : solanaAdapter;
+}
+function initChain(cfg) {
+  active.init(cfg);
+}
+function activeChain() {
+  return active.kind;
+}
+function codeIn(signer, data, filename, filetype, onProgress, speed) {
+  return active.codeIn(signer, data, filename, filetype, onProgress, speed);
+}
+function readCodeIn(txId) {
+  return active.readCodeIn(txId);
+}
+function readRows(hint, options) {
+  return active.readRows(hint, options);
+}
+function readRowsByRef(ref, options) {
+  return active.readRowsByRef(ref, options);
+}
+function signerAddress(signer) {
+  return active.signerAddress(signer);
+}
+function ensureDbRoot(signer, dbRootId) {
+  return active.ensureDbRoot(signer, dbRootId);
+}
+function createTable(signer, hint, columns, idColumn, options) {
+  return active.createTable(signer, hint, columns, idColumn, options);
+}
+function writeRow(signer, hint, rowJson, dbRootId) {
+  return active.writeRow(signer, hint, rowJson, dbRootId);
+}
+function transferNative(signer, to, amount) {
+  return active.transferNative(signer, to, amount);
+}
+function tableExists(hint, dbRootId) {
+  return active.tableExists(hint, dbRootId);
+}
+function tableRef(hint, dbRootId) {
+  return active.tableRef(hint, dbRootId);
+}
+function tableKey(hint, dbRootId) {
+  return active.tableKey(hint, dbRootId);
+}
+
+// src/layers/commit.ts
+var COMMIT_COLUMNS = [
+  "id",
+  "message",
+  "treeTxId",
+  "parentCommitId",
+  "timestamp",
+  "author"
+];
+async function ensureCommitTable(signer, repo) {
+  await ensureDbRoot(signer);
+  const owner = await signerAddress(signer);
+  const hint = commitTableHint(owner, repo);
+  if (await tableExists(hint)) return null;
+  return createTable(signer, hint, COMMIT_COLUMNS, "id", { writers: [owner] });
+}
+async function writeCommit(signer, repo, commit) {
+  const owner = await signerAddress(signer);
+  const hint = commitTableHint(owner, repo);
+  const sig = await writeRow(signer, hint, JSON.stringify(commit));
+  notifyGateways(tableKey(hint), sig, commit, owner);
+  return sig;
+}
+function commitTableRef(owner, repo) {
+  return tableRef(commitTableHint(owner, repo));
+}
+async function readLatestCommit(ref) {
+  const rows = await readRowsByRef(ref, { limit: 1 });
+  return rows[0] ?? null;
+}
+async function readCommitHistory(ref, options) {
+  const rows = await readRowsByRef(ref, options);
+  return rows;
+}
+
+// src/layers/repo.ts
+var REPO_COLUMNS = ["name", "description", "isPublic", "timestamp"];
+var REGISTRY_COLUMNS = ["owner", "repo", "description", "timestamp"];
+async function createRepo(signer, meta) {
+  await ensureDbRoot(signer);
+  const owner = await signerAddress(signer);
+  const listHint = repoListHint(owner);
+  const writes = [];
+  if (!await tableExists(listHint)) {
+    await createTable(signer, listHint, REPO_COLUMNS, "name", { writers: [owner] });
+  }
+  const sig = await writeRow(signer, listHint, JSON.stringify(meta));
+  writes.push({ tableHint: listHint, sig, row: meta });
+  notifyGateways(tableKey(listHint), sig, meta, owner);
+  if (meta.isPublic) {
+    if (!await tableExists(REGISTRY_HINT)) {
+      await createTable(signer, REGISTRY_HINT, REGISTRY_COLUMNS, "owner");
+    }
+    const entry = {
+      owner,
+      repo: meta.name,
+      description: meta.description,
+      timestamp: meta.timestamp
+    };
+    const regSig = await writeRow(signer, REGISTRY_HINT, JSON.stringify(entry));
+    writes.push({ tableHint: REGISTRY_HINT, sig: regSig, row: entry });
+    notifyGateways(tableKey(REGISTRY_HINT), regSig, entry, owner);
+  }
+  return writes;
+}
+async function readOwnerRepos(owner) {
+  return await readRows(repoListHint(owner));
+}
+async function readRegistryPage(options) {
+  return await readRows(REGISTRY_HINT, options);
+}
+async function bootstrapRegistry(signer) {
+  await ensureDbRoot(signer);
+  if (await tableExists(REGISTRY_HINT)) {
+    return null;
+  }
+  return createTable(signer, REGISTRY_HINT, REGISTRY_COLUMNS, "owner");
+}
+
+// src/layers/storage.ts
+async function uploadBlob(signer, relativePath, base64Content, reuse, onProgress, speed) {
+  const hash = await sha256Hex(base64Content);
+  const prior = reuse[relativePath];
+  if (prior && prior.hash === hash) return prior;
+  const basename = relativePath.split("/").pop() || relativePath;
+  const txId = await codeIn(
+    signer,
+    base64Content,
+    `iqgit-blob:${basename}`,
+    "application/octet-stream",
+    onProgress,
+    speed
+  );
+  return { txId, hash };
+}
+async function uploadTree(signer, tree, speed) {
+  return codeIn(
+    signer,
+    JSON.stringify(tree),
+    "iqgit-tree",
+    "application/json",
+    void 0,
+    speed
+  );
+}
+async function loadTree(treeTxId) {
+  const { data } = await readCodeIn(treeTxId);
+  if (data === null) {
+    throw new Error(`tree.json not found for tx ${treeTxId}`);
+  }
+  return JSON.parse(data);
+}
+async function loadBlob(txId) {
+  const { data } = await readCodeIn(txId);
+  if (data === null) {
+    throw new Error(`blob not found for tx ${txId}`);
+  }
+  return data;
+}
+
+// src/layers/client.ts
+var GitClient = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+    this.signer = cfg.signer;
+    if (cfg.chain === "eth") {
+      setChain("eth");
+      initChain({ chain: "eth", network: cfg.network, rpcUrl: cfg.rpcUrl });
+    } else {
+      setChain("solana");
+      initChain({ chain: "solana", connection: cfg.connection });
+      setRpcUrl(cfg.connection.rpcEndpoint);
+    }
+  }
+  cfg;
+  /** The configured signer, as the chain-neutral union the layers consume. */
+  signer;
+  /**
+   * Create a new repo. Wraps repo.createRepo + pre-creating the commit table
+   * so the first `commit()` call doesn't need to pay createTable cost.
+   */
+  async createRepo(meta) {
+    const writes = await createRepo(this.signer, meta);
+    await ensureCommitTable(this.signer, meta.name);
+    this.fireOnWrite(writes);
+  }
+  /**
+   * Incremental commit against a scanned directory snapshot.
+   *
+   * input:  repoName, message, scan — a `{ [path]: base64Content }` map that
+   *         the caller produced (Node: fs walk + base64; browser: File input).
+   * output: newly written Commit
+   */
+  async commit(repoName, message, scan, options) {
+    const owner = await signerAddress(this.signer);
+    const speed = options?.speed ?? this.cfg.speed;
+    const latest = await readLatestCommit(commitTableRef(owner, repoName));
+    const oldTree = latest ? await loadTree(latest.treeTxId) : {};
+    const newTree = {};
+    for (const [path, content] of Object.entries(scan)) {
+      newTree[path] = await uploadBlob(
+        this.signer,
+        path,
+        content,
+        oldTree,
+        void 0,
+        speed
+      );
+    }
+    const treeTxId = await uploadTree(this.signer, newTree, speed);
+    const commit = {
+      id: crypto.randomUUID(),
+      message,
+      treeTxId,
+      parentCommitId: latest?.id,
+      timestamp: Date.now(),
+      author: owner
+    };
+    const sig = await writeCommit(this.signer, repoName, commit);
+    this.fireOnWrite([{ tableHint: commitTableHint(owner, repoName), sig, row: commit }]);
+    return commit;
+  }
+  /** Resolve the table hint to a PDA and forward each write to `onWrite`.
+   *  Wrapped in try/catch per call so a misbehaving notify can't fail the
+   *  whole batch — but we still surface the error so the consumer knows. */
+  fireOnWrite(writes) {
+    if (!this.cfg.onWrite) return;
+    for (const w of writes) {
+      const tablePda2 = tableKey(w.tableHint);
+      this.cfg.onWrite({ tablePda: tablePda2, tableHint: w.tableHint, sig: w.sig, row: w.row });
+    }
+  }
+  /**
+   * Restore a commit's files into a caller-provided sink. Runtime-neutral
+   * shape mirrors `commit`: the caller decides how to write bytes to disk /
+   * to a File System Access API handle / anywhere else. `content` is the
+   * raw base64 string — the sink decodes.
+   */
+  async checkout(repoName, commitId, sink) {
+    const owner = await signerAddress(this.signer);
+    const ref = commitTableRef(owner, repoName);
+    let target;
+    if (commitId === "latest") {
+      target = await readLatestCommit(ref);
+    } else {
+      const history = await readCommitHistory(ref);
+      target = history.find((c) => c.id === commitId) ?? null;
+    }
+    if (!target) {
+      throw new Error(`commit not found: ${commitId} in ${owner}/${repoName}`);
+    }
+    const tree = await loadTree(target.treeTxId);
+    for (const [path, entry] of Object.entries(tree)) {
+      const content = await loadBlob(entry.txId);
+      await sink(path, content);
+    }
+    return target;
+  }
+  /**
+   * Whole-repo snapshot download — convenience on top of checkout("latest")
+   * but reading from someone else's `owner`. We do not require signer to
+   * equal owner for reads.
+   */
+  async clone(repoName, owner, sink) {
+    const target = await readLatestCommit(commitTableRef(owner, repoName));
+    if (!target) {
+      throw new Error(`no commits in ${owner}/${repoName}`);
+    }
+    const tree = await loadTree(target.treeTxId);
+    for (const [path, entry] of Object.entries(tree)) {
+      const content = await loadBlob(entry.txId);
+      await sink(path, content);
+    }
+    return target;
+  }
+  /** Commit history for a repo. */
+  async log(owner, repoName, options) {
+    return readCommitHistory(commitTableRef(owner, repoName), options);
+  }
+  /**
+   * Compare a current directory snapshot to the latest commit's tree.
+   */
+  async status(owner, repoName, scan) {
+    const latest = await readLatestCommit(commitTableRef(owner, repoName));
+    const tree = latest ? await loadTree(latest.treeTxId) : {};
+    const added = [];
+    const modified = [];
+    const unchanged = [];
+    for (const [path, content] of Object.entries(scan)) {
+      const prior = tree[path];
+      if (!prior) {
+        added.push(path);
+        continue;
+      }
+      const hash = await sha256Hex(content);
+      (prior.hash === hash ? unchanged : modified).push(path);
+    }
+    return { added, modified, unchanged };
+  }
+};
+
+// src/layers/pages.ts
+var DEPLOYED_COLUMNS = ["id", "owner", "repo", "deployedAt"];
+function pagesTableRef() {
+  return tableRef(IQPAGES_DEPLOYED_HINT, IQPAGES_ROOT_ID);
+}
+function pagesTableKey() {
+  return tableKey(IQPAGES_DEPLOYED_HINT, IQPAGES_ROOT_ID);
+}
+async function listPagesDeployments() {
+  const rows = await readRowsByRef(pagesTableRef());
+  return rows;
+}
+async function isPagesDeployed(owner, repo) {
+  const id = pagesDeployId(owner, repo);
+  const all = await listPagesDeployments();
+  return all.some((r) => r.id === id);
+}
+async function readJsonFromLatest(owner, repo, filename) {
+  const latest = await readLatestCommit(commitTableRef(owner, repo));
+  if (!latest) return null;
+  const tree = await loadTree(latest.treeTxId);
+  const entry = tree[filename];
+  if (!entry?.txId) return null;
+  const base64 = await loadBlob(entry.txId);
+  return JSON.parse(Buffer.from(base64, "base64").toString("utf8"));
+}
+async function readPagesConfig(owner, repo) {
+  return readJsonFromLatest(owner, repo, IQPAGES_CONFIG_FILENAME);
+}
+async function readPagesProfile(owner, repo) {
+  return readJsonFromLatest(owner, repo, IQPAGES_PROFILE_FILENAME);
+}
+async function ensureGallery(signer) {
+  await ensureDbRoot(signer, IQPAGES_ROOT_ID);
+  if (await tableExists(IQPAGES_DEPLOYED_HINT, IQPAGES_ROOT_ID)) return;
+  await createTable(signer, IQPAGES_DEPLOYED_HINT, DEPLOYED_COLUMNS, "id", {
+    dbRootId: IQPAGES_ROOT_ID
+  });
+}
+async function chargeFee(signer) {
+  if (activeChain() === "eth") {
+    await transferNative(signer, PAGES_FEE_RECIPIENT_EVM, PAGES_FEE_WEI);
+  } else {
+    await transferNative(signer, PAGES_FEE_RECIPIENT, PAGES_FEE_LAMPORTS);
+  }
+}
+async function deployPages(signer, repo) {
+  const owner = await signerAddress(signer);
+  if (await isPagesDeployed(owner, repo)) {
+    throw new Error(`already deployed: ${owner}/${repo}`);
+  }
+  const config = await readPagesConfig(owner, repo);
+  if (!config) {
+    throw new Error(
+      `${IQPAGES_CONFIG_FILENAME} missing in ${repo}. Commit it first, then deploy.`
+    );
+  }
+  await ensureGallery(signer);
+  const row = {
+    id: pagesDeployId(owner, repo),
+    owner,
+    repo,
+    deployedAt: Date.now()
+  };
+  const sig = await writeRow(
+    signer,
+    IQPAGES_DEPLOYED_HINT,
+    JSON.stringify(row),
+    IQPAGES_ROOT_ID
+  );
+  notifyGateways(pagesTableKey(), sig, row, owner);
+  await chargeFee(signer);
+  return { sig, config };
+}
+
+// src/layers/network.ts
+var EVM_TOKENS = {
+  eth: "sepolia",
+  sepolia: "sepolia",
+  monad: "monad",
+  monadTestnet: "monadTestnet"
+};
+function setNetwork(token, options) {
+  const evm = EVM_TOKENS[token];
+  if (evm) {
+    setChain("eth");
+    initChain({ chain: "eth", network: evm, rpcUrl: options?.rpcUrl });
+    return;
+  }
+  setChain("solana");
+  setSolanaGatewayNetwork(token);
+}
+
+export { GitClient, bootstrapRegistry, commitTableRef, deployPages, isPagesDeployed, listPagesDeployments, loadBlob, loadTree, pagesTableRef, readCommitHistory, readLatestCommit, readOwnerRepos, readPagesConfig, readPagesProfile, readRegistryPage, setNetwork, setSha256, uploadBlob, uploadTree, writeCommit };
+//# sourceMappingURL=chunk-EZNMA5NJ.js.map
+//# sourceMappingURL=chunk-EZNMA5NJ.js.map