indelible/publish¶

Functions for writing to the TAANQ and ENS contracts, plus off-chain operations like quote proof generation and JSON download.

import { commitAttestation, revealAttestation, proveQuote } from 'indelible/publish';

All write functions require both a walletClient (for signing and sending transactions) and a publicClient (for reading contract state). See the setup guide.

Attestations¶

commitAttestation¶

Submits the first step of the commit/reveal flow. Computes a salted hash of the content and sends a commit() transaction to the contract.

const { pendingCommit } = await commitAttestation({
    walletClient,
    publicClient,
    content,
    account,
    authority?,
    parentIpfsHash?,
});

Returns: Promise<{ pendingCommit: PendingCommit }>

localStorage.setItem('pendingCommit', JSON.stringify(pendingCommit));

revealAttestation¶

Submits the second step of the commit/reveal flow. Must be called at least 60 seconds after the commit transaction is mined.

const { attestationIndex } = await revealAttestation({
    walletClient,
    publicClient,
    pendingCommit,
    account,
});

Returns: Promise<{ attestationIndex: bigint }>

The returned attestationIndex is the permanent on-chain index of the new attestation. Store it alongside the IPFS CID and authority address to form a complete attestation reference.

revokeAttestation¶

Revokes an existing attestation. Only callable by the attestation's authority address or an active delegate, and only within the 7-day revocation window.

await revokeAttestation({
    walletClient,
    publicClient,
    attestationId,
    account,
});

Returns: Promise<void>

setChildIpfsHash¶

Signals that a newer version of an attested article exists by setting childIpfsHash on an existing attestation. Only callable by the attestation's authority or an active delegate.

await setChildIpfsHash({
    walletClient,
    publicClient,
    attestationId,
    childIpfsHash,
    account,
});

Returns: Promise<{ txHash: string }>

getExistingAttestationIndex¶

Checks whether an attestation already exists for a given IPFS hash and authority. Returns the attestation index, or 0n if none exists. Useful before committing to avoid a duplicate.

const index = await getExistingAttestationIndex({ publicClient, ipfsHash, authority });

Returns: Promise<bigint>

Delegations¶

delegate¶

Authorizes a delegate address to create and revoke attestations on behalf of account.

await delegate({
    walletClient,
    publicClient,
    delegateAddress,
    account,
});

Returns: Promise<void>

Calling this when a delegation already exists overwrites the previous delegate immediately. See Delegations for the full model.

revokeDelegation¶

Removes the caller's active delegation.

await revokeDelegation({ walletClient, publicClient, account });

Returns: Promise<void>

getDelegation¶

Reads the current delegation for an authority address.

const delegation = await getDelegation({ publicClient, authority });
// { delegateAddress: '0x...', timestamp: 1234567890n }
// or { delegateAddress: '0x000...', timestamp: 0n } if no delegation exists

Returns: Promise<{ delegateAddress: string, timestamp: bigint }>

A delegateAddress of 0x0000000000000000000000000000000000000000 (the zero address) means no delegation is currently set.

Quote proofs¶

proveQuote¶

Generates a quote proof JSON for a passage of text quoted from an attested article. The proof can be embedded in HTML or distributed as a standalone file.

const { proofJson, onChain } = await proveQuote({
    articleText,
    quote,
    authority,
    publicClient?,
    chainId?,
});

Returns: Promise<{ proofJson: object, onChain: boolean }>

Segmented quotes¶

If quote doesn't appear verbatim in articleText and it contains an ellipsis (... or …) or bracketed text (e.g. [sic], […]), proveQuote splits it into literal segments around those markers and locates each segment in articleText, in the same order they appear in the quote. Text inside brackets is discarded entirely — it's treated the same as an ellipsis.

// Both of these produce a valid proof, as long as each segment appears
// in articleText in that order:
await proveQuote({ articleText, quote: 'The revolution ... televised.', authority });
await proveQuote({ articleText, quote: 'The revolution [will not be] televised.', authority });

The resulting proofJson has the exact same shape as a contiguous quote's proof — it just contains proofs for the chunks covering every segment. Throws if a segment can't be found, or is found out of order relative to the previous segment.

If your quote can legitimately contain a literal ellipsis or brackets (not as an omission marker), pass disableSegmenting: true to opt out of this behavior for that call:

// "..." here is part of the actual quoted text, not an omission marker.
await proveQuote({
    articleText,
    quote: 'She said "wait..." and walked away.',
    authority,
    disableSegmenting: true,
});

import { proveQuote, downloadJson } from 'indelible/publish';

const { proofJson } = await proveQuote({
    articleText,
    quote,
    authority: '0xD2f2...',
    publicClient,
});

// In the browser — triggers a file download
downloadJson(proofJson, 'quote-proof.json');

ENS¶

registerEnsBinding¶

Registers a binding between an ENS name and an Ethereum address on the Indelible ENS contract.

await registerEnsBinding({
    walletClient,
    publicClient,
    ensName,
    account,
});

Returns: Promise<void>

See ENS Integration for the full integration model.

Helpers¶

generateSalt¶

Generates a cryptographically random 32-byte salt suitable for use in the commit/reveal flow. Called automatically by commitAttestation; exposed for advanced use cases.

const salt = generateSalt();
// Uint8Array(32) [ ... ]

buildSaltedHash¶

Computes the saltedHash value required for the commit() contract call.

const saltedHash = buildSaltedHash(ipfsHash, address, salt);

Returns: string — a bytes32 hex hash.

downloadJson¶

Triggers a browser file download for a JSON object. Browser-only convenience; in Node.js, use JSON.stringify() and write to disk directly.

downloadJson(proofJson, 'quote-proof.json');