Under the hood: inscription

// Inscribe an ASC step list on Solana with IQ Labs code-in, then read it back and hash it.
// API per the @iqlabs-official/solana-sdk README (marked Draft): check signatures against the SDK source.
import iqlabs from '@iqlabs-official/solana-sdk';
import { Connection, Keypair } from '@solana/web3.js';
import { createHash } from 'node:crypto';
import steps from './hot_wallet_steps.json';

const connection = new Connection(process.env.SOLANA_RPC_URL ?? 'http://127.0.0.1:8899', 'confirmed');
iqlabs.setRpcUrl(connection.rpcEndpoint);
const signer = Keypair.fromSecretKey(/* author wallet secret key */ new Uint8Array());

const body = JSON.stringify(steps);                 // 1,909 bytes for the hot-wallet example: multi-transaction tier (900 B to 8.5 KB)
const policyTx = await iqlabs.writer.codeIn(
  { connection, signer },
  body,
  'asc-hot-wallet.json', // filename
  0,                     // method (SDK default)
  'application/json',    // filetype
);

const { metadata, data } = await iqlabs.reader.readCodeIn(policyTx);
if (data !== body) throw new Error('read-back mismatch');
const policyRef = createHash('sha256').update(data).digest('hex');
console.log({ policyTx, policyRef, metadata });      // store both on the ASC record and in each attestation

// Inscribe the same ASC on an EVM chain with IQ Labs' Ethereum SDK.
// Networks today: 'sepolia' (default), 'monad', 'robinhood'. Ethereum mainnet is not deployed.
import iqlabs from '@iqlabs-official/ethereum-sdk';
import { Wallet, JsonRpcProvider, keccak256, toUtf8Bytes } from 'ethers';
import steps from './hot_wallet_steps.json';

iqlabs.setNetwork('sepolia');
const provider = new JsonRpcProvider(iqlabs.getRpcUrl());
const signer = new Wallet(process.env.AUTHOR_PRIVATE_KEY!, provider);
await iqlabs.assertChainMatches(signer);

const body = JSON.stringify(steps);                       // over 850 bytes: SDK uploads a linked list of chunks
const policyTx = await iqlabs.writer.codeIn(signer, body, 'asc-hot-wallet.json', 'application/json');
const { data } = await iqlabs.reader.readCodeIn(policyTx);
if (data !== body) throw new Error('read-back mismatch');

// The guarded contract stores keccak256 of the bytes; checkPolicy() attestations sign over it.
const policyRef = keccak256(toUtf8Bytes(body));
console.log({ policyTx, policyRef });

// Private ASC: encrypt the rules to every juror's wallet-derived X25519 key, inscribe only the ciphertext.
// Works the same with @iqlabs-official/ethereum-sdk (same crypto namespace).
import iqlabs from '@iqlabs-official/solana-sdk';
import { createHash } from 'node:crypto';

// Each juror publishes its X25519 public key once, derived from its wallet:
//   const sign = async (msg: Uint8Array) => wallet.signMessage(msg);
//   const { pubKey } = await iqlabs.crypto.deriveX25519Keypair(sign);
const jurorPubKeys: string[] = [/* hex X25519 pubkeys from the jurors table */];

export async function inscribePrivateAsc(input: { connection: any; signer: any }, rulesJson: string) {
  const plaintextRef = createHash('sha256').update(rulesJson).digest('hex'); // jurors attest to this
  const encrypted = iqlabs.crypto.multiEncrypt(jurorPubKeys, new TextEncoder().encode(rulesJson)); // { recipients, iv, ciphertext }
  const envelope = JSON.stringify({ kind: 'asc.private/1', plaintextRef, encrypted });
  const policyTx = await iqlabs.writer.codeIn(input, envelope, 'asc-private.json', 0, 'application/json');
  return { policyTx, plaintextRef };
}

// Juror side:
//   const { metadata, data } = await iqlabs.reader.readCodeIn(policyTx);
//   const { plaintextRef, encrypted } = JSON.parse(data!);
//   const rules = iqlabs.crypto.multiDecrypt(privKey, pubKey, encrypted);   // Uint8Array
//   check sha256(rules) === plaintextRef before judging.

// Public juror registry and rulings log as IQ Labs tables. The escrow program still verifies
// Ed25519 signatures itself; the tables are the public, append-only record anyone can read.
import iqlabs from '@iqlabs-official/solana-sdk';

const DB = 'asc';
export async function setup(connection: any, signer: any) {
  await iqlabs.writer.createTable(connection, signer, DB, 'jurors', 'jurors',
    ['wallet', 'family', 'model', 'x25519Pub', 'addedAt'], 'wallet', [], undefined, [/* writer allowlist: ASC admin */]);
  await iqlabs.writer.createTable(connection, signer, DB, 'rulings', 'rulings',
    ['policyRef', 'actionHash', 'ruling', 'wallet', 'sig', 'at'], 'actionHash', []);
}

export async function logRuling(connection: any, jurorSigner: any, row: Record<string, string>) {
  return iqlabs.writer.writeRow(connection, jurorSigner, DB, 'rulings', JSON.stringify(row));
}

// Readers: iqlabs.reader.readTableRows(<table account>, { limit: 50 })