@palliora.org/chainsdk 0.4.0 → 0.5.1

package/dist/index.d.ts

@@ -39,8 +39,37 @@ declare enum AccountSourceType {
  * @returns The keypair object.
  */
 declare function createAccount(input: string, type: AccountSourceType, name?: string, cryptoType?: CryptoType, signedMsg?: string): Promise<KeyringPair>;
+/**
+ * Derives a Substrate account from a Magic Link (or other Ethereum-compatible)
+ * signature over the fixed message `createAccount` expects for signature-derived
+ * accounts, wiring passwordless/email-based onboarding into the existing
+ * `AccountSourceType.DERIVED` flow.
+ *
+ * @param signature - Hex-encoded signature (0x-prefixed) produced by the Magic Link signer.
+ */
+declare function createAccountFromMagicLink(signature: string, name?: string, cryptoType?: CryptoType): Promise<KeyringPair>;
 declare function pairFromPrivateKeyHex(privateKeyHex: string, cryptoType: CryptoType): _polkadot_util_crypto_types.Keypair;
 
+interface Balance {
+    free: bigint;
+    reserved: bigint;
+    frozen: bigint;
+    /** Free balance formatted with the chain's token symbol/decimals, e.g. "1.5 PALI". */
+    formatted: string;
+}
+/** Reads an account's free/reserved/frozen balance from `system.account`. */
+declare function getBalance(address: string): Promise<Balance>;
+
+interface AccountInfo {
+    address: string;
+    nonce: number;
+    balance: Balance;
+    /** On-chain identity display name, or `null` if none is set. */
+    displayName: string | null;
+}
+/** Convenience read combining balance, nonce, and identity display name for a single account. */
+declare function getAccountInfo(address: string): Promise<AccountInfo>;
+
 declare const API_RPC: {
     kate: {
         queryRows: {
@@ -299,6 +328,7 @@ declare const API_TYPES: {
             Dataset: string;
             Model: string;
             Agent: string;
+            Executable: string;
             Other: string;
         };
     };
@@ -348,13 +378,16 @@ declare const API_TYPES: {
         fhe: string;
         zkp: string;
     };
+    ComputeType: {
+        _enum: string[];
+    };
     GuardianPrefs: {
         pubKey: string;
         guardian: string;
         verifier: string;
         compute: string;
         computePrefs: string;
-        feeThreshold: string;
+        feeThresholds: string;
     };
     BlockLengthColumns: string;
     BlockLengthRows: string;
@@ -614,7 +647,7 @@ interface UploadOptions {
     name: string;
     description: string;
     price: PaliAmountInput;
-    type: "model" | "dataset" | "agent";
+    type: "model" | "dataset" | "agent" | "executable";
     guardianGroupInfo: GuardianGroupInfo;
     ref?: string;
     filePath?: string;
@@ -728,8 +761,8 @@ declare const FileFromMetadataRef: (mcryptApi: any, metadataRef: [number, number
  * Returns the singleton {@link ApiPromise} instance, creating it if necessary.
  *
  * @remarks
- * - If no underlying `provider` is configured (the module-level `provider`
- *   imported from "./wsProvider"), this function returns `undefined`.
+ * - Throws if the SDK has not been initialized with a `pallioraWs` endpoint
+ *   (see `init` in "../config").
  * - When creating the API, the configured `rpc`, `types` and `signedExtensions`
  *   are applied.
  * - In non-test environments, top-level API `error` and `disconnected` events
@@ -738,9 +771,19 @@ declare const FileFromMetadataRef: (mcryptApi: any, metadataRef: [number, number
  *
  * @param cb - Optional callback function to attach to the "disconnected" event.
  *
- * @returns The singleton {@link ApiPromise} instance (or `undefined` if no provider).
+ * @returns The singleton {@link ApiPromise} instance.
+ */
+declare function getApi(cb?: () => void): Promise<ApiPromise>;
+/**
+ * disconnectApi()
+ *
+ * Tears down the singleton {@link ApiPromise} instance, if one exists.
+ *
+ * @remarks
+ * Safe to call when no API has been created yet (no-op). After this resolves,
+ * the next call to {@link getApi} creates a fresh instance.
  */
-declare function getApi(cb?: () => void): Promise<ApiPromise | undefined>;
+declare function disconnectApi(): Promise<void>;
 /**
  * getKeyring()
  *
@@ -803,6 +846,30 @@ interface SubmissionReceipt {
     /** Zero-based index of the result extrinsic within the block. */
     extrinsicIndex: number;
 }
+/** Union of `AgreementStatus` variant names, read straight off {@link API_TYPES} (chain/spec.ts). */
+type AgreementStatus = keyof typeof API_TYPES.AgreementStatus._enum;
+/** Union of `ContractType` variant names, read straight off {@link API_TYPES} (chain/spec.ts). */
+type ContractType = keyof typeof API_TYPES.ContractType._enum;
+/**
+ * On-chain record for an agreement/contract, read back from `compute.agreementsInfo`.
+ * Mirrors the `ContractInfo` type registered in {@link API_TYPES} (chain/spec.ts).
+ */
+interface ContractInfo {
+    /** Current settlement status of the agreement. */
+    status: AgreementStatus;
+    /** Address of the account that owns the contract. */
+    owner: string;
+    /** Block number at which the contract originated. */
+    originBlock: number;
+    /** Block number at which the contract was last invoked. */
+    invocationBlock: number;
+    /** Sequential index assigned to the agreement. */
+    index: number;
+    /** Usage price charged per invocation, in atomic units. */
+    usagePrice: bigint;
+    /** Contract lifecycle type. */
+    contractType: ContractType;
+}
 
 declare const signAndSend: (request: SubmittableExtrinsic<"promise">, account: KeyringPair, opts?: Record<string, unknown>) => Promise<{
     blockNumber: number;
@@ -810,12 +877,36 @@ declare const signAndSend: (request: SubmittableExtrinsic<"promise">, account: K
     hash: `0x${string}`;
     tx_result: ISubmittableResult;
 }>;
+/**
+ * Retries {@link signAndSend} with exponential backoff, for RPC endpoints that
+ * intermittently drop connections or time out mid-submission.
+ *
+ * @param request   Unsigned extrinsic to submit
+ * @param account   Signing account
+ * @param opts      Extra signer options, forwarded to `signAndSend` (see its defaults)
+ * @param retries   Number of retry attempts after the initial try (default 3)
+ * @param backoffMs Base delay before the first retry; doubles each subsequent attempt (default 1000)
+ */
+declare const retrySignAndSend: (request: SubmittableExtrinsic<"promise">, account: KeyringPair, opts?: Record<string, unknown>, retries?: number, backoffMs?: number) => Promise<{
+    blockNumber: number;
+    index: number;
+    hash: `0x${string}`;
+    tx_result: ISubmittableResult;
+}>;
 declare const getFileMetadataCall: (api: ApiPromise, metadataRef: [number, number]) => Promise<_polkadot_types_types.CallBase<_polkadot_types_types.AnyTuple, _polkadot_types_interfaces.FunctionMetadataLatest>>;
 declare const getGuardianAddress: () => Promise<{
     peerid: string;
     address: string;
 }[]>;
 declare const getGuardianNwParams: () => Promise<string>;
+/**
+ * Reads back the on-chain record for an agreement/contract created via
+ * `createAgreement`, from `compute.contracts`.
+ *
+ * @param contractId - Hex-encoded agreement ID (as returned by `createAgreement`).
+ * @returns The decoded {@link ContractInfo}, or `null` if no contract exists for that ID.
+ */
+declare function getContractInfo(contractId: string): Promise<ContractInfo | null>;
 /**
  * Fetches the block at `blockHeight`, extracts the extrinsic at
  * `extrinsicIndex`, and returns both the raw codec object and its human-readable
@@ -827,6 +918,11 @@ declare function fetchAndDecodeExtrinsic(blockHeight: number, extrinsicIndex: nu
     raw: any;
     decoded: Record<string, unknown>;
 }>;
+/**
+ * Finds the first event record matching `section`/`method` (case-insensitive)
+ * among a transaction's emitted events, e.g. `tx_result.events` from {@link signAndSend}.
+ */
+declare function findEvent(events: EventRecord[], section: string, method: string): EventRecord | undefined;
 type BlockScanFilter = {
     /** Pallet name, e.g. "dataAvailability" (case-insensitive) */
     section: string;
@@ -867,6 +963,14 @@ type BlockScanResult = {
  * @param maxBlocks  Reject after scanning this many blocks; pass 0 to wait indefinitely (default 20)
  */
 declare const scanForBlockEvent: (api: ApiPromise, filter: BlockScanFilter, startBlock?: number, maxBlocks?: number) => Promise<BlockScanResult>;
+/**
+ * Resolves as soon as the next block header is produced. Useful as a plain
+ * polling tick, e.g. between rounds of a manual wait loop.
+ */
+declare function waitForNextBlock(): Promise<{
+    blockNumber: number;
+    blockHash: string;
+}>;
 /**
  * Subscribes to new block headers and scans each block's extrinsics until a
  * `compute.result` extrinsic matching `requestId` is found.  Resolves with the
@@ -886,6 +990,24 @@ declare function watchForSubmissionReceipt(requestId: string, timeoutMs?: number
  */
 declare function getAgreementCreatedRequestId(blockHeight: number, extrinsicIndex: number): Promise<string | null>;
 
+interface LatestBlock {
+    height: number;
+    hash: string;
+    time: number;
+    validator: string;
+    eventsCount: number;
+    extrinsicsCount: number;
+}
+interface LatestBlocksResult {
+    blocks: LatestBlock[];
+    latestHeight: number;
+}
+/**
+ * Newest on-chain blocks first, paged backward from the current tip.
+ * Uses RPC rather than the indexer `/api/blocks` list.
+ */
+declare function getLatestBlocks(count: number, page?: number, apiInstance?: ApiPromise): Promise<LatestBlocksResult>;
+
 /**
  * Converts a {@link Fee} into the on-chain `fees` / `computeRate` pair.
  * `computeRate` only has meaning for `Active` contracts (it drives dynamic
@@ -896,6 +1018,42 @@ declare function buildFee(fee?: Fee): {
     fees: bigint;
     computeRate: bigint;
 };
+/** Zero `H256` — the `groupId` of a contract that belongs to no guardian group. */
+declare const NO_GUARDIAN_GROUP: string;
+/**
+ * Classification carried in `ComputeMetadata.storeType`.
+ *
+ * Mirrors `pallet_compute::StoreType` variant-for-variant via {@link API_TYPES}.
+ * Order is the encoding: the variant index is what goes on the wire, so an
+ * omitted or reordered variant silently shifts every one after it.
+ */
+type StoreType = keyof typeof API_TYPES.StoreType._enum;
+interface ComputeMetadataInput {
+    /** Human-readable name of the registered artifact. */
+    name: string;
+    /** Human-readable description of the registered artifact. */
+    description: string;
+    /** What kind of artifact this is. */
+    storeType: StoreType;
+    /**
+     * H256 of the guardian group this entry belongs to. Defaults to
+     * {@link NO_GUARDIAN_GROUP} — correct for plaintext contracts, which have no
+     * group. The chain stores this field but never reads it.
+     */
+    groupId?: string;
+}
+/**
+ * Converts a {@link ComputeMetadataInput} into the on-chain `ComputeMetadata`,
+ * whose `name` and `description` are byte vectors rather than strings.
+ * Returns `null` for absent metadata, which is what `Option<ComputeMetadata>`
+ * expects.
+ */
+declare function buildComputeMetadata(metadata?: ComputeMetadataInput): {
+    name: number[];
+    description: number[];
+    storeType: "Dataset" | "Model" | "Agent" | "Executable" | "Other";
+    groupId: string;
+} | null;
 interface ComputeContract {
     contractType: "Active" | "Dormant";
     guardians: GuardianAddress[];
@@ -912,6 +1070,26 @@ declare function createAgreement(contract: ComputeContract, account: KeyringPair
     hash: string;
     agreementId?: string;
 }>;
+interface InvokeAgreementInput {
+    /** Guardian account IDs handling the invocation; matches the agreement's guardian set. */
+    guardians: GuardianAddress[];
+    /** Cipher suite describing how `data` is encrypted. Use "Plaintext" for unencrypted payloads. */
+    cipher: unknown;
+    /** Invocation payload bytes (already encrypted if `cipher` is not "Plaintext"). */
+    data: Uint8Array | number[];
+}
+/**
+ * Invokes an existing `Subscription`-type agreement with a new payload, via
+ * `compute.invoke`.
+ *
+ * @param agreementId - Hex-encoded agreement ID (as returned by `createAgreement`).
+ */
+declare function invokeAgreement(agreementId: string, input: InvokeAgreementInput, account: KeyringPair, opts?: Record<string, unknown>): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: `0x${string}`;
+    tx_result: _polkadot_types_types.ISubmittableResult;
+}>;
 declare function createSimpleAgreement(): Promise<{
     blockNumber: number;
     index: number;
@@ -920,8 +1098,13 @@ declare function createSimpleAgreement(): Promise<{
 }>;
 
 interface DataContractParams {
-    /** URL pointing to the data to store. */
-    url: string;
+    /** URL pointing to the data to store. Mutually exclusive with `data`. */
+    url?: string;
+    /**
+     * Bytes carried in the extrinsic itself, for payloads small enough not to
+     * warrant off-chain hosting. Mutually exclusive with `url`.
+     */
+    data?: string | Uint8Array;
     /** Guardian account IDs that participate in this contract. */
     guardians: string[];
     /**
@@ -930,6 +1113,13 @@ interface DataContractParams {
      * compute rate only applies to `Active` contracts.
      */
     fee: Fee;
+    /**
+     * Describes the registered artifact — name, description, and the `storeType`
+     * saying what kind of thing it is. Omitted metadata registers the contract
+     * anonymously, which leaves nothing on-chain to tell a stored dataset from a
+     * stored program.
+     */
+    metadata?: ComputeMetadataInput;
     /** Block number deadline. Defaults to 0 (no deadline). */
     deadline?: number;
     /** Trusted guardian index in the guardians list. Defaults to 0. */
@@ -940,9 +1130,15 @@ interface DataContractParams {
  *
  * - No encryption (Plaintext cipher suite)
  * - Trusted confidentiality mode
- * - Input fetched from a URL
+ * - Input fetched from a URL, or carried inline in the extrinsic
  * - No pre-check or post-check verifications
  * - Plain (unencrypted) result
+ *
+ * The artifact goes in `compute.input` and `compute.program` stays inert: a
+ * `Dormant` contract registers something rather than running it. A later
+ * `Active` contract reaches this artifact with `{ ContractId: { id } }`, in
+ * either its own `input` or its `program`, and pays this contract's owner the
+ * `fee` offered here as the usage price.
  */
 declare function dataContract(params: DataContractParams, account: KeyringPair): Promise<{
     blockNumber: number;
@@ -951,6 +1147,68 @@ declare function dataContract(params: DataContractParams, account: KeyringPair):
     agreementId?: string;
 }>;
 
+/**
+ * The chain-side parameters the compute fee floor is derived from.
+ *
+ * All four are read live: the first three are root-settable storage values
+ * (`compute.setMaxDaStorageSize`, `setProviderStorageRate`,
+ * `setThresholdDecryptionFee`), so a hard-coded copy goes stale silently and
+ * surfaces only as an `InsufficientFreeBalance` at submission time.
+ */
+interface FeeParams {
+    /** Bytes of DA storage a result is priced against. */
+    maxDaStorageSize: bigint;
+    /** Price per byte of DA storage, in atomic units. */
+    providerStorageRate: bigint;
+    /** Flat fee split between the contract's guardians, in atomic units. */
+    thresholdDecryptionFee: bigint;
+    /** Block time in milliseconds, the multiplier applied to `computeRate`. */
+    millisecondsPerBlock: bigint;
+}
+interface MinFeeInput {
+    /** Per-millisecond compute rate the contract offers, in PALI. */
+    computeRate: PaliAmountInput;
+    /** Contract ID supplying the input, whose owner is owed the input fee. */
+    inputContractId?: string;
+}
+/** The fee floor and the four components it is built from, all in atomic units. */
+interface MinFeeBreakdown {
+    /** `maxDaStorageSize * providerStorageRate` — pays whoever submits the result. */
+    resultFee: bigint;
+    /** `usagePrice` of the referenced input contract, or 0 when none is referenced. */
+    inputFee: bigint;
+    /** Flat threshold-decryption fee, split between the contract's guardians. */
+    thresholdDecryptionFee: bigint;
+    /** `computeRate * millisecondsPerBlock` — one block's worth of compute. */
+    offeredComponent: bigint;
+    /** The sum: the smallest `fees` the chain accepts for this contract. */
+    minFee: bigint;
+}
+/**
+ * Reads the four live chain parameters that define the compute fee floor.
+ *
+ * Throws when the connected runtime predates the metered-compute upgrade: older
+ * runtimes expose a `compute` pallet with neither these storage items nor the
+ * `Contract`-shaped `agreement` call, so there is no fee floor to report.
+ */
+declare function getFeeParams(): Promise<FeeParams>;
+/**
+ * Computes the smallest `fees` an `Active` or `Subscription` contract may offer.
+ *
+ * Mirrors `pallet_compute::Pallet::fee_components`, which `CheckCompute` enforces
+ * when validating the extrinsic and which `compute.result` settles against. An
+ * offer below this floor is rejected as `InsufficientFreeBalance` before the
+ * agreement is ever included in a block.
+ *
+ * Clearing this floor is necessary but not sufficient: guardians independently
+ * reject an agreement whose `computeRate` is under their own per-compute-type
+ * threshold. See CHAIN-RULES.md ("Two gates, not one").
+ *
+ * `Dormant` contracts reserve nothing and are exempt — they may offer any `fees`,
+ * including zero.
+ */
+declare function estimateMinFee(input: MinFeeInput): Promise<MinFeeBreakdown>;
+
 interface EncryptedInferenceSubscriptionParams {
     /** Guardian account addresses that participate in this compute. */
     guardians: string[];
@@ -1102,6 +1360,261 @@ declare function simpleCompute(params: SimpleComputeParams, account: KeyringPair
     agreementId?: string;
 }>;
 
+interface StoredComputeParams {
+    /** Guardian account IDs that participate in this compute. */
+    guardians: string[];
+    /** Contract ID of the `Dormant` contract registering the program. */
+    programContractId: string;
+    /** Contract ID of the `Dormant` contract registering the input data. */
+    inputContractId: string;
+    /**
+     * Fee offered for the compute step. Must clear the floor returned by
+     * `estimateMinFee({ computeRate, inputContractId })` — referencing a stored
+     * input raises that floor by the input contract's usage price.
+     */
+    fee: Fee;
+    /** Describes this execution. Unlike the contracts it references, it registers
+     * nothing — so `storeType` is `"Other"` unless the run itself produces a
+     * classifiable artifact. */
+    metadata?: ComputeMetadataInput;
+    /** Block number deadline for the compute step. Defaults to 0 (no deadline). */
+    deadline?: number;
+    /** Trusted guardian index in the guardians list. Defaults to 0. */
+    trustIndex?: number;
+}
+/**
+ * Submits an `Active` agreement whose program and input both live in contracts
+ * already registered on-chain.
+ *
+ * Where {@link simpleCompute} carries the program as a URL and the input as a
+ * block coordinate, this points at two `Dormant` contracts instead. Each
+ * `{ ContractId: { id } }` resolves to that contract's `compute.input` — the
+ * field {@link dataContract} stores an artifact in — so the program contract
+ * supplies the image and the input contract supplies the data.
+ *
+ * Only the `input` reference is billed: settlement pays the input contract's
+ * owner its `usage_price`, which is why that ID is also what
+ * `estimateMinFee` needs to quote the floor.
+ */
+declare function storedCompute(params: StoredComputeParams, account: KeyringPair): Promise<{
+    blockNumber: number;
+    index: number;
+    hash: string;
+    agreementId?: string;
+}>;
+
+/** Thrown for any non-2xx response from the cost estimation service. */
+declare class CostEstimationError extends Error {
+    readonly status: number;
+    constructor(message: string, status: number);
+}
+
+/** Confidentiality mode a compute contract requires guardians to support. */
+type ComputeMode = "Trusted" | "TEE" | "MPC" | "FHE" | "ZKP";
+/** Request body for {@link startEstimate} (`POST /estimate`). */
+interface ContractParams {
+    /** Confidentiality mode eligible guardians must support. */
+    computeMode: ComputeMode;
+    /** Drives duration prediction. Omit to fall back to the service's default duration. */
+    programRef?: string;
+    /** Existing on-chain contract id. Omit to zero the input-fee component of the estimate. */
+    contractId?: string;
+}
+/** A guardian entry as returned in an estimate's eligible set. */
+interface GuardianEntry {
+    address: string;
+    pubKey: string;
+    /** On-chain reserve rate, in atomic units. */
+    feeThreshold: bigint;
+}
+/** Resolved outcome of a `"completed"` estimate. */
+interface EstimateResult {
+    predictedDurationMs: number;
+    /** Winning auctioned rate, in atomic units. */
+    auctionedRate: bigint;
+    /** `resultFee + inputFee + thresholdDecryptionFee + auctionedRate * predictedDurationMs`. */
+    estimatedCost: bigint;
+    /** Full eligible guardian set at auction start, not just the winner. */
+    guardians: GuardianEntry[];
+}
+/** Response from {@link getEstimateResult} (`GET /estimates/:id`). */
+type EstimateStatusResponse = {
+    status: "pending";
+    auctionId: string;
+} | {
+    status: "completed";
+    auctionId: string;
+    result: EstimateResult;
+} | {
+    status: "failed";
+    auctionId: string;
+    error: string;
+};
+/** An auction currently open (unresolved), as listed by `GET /auctions` and friends. */
+interface OpenAuction {
+    auctionId: string;
+    contractId: string;
+    guardians: string[];
+    /** Auction resolution deadline, epoch ms. */
+    deadline: number;
+}
+/** The winning bid on a resolved auction. */
+interface AuctionWinner {
+    guardian: string;
+    /** Winning rate, in atomic units. */
+    rate: bigint;
+}
+/**
+ * A resolved auction this guardian was eligible for, as returned by
+ * {@link listResolvedGuardianAuctions} (`GET /guardians/:address/auctions?resolved=true`).
+ */
+interface ResolvedAuction {
+    auctionId: string;
+    contractId: string;
+    guardians: string[];
+    deadline: number;
+    winner: AuctionWinner;
+}
+/**
+ * Full detail for a single auction regardless of resolution status, as returned by
+ * {@link getAuction} (`GET /auctions/:id`). A resolved auction is never deleted from
+ * the service's store, only excluded from `GET /auctions` / `GET /guardians/:address/auctions`
+ * — this is the only endpoint that can return its outcome once it has dropped off those lists.
+ */
+interface AuctionDetail {
+    auctionId: string;
+    contractId: string;
+    guardians: string[];
+    deadline: number;
+    resolved: boolean;
+    /** Present only once `resolved` is `true`. */
+    winner?: AuctionWinner;
+}
+
+interface StartedEstimate {
+    estimateId: string;
+    /**
+     * Id of the auction backing this estimate. Usable with {@link getAuction} once a
+     * resolved auction has dropped off `GET /auctions` / `GET /guardians/:address/auctions`
+     * — most callers never need it and can just poll {@link getEstimateResult}.
+     */
+    auctionId: string;
+}
+/**
+ * Starts a cost estimate via `POST /estimate`.
+ *
+ * Asynchronous: returns as soon as the rate auction is created, well before it
+ * resolves (~`AUCTION_WINDOW_MS`, 5000ms by default). Poll {@link getEstimateResult}
+ * with the returned id for the outcome, or use {@link waitForEstimate} to do both in
+ * one call.
+ *
+ * Not idempotent — every call starts a brand-new auction with a new id, and can
+ * resolve to a different `estimatedCost` even for identical input.
+ *
+ * @throws {CostEstimationError} 400 if `computeMode` is missing/invalid; 422 if no
+ * guardians are eligible for that mode (do not tight-loop retry).
+ */
+declare function startEstimate(params: ContractParams): Promise<StartedEstimate>;
+/**
+ * Fetches the current state of an estimate started via {@link startEstimate}.
+ *
+ * `auctionedRate`, `estimatedCost`, and `feeThreshold` are returned as `bigint` —
+ * never treat them as floating-point numbers.
+ *
+ * @throws {CostEstimationError} 404 if `estimateId` is unrecognized (terminal — a
+ * restart of the service does not invalidate a previously issued id).
+ */
+declare function getEstimateResult(estimateId: string): Promise<EstimateStatusResponse>;
+interface WaitForEstimateOptions {
+    /** Milliseconds between polls. Defaults to 5000ms (the service's default auction window). */
+    intervalMs?: number;
+    /** Upper bound on total wait time in milliseconds. Defaults to 60000ms. */
+    timeoutMs?: number;
+}
+/**
+ * Starts an estimate and polls {@link getEstimateResult} until it leaves
+ * `"pending"`, spacing requests `intervalMs` apart rather than tight-looping.
+ *
+ * Resolves with the terminal `"completed"` or `"failed"` status. Rejects if
+ * `timeoutMs` elapses first — the estimate keeps running server-side regardless,
+ * and can still be recovered later via {@link getEstimateResult} with the same id.
+ */
+declare function waitForEstimate(params: ContractParams, options?: WaitForEstimateOptions): Promise<{
+    estimateId: string;
+    status: EstimateStatusResponse;
+}>;
+
+/**
+ * Lists currently open (unresolved) auctions via `GET /auctions`, so a guardian can
+ * discover an `auctionId` while it is still running in the background after a
+ * {@link startEstimate} call returned. Only relevant when acting on behalf of a
+ * guardian — a plain cost lookup never needs this.
+ */
+declare function listOpenAuctions(): Promise<OpenAuction[]>;
+/**
+ * Same as {@link listOpenAuctions}, pre-filtered server-side (via
+ * `GET /guardians/:address/auctions`) to auctions `guardianAddress` is eligible for.
+ */
+declare function listGuardianAuctions(guardianAddress: string): Promise<OpenAuction[]>;
+/**
+ * Looks up a single auction via `GET /auctions/:id`, regardless of resolution status.
+ * A resolved auction is never deleted from the service's store, only excluded from
+ * {@link listOpenAuctions} / {@link listGuardianAuctions} — this is the only way to
+ * retrieve its outcome (including the winning guardian's address) once resolved.
+ *
+ * @throws {CostEstimationError} 404 if `auctionId` is unrecognized — terminal.
+ */
+declare function getAuction(auctionId: string): Promise<AuctionDetail>;
+/**
+ * Lists auctions `guardianAddress` was eligible for and that have since resolved, via
+ * `GET /guardians/:address/auctions?resolved=true`. Use this instead of
+ * {@link listGuardianAuctions} (which only ever shows currently open auctions) when
+ * fetching a confirmed auction for a guardian you don't already have an `auctionId`
+ * for — no need to guess the guardian's `computeMode` and start a throwaway estimate.
+ */
+declare function listResolvedGuardianAuctions(guardianAddress: string): Promise<ResolvedAuction[]>;
+/**
+ * Submits a signed rate bid into an open auction via `POST /auctions/:id/bid`,
+ * signed with `guardian`'s sr25519 key over the literal string
+ * `${auctionId}:${rate}`, as required by the service.
+ *
+ * Lowest `rate` wins; ties break by earliest submission time, then by
+ * lexicographically smallest address. A guardian that never bids keeps its default
+ * entry — its own on-chain threshold for the compute type this auction was opened
+ * for, which reads as zero when it declared none.
+ *
+ * @param rate - Bid rate as a decimal-integer string, in atomic units.
+ * @throws {CostEstimationError} 422 if the auction is unknown, already closed, or
+ * `guardian` isn't in its eligible set — terminal, do not retry the same bid.
+ */
+declare function submitAuctionBid(auctionId: string, rate: string, guardian: KeyringPair): Promise<void>;
+
+/**
+ * Registers a webhook URL for `guardian` via `POST /guardians/:address/webhook`, so
+ * it gets a best-effort push (`{ auctionId, contractId, deadline }`) whenever it's
+ * placed in a new auction, instead of polling {@link listGuardianAuctions}.
+ *
+ * Signed with `guardian`'s sr25519 key over the literal string `webhook:${url}`, as
+ * required by the service — this binds the registration to the exact URL so it
+ * can't be replayed to redirect notifications elsewhere.
+ *
+ * Replaces any previously registered webhook for this guardian; there is no
+ * list/unregister endpoint. Delivery is best-effort and unawaited by the service —
+ * a failed push is only logged server-side, never retried, so don't rely on this as
+ * a substitute for polling if missing an auction would be costly.
+ *
+ * @throws {CostEstimationError} 400 if `url` isn't an absolute http(s) URL; 404 if
+ * `guardian` has no resolvable on-chain guardian entry; 422 if the signature doesn't
+ * verify.
+ */
+declare function registerGuardianWebhook(url: string, guardian: KeyringPair): Promise<void>;
+
+/**
+ * Liveness probe via `GET /health`. Does not verify chain connectivity — a healthy
+ * response does not guarantee {@link startEstimate} will succeed.
+ */
+declare function healthCheck(): Promise<boolean>;
+
 declare const gen_stretched_key: (input: Uint8Array) => Uint8Array<ArrayBufferLike>;
 declare const gen_shared_key: (key: Uint8Array, pk: Uint8Array) => Uint8Array<ArrayBufferLike>;
 declare const encrypt$1: (plaintext: Uint8Array, key: Uint8Array) => {
@@ -1244,7 +1757,7 @@ interface DataAgreementMetadata {
     name: string;
     description: string;
     /** Maps to the on-chain StoreType enum. */
-    storeType: "Dataset" | "Model" | "Agent" | "Other";
+    storeType: StoreType;
     /** H256 group identifier. */
     groupId: string;
 }
@@ -1307,6 +1820,16 @@ declare function uploadData(options: UploadOptions): Promise<void>;
 declare function uploadDataLegacy(options: Omit<UploadOptions, "opts">): Promise<void>;
 
 declare const getGuardianList: () => Promise<string[]>;
+interface ActiveGuardian {
+    account: string;
+    guardianPrefs: Record<string, unknown> | null;
+    stakersOverview: Record<string, unknown> | null;
+}
+/**
+ * Current-era on-chain guardians with staking prefs and ledger totals.
+ * Does not disconnect the shared API.
+ */
+declare function getActiveGuardians(apiInstance?: ApiPromise): Promise<ActiveGuardian[]>;
 
 declare const createGuardianGroup: (account: KeyringPair, selectedGuardians: GuardianAddress[]) => Promise<{
     blockNumber: number;
@@ -1324,10 +1847,43 @@ declare const createGuardianGroup: (account: KeyringPair, selectedGuardians: Gua
  * @param maxBlocks  Give up waiting for the event after this many blocks; 0 = indefinite (default 20)
  */
 declare const createGuardianGroupAndWatch: (account: KeyringPair, guardians: GuardianAddress[], maxBlocks?: number) => Promise<GuardianGroupInfo>;
+/**
+ * Reconstructs a guardian group's full crypto params from the two on-chain
+ * extrinsics that together define it. There is no direct RPC to query group
+ * info by ID, so this reads it back from where it was written:
+ *
+ * - `dataAvailability.daccGuardianGroup(selectedGuardians, tauParams)` — the
+ *   creation extrinsic; carries the guardian list.
+ * - `dataAvailability.daccGuardianGroupInfo(groupId, groupPk, tauParams, aggKey)`
+ *   — the result extrinsic (submitted separately once the group's crypto
+ *   params are computed); carries the actual group_id/group_pk/tau_params/agg_key.
+ *
+ * `groupId` isn't a required input — like {@link createGuardianGroupAndWatch},
+ * it's derived from decoding the result extrinsic, not supplied by the caller.
+ *
+ * @param creationRef  Block number + extrinsic index of the group creation extrinsic
+ * @param resultRef    Block number + extrinsic index of the group creation result
+ *                      extrinsic. If omitted, blocks are scanned forward from
+ *                      `creationRef` to find it (see `maxBlocks`).
+ * @param maxBlocks    Only used when `resultRef` is omitted. Give up scanning after
+ *                      this many blocks; 0 = scan to current chain tip (default 20)
+ */
+declare const getGuardianGroupInfo: (creationRef: OnChainRef, resultRef?: OnChainRef, maxBlocks?: number) => Promise<GuardianGroupInfo>;
 
+/** Classes of compute a guardian can declare a fee threshold against. */
+declare const COMPUTE_TYPES: readonly ["trusted", "tee", "mpc", "fhe", "zkp"];
+type ComputeType = (typeof COMPUTE_TYPES)[number];
+/** A rate in atomic units, already converted from PALI by the caller. */
+type FeeThresholdInput = bigint | string | number;
 interface GuardianJoinPrefs {
     compute?: string;
-    fee?: bigint | string | number;
+    /**
+     * Minimum rate to take work on at, in atomic units. A single amount applies to every
+     * compute type named in `compute`; a per-type record prices each one separately.
+     * Compute types left unpriced carry no threshold on chain, which reads as zero — the
+     * guardian accepts any rate for them.
+     */
+    fee?: FeeThresholdInput | Partial<Record<ComputeType, FeeThresholdInput>>;
     standard?: boolean;
     verifier?: boolean;
 }
@@ -1347,6 +1903,36 @@ declare function removeStake(account: KeyringPair): Promise<void>;
 
 declare function withdrawStake(account: KeyringPair): Promise<void>;
 
+interface StorageProvider {
+    /** Unique identifier for the storage backend (e.g., 's3', 'ipfs') */
+    readonly id: string;
+    /** Generates the deterministic URL where the file will be stored */
+    getDeterministicUrl(hash: string): string;
+    /**
+     * Fetches the authorized upload URL (e.g., a Pre-signed URL) from the Auth Service
+     * after the on-chain agreement has been created.
+     */
+    getUploadUrl(txHash: string, fileHash: string, blockNumber: number, expectedUrl: string): Promise<string>;
+    /** Uploads the raw bytes to the authorized URL */
+    upload(url: string, data: Uint8Array): Promise<void>;
+}
+
+declare class S3Provider implements StorageProvider {
+    readonly id = "s3";
+    getDeterministicUrl(hash: string): string;
+    getUploadUrl(txHash: string, fileHash: string, blockNumber: number, expectedUrl: string): Promise<string>;
+    upload(url: string, data: Uint8Array): Promise<void>;
+}
+
+declare class StorageRouter {
+    private providers;
+    private defaultProvider;
+    constructor();
+    register(provider: StorageProvider): void;
+    getProvider(id?: string): StorageProvider;
+}
+declare const storageRouter: StorageRouter;
+
 declare function fundAccount(account: KeyringPair, amountBaseUnits: bigint, address?: string): Promise<void>;
 
 declare function transfer(account: KeyringPair, amountBaseUnits: bigint, address: string): Promise<void>;
@@ -1410,7 +1996,7 @@ declare const base64ToUint8Array: (base64: string) => Uint8Array;
 declare const decodeField: (field: string, expectedLength?: number) => Uint8Array;
 /**
  * Conditional debug logging utility.
- * Only logs when DEBUG flag is enabled in config.
+ * Only logs when the debug flag is enabled in config.
  *
  * @param message - The message to log
  * @param optionalParams - Additional parameters to log
@@ -1419,24 +2005,725 @@ declare const debugLog: (message?: any, ...optionalParams: any[]) => void;
 
 declare function joinValidator(account: KeyringPair, commission: number): Promise<void>;
 
-declare let PALLIORA_WS: string;
-declare let PALLIORA_RPC_URL: string;
-declare let DEBUG: boolean;
-declare let TX_WAIT_FINALIZATION: boolean;
-declare let provider: WsProvider;
-declare function configure(opts: {
-    pallioraWs?: string;
-    pallioraRpcUrl?: string;
-    debug?: boolean;
-    txWaitFinalization?: boolean;
-}): void;
+/** Values the host application must supply through {@link init}. */
+interface PallioraConfig {
+    /** WebSocket endpoint used for the chain API connection. */
+    pallioraWs: string;
+    /** RPC endpoint, when it differs from {@link PallioraConfig.pallioraWs}. */
+    pallioraRpcUrl: string;
+    /** Base URL of the cost-estimation service. */
+    costEstimatorUrl: string;
+    /** Base URL of the auth service that issues S3 pre-signed URLs. */
+    authServiceUrl: string;
+    /** AWS region of the artifact storage bucket. */
+    awsRegion: string;
+    /** Name of the artifact storage bucket. */
+    awsS3Bucket: string;
+    /** Enables debug logging. Defaults to `false`. */
+    debug: boolean;
+    /** Waits for finalization instead of returning once a tx is in-block. Defaults to `false`. */
+    txWaitFinalization: boolean;
+}
+/**
+ * Initializes the SDK. Call this once, before any other SDK function.
+ *
+ * @remarks
+ * Repeated calls merge into the existing configuration, so a host can supply
+ * the chain endpoint at startup and storage settings later.
+ */
+declare function init(options: Partial<PallioraConfig>): void;
+/** Whether {@link init} has been called. */
+declare function isInitialized(): boolean;
+/** Clears the configuration. Intended for tests. */
+declare function resetConfig(): void;
+/** @throws when `pallioraWs` was not supplied to {@link init}. */
+declare const getPallioraWs: () => string;
+/** @throws when `pallioraRpcUrl` was not supplied to {@link init}. */
+declare const getPallioraRpcUrl: () => string;
+/** @throws when `costEstimatorUrl` was not supplied to {@link init}. */
+declare const getCostEstimatorUrl: () => string;
+/** @throws when `authServiceUrl` was not supplied to {@link init}. */
+declare const getAuthServiceUrl: () => string;
+/** @throws when `awsRegion` was not supplied to {@link init}. */
+declare const getAwsRegion: () => string;
+/** @throws when `awsS3Bucket` was not supplied to {@link init}. */
+declare const getAwsS3Bucket: () => string;
+/** Defaults to `false` when not supplied to {@link init}. */
+declare const isDebug: () => boolean;
+/** Defaults to `false` when not supplied to {@link init}. */
+declare const waitsForFinalization: () => boolean;
+/**
+ * Returns the shared {@link WsProvider}, creating it on first use and replacing
+ * it whenever `pallioraWs` changes.
+ *
+ * @throws when `pallioraWs` was not supplied to {@link init}.
+ */
+declare function getProvider(): WsProvider;
 
 interface IdentityFields {
     display?: string;
 }
 declare function setIdentity(account: KeyringPair, { display }: IdentityFields): Promise<void>;
 
+interface IndexerClientOptions {
+    /** Base URL of the indexer server (default: `http://localhost:5020`). */
+    baseUrl?: string;
+    /**
+     * Custom fetch implementation. Defaults to the global `fetch`.
+     * Useful for injecting a test double or a polyfill in older Node versions.
+     */
+    fetch?: typeof globalThis.fetch;
+}
+/**
+ * Lightweight wrapper around `fetch` that targets the `@statescan/indexer` REST API.
+ *
+ * Every public method on the domain modules receives an `IndexerClient` instance,
+ * keeping configuration (base URL, custom fetch) in one place.
+ *
+ * @example
+ * ```ts
+ * import { IndexerClient } from "@palliora.org/chainsdk";
+ *
+ * const client = new IndexerClient({ baseUrl: "https://indexer.palliora.org" });
+ * ```
+ */
+declare class IndexerClient {
+    readonly baseUrl: string;
+    private readonly _fetch;
+    constructor(options?: IndexerClientOptions);
+    /**
+     * Performs a GET request against the indexer and returns the parsed JSON body.
+     *
+     * @throws {IndexerHttpError} When the response indicates failure (`success: false`)
+     *         or the HTTP status is not 2xx.
+     */
+    get<T>(path: string, params?: Record<string, string | number | boolean | null | undefined>): Promise<T>;
+}
+/**
+ * Error thrown when the indexer returns a non-2xx response or an error envelope.
+ */
+declare class IndexerHttpError extends Error {
+    readonly statusCode: number;
+    constructor(statusCode: number, message: string);
+}
+
+/** Common `indexer` subdocument present on most indexed documents. */
+interface IndexerMeta {
+    blockHeight: number;
+    blockHash: string;
+    blockTime: number;
+    extrinsicIndex: number;
+    eventIndex: number;
+}
+/** @deprecated Prefer {@link StoreType}. Kept for backward compatibility. */
+type ArtefactType = StoreType | "Data";
+interface ArtefactDocument {
+    contractId: string;
+    creator: string;
+    owner: string;
+    storeType: StoreType | string | null;
+    contractType: string;
+    status?: string;
+    groupId: string | null;
+    name?: string | null;
+    description?: string | null;
+    /** @deprecated Prefer `storeType`. May be absent on newer documents. */
+    artefactType?: ArtefactType;
+    blobRefs?: Array<[number, number] | unknown>;
+    indexer: IndexerMeta;
+    [key: string]: unknown;
+}
+interface ArtefactsQuery {
+    /** Server-side filter when supported by the indexer. Prefer client helpers for `storeType`. */
+    artefactType?: ArtefactType;
+    storeType?: StoreType;
+}
+interface ArtefactAccessQuery {
+    blockHeight?: number;
+    extrinsicIndex?: number;
+    retriver?: string;
+}
+interface ArtefactContractsQuery {
+    blockHeight?: number;
+    extrinsicIndex?: number;
+    retriver?: string;
+}
+interface ContractResponse {
+    peerId?: string;
+    acceptance?: boolean;
+    creationTime?: number;
+    [key: string]: unknown;
+}
+interface ContractDocument {
+    contractId: string;
+    creator?: string;
+    owner?: string;
+    storeType?: string;
+    contractType?: string;
+    status?: string;
+    groupId?: string;
+    artefactType?: string;
+    parties?: string[];
+    responses?: ContractResponse[];
+    fee?: string | number;
+    creationTime?: number;
+    computeTx?: unknown;
+    indexer?: IndexerMeta;
+    [key: string]: unknown;
+}
+interface ContractsQuery {
+    page?: number;
+    page_size?: number;
+}
+interface ComputeDocument {
+    jobId?: string;
+    contractId?: string;
+    orchestrator?: string;
+    parties?: string[];
+    resultTx?: unknown;
+    computeReward?: string | number;
+    decryptionFee?: unknown;
+    fee?: string | number;
+    indexer?: IndexerMeta;
+    [key: string]: unknown;
+}
+interface ResultFeeParty {
+    recipient?: string;
+    amount?: string;
+    kind?: string;
+    [key: string]: unknown;
+}
+interface ResultFeeBreakdown {
+    inputFee?: ResultFeeParty | null;
+    programFee?: ResultFeeParty | null;
+    thresholdDecryptionFee?: unknown;
+    computeFee?: ResultFeeParty | null;
+    submitorFee?: ResultFeeParty | null;
+    resultFee?: string;
+    totalCharged?: string;
+    reservedFee?: string;
+    refundedAmount?: string;
+    [key: string]: unknown;
+}
+/** One execution stored in `palliora-compute.results`. */
+interface ResultDocument {
+    resultId: string;
+    contractId: string;
+    contractType?: string;
+    submitor?: string;
+    computeDurationMs?: number;
+    executionOutcome?: unknown;
+    feeBreakdown?: ResultFeeBreakdown;
+    indexer?: IndexerMeta;
+    [key: string]: unknown;
+}
+interface ResultsQuery {
+    /** Filter `palliora-compute.results` by parent contract. Required by the indexer. */
+    contractId: string;
+}
+type ContractFlowStatus = "PENDING" | "ACCEPTED" | "PROCESSING" | "COMPLETED";
+interface ContractFlowPhase {
+    id: "phase-1" | "phase-2" | "phase-3" | "phase-4" | "phase-5";
+    title: string;
+    status: string;
+    description: string;
+    json: Record<string, unknown>;
+    active: boolean;
+    complete: boolean;
+    pending: boolean;
+}
+/** Combined compute-contract lifecycle assembled from `/api/contract/:id` + `/api/compute/:id` + `/api/results`. */
+interface ContractFlow {
+    agreement: ContractDocument;
+    /** Latest compute request, if any. Prefer {@link ContractFlow.computes} for session flows. */
+    compute: ComputeDocument | null;
+    /** Every compute request on this agreement, oldest first. */
+    computes: ComputeDocument[];
+    /** Execution rows from `palliora-compute.results` for this contract. */
+    results: ResultDocument[];
+    status: ContractFlowStatus;
+    phases: ContractFlowPhase[];
+}
+/** Combined artefact + access + blobs for a dataset/model/agent detail page. */
+interface ArtefactFlow {
+    artefact: ArtefactDocument;
+    access: unknown[];
+    blobs: BlobDocument[];
+}
+interface BlockDocument {
+    height: number;
+    hash: string;
+    time: number;
+    validator?: string;
+    parentHash?: string;
+    stateRoot?: string;
+    extrinsicsRoot?: string;
+    eventsCount?: number;
+    extrinsicsCount?: number;
+    [key: string]: unknown;
+}
+/** Payload inside `GET /api/blocks` — `{ data: { blocks, stats } }`. */
+interface BlocksData {
+    blocks: BlockDocument[];
+    stats?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+interface BlocksQuery {
+    page?: number;
+    page_size?: number;
+}
+interface Overview {
+    accounts: number;
+    transfers: number;
+    latestHeight: number;
+    avgBlockTime: number;
+    activeValidators: number | null;
+}
+interface ChainEvent {
+    indexer: IndexerMeta;
+    section: string;
+    method: string;
+    [key: string]: unknown;
+}
+interface EventsData {
+    items: ChainEvent[];
+    page: number;
+    pageSize: number;
+}
+interface EventsQuery {
+    page?: number;
+    page_size?: number;
+}
+interface CallDocument {
+    [key: string]: unknown;
+}
+interface CallQuery {
+    blockHeight: number;
+    extrinsicIndex: number;
+}
+interface CallMetadataDocument {
+    [key: string]: unknown;
+}
+interface CallMetadataQuery {
+    blockHeight: number;
+    extrinsicIndex: number;
+}
+interface CallArgsDocument {
+    [key: string]: unknown;
+}
+interface CallArgsQuery {
+    metadataHash: string;
+}
+interface TransferDocument {
+    indexer: IndexerMeta;
+    [key: string]: unknown;
+}
+interface TransfersQuery {
+    page?: number;
+    page_size?: number;
+}
+interface ExtrinsicDocument {
+    indexer: {
+        blockHeight: number;
+        extrinsicIndex: number;
+        blockHash?: string;
+        blockTime?: number;
+        eventIndex?: number;
+    };
+    hash: string;
+    isSigned: boolean;
+    [key: string]: unknown;
+}
+interface ExtrinsicsQuery {
+    page?: number;
+    page_size?: number;
+    /** Set to `"true"` to return only signed extrinsics. */
+    signed_only?: "true" | "false" | boolean;
+}
+interface AddressDocument {
+    address: string;
+    balance: string | number;
+    [key: string]: unknown;
+}
+interface BlobDocument {
+    indexer: IndexerMeta;
+    [key: string]: unknown;
+}
+/**
+ * Identity-enriched guardian from `GET /api/guardian-groups`.
+ * `displayName` is the on-chain identity display, or `null` if none is set.
+ */
+interface GuardianDocument {
+    account: string;
+    displayName: string | null;
+}
+interface GuardianGroupDocument {
+    groupId: string;
+    creator?: string;
+    guardians: string[];
+    /**
+     * Parallel to {@link GuardianGroupDocument.guardians}.
+     * Identity display name for each address, or `null` if unset.
+     */
+    guardianNames: Array<string | null>;
+    groupPk?: string;
+    tauParams?: string;
+    aggKey?: string;
+    status?: string;
+    success?: boolean;
+    indexer?: IndexerMeta;
+    creationTime?: number;
+    [key: string]: unknown;
+}
+interface GuardianGroupsQuery {
+    guardian?: string;
+}
+interface AccessDocument {
+    [key: string]: unknown;
+}
+interface AccessQuery {
+    blockHeight?: number;
+    extrinsicIndex?: number;
+    retriver?: string;
+}
+/** Standard success response: `{ success: true, data: T }`. */
+interface SuccessResponse<T> {
+    success: true;
+    data: T;
+}
+/** Paginated success response: `{ success: true, data: T[], total: number }`. */
+interface PaginatedResponse<T> {
+    success: true;
+    data: T[];
+    total: number;
+}
+/** Access-style success response: `{ success: true, data: T[], message: string }`. */
+interface AccessResponse<T> {
+    success: true;
+    data: T[];
+    message: string;
+}
+/** Address-style response (no `success` flag): `{ data: T }`. */
+interface DataOnlyResponse<T> {
+    data: T;
+}
+/** Error response from the indexer. */
+interface ErrorResponse {
+    success: false;
+    message: string;
+}
+
+/**
+ * Fetch all artefacts, optionally filtered by type.
+ *
+ * `GET /api/artefacts`
+ *
+ * For UI categorization by `storeType`, prefer the dedicated helpers:
+ * {@link getDatasets}, {@link getModels}, {@link getAgents}, {@link getExecutables}.
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   Optional filter — `storeType` / `artefactType`
+ * @returns `{ success: true, data: ArtefactDocument[] }`
+ */
+declare function getArtefacts(client: IndexerClient, query?: ArtefactsQuery): Promise<SuccessResponse<ArtefactDocument[]>>;
+/**
+ * Fetch artefacts filtered by `storeType`.
+ *
+ * Loads `/api/artefacts` and filters client-side so results are reliable even when
+ * the indexer ignores the `storeType` query param.
+ */
+declare function getArtefactsByStoreType(client: IndexerClient, storeType: StoreType): Promise<SuccessResponse<ArtefactDocument[]>>;
+/** Fetch artefacts with `storeType: "Dataset"`. */
+declare function getDatasets(client: IndexerClient): Promise<SuccessResponse<ArtefactDocument[]>>;
+/** Fetch artefacts with `storeType: "Model"`. */
+declare function getModels(client: IndexerClient): Promise<SuccessResponse<ArtefactDocument[]>>;
+/** Fetch artefacts with `storeType: "Agent"`. */
+declare function getAgents(client: IndexerClient): Promise<SuccessResponse<ArtefactDocument[]>>;
+/** Fetch artefacts with `storeType: "Executable"`. */
+declare function getExecutables(client: IndexerClient): Promise<SuccessResponse<ArtefactDocument[]>>;
+/**
+ * Fetch a single artefact by its contract ID.
+ *
+ * `GET /api/artefact/:id`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param id      The `contractId` of the artefact
+ */
+declare function getArtefact(client: IndexerClient, id: string): Promise<SuccessResponse<ArtefactDocument>>;
+/**
+ * Fetch access records for a specific artefact.
+ *
+ * `GET /api/artefact/:id/access`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param id      The `contractId` of the artefact
+ * @param query   Optional filters — `blockHeight`, `extrinsicIndex`, `retriver`
+ */
+declare function getArtefactAccess(client: IndexerClient, id: string, query?: ArtefactAccessQuery): Promise<SuccessResponse<unknown[]>>;
+/** True when `doc` is a compute contract that references this artefact. */
+declare function isArtefactUsage(doc: Record<string, unknown> | null | undefined, artefactId: string): boolean;
+/**
+ * Fetch compute contracts that use this artefact as input or program.
+ *
+ * `GET /api/artefact/:id/contracts`
+ *
+ * Older indexers returned the artefact document itself. In that case this
+ * helper scans `/api/artefacts` and keeps rows that reference the artefact.
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param id      The artefact `contractId`
+ * @param query   Optional filters — `blockHeight`, `extrinsicIndex`, `retriver`
+ */
+declare function getArtefactContracts(client: IndexerClient, id: string, query?: ArtefactContractsQuery): Promise<SuccessResponse<unknown[]>>;
+
+/**
+ * Fetch a paginated list of contracts.
+ *
+ * `GET /api/contracts`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   Pagination — `page` (0-indexed), `page_size` (default 25)
+ * @returns `{ success: true, data: ContractDocument[], total: number }`
+ */
+declare function getContracts(client: IndexerClient, query?: ContractsQuery): Promise<PaginatedResponse<ContractDocument>>;
+/**
+ * Fetch a single contract by its ID.
+ *
+ * `GET /api/contract/:id`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param id      The contract identifier
+ */
+declare function getContract(client: IndexerClient, id: string): Promise<SuccessResponse<ContractDocument>>;
+/**
+ * Fetch compute request data for a specific contract.
+ *
+ * `GET /api/compute/:id`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param id      The contract identifier
+ */
+declare function getCompute(client: IndexerClient, id: string): Promise<SuccessResponse<ComputeDocument>>;
+/**
+ * Fetch compute results for a contract from `palliora-compute.results`.
+ *
+ * `GET /api/results?contractId=`
+ */
+declare function getResults(client: IndexerClient, query: ResultsQuery): Promise<SuccessResponse<ResultDocument[]>>;
+/**
+ * Fetch a single compute result by `resultId`.
+ *
+ * `GET /api/result/:id`
+ */
+declare function getResult(client: IndexerClient, id: string): Promise<SuccessResponse<ResultDocument>>;
+
+type ComputeInput = ComputeDocument | ComputeDocument[] | null | undefined;
+declare function normalizeComputes(compute: ComputeInput): ComputeDocument[];
+/**
+ * Map a `palliora-compute.results` row onto the compute-request shape used by
+ * session phases (jobId, orchestrator, resultTx, fees).
+ */
+declare function resultToCompute(result: ResultDocument): ComputeDocument;
+declare function deriveContractStatus(agreement: ContractDocument | null | undefined, compute: ComputeInput): ContractFlowStatus | "—";
+declare function buildContractPhases(agreement: ContractDocument | null | undefined, compute: ComputeInput): ContractFlowPhase[];
+/**
+ * Fetch a compute contract, optional `/api/compute/:id` payload, and
+ * `palliora-compute.results` rows, then derive session lifecycle status and
+ * the five UI phases used by the explorer.
+ *
+ * Missing compute (`404`) or results (`404`) is treated as empty.
+ */
+declare function getContractFlow(client: IndexerClient, id: string): Promise<SuccessResponse<ContractFlow>>;
+/**
+ * Fetch an artefact together with its access records and blobs.
+ *
+ * Missing access (`404`) becomes `[]`. Missing blobs are skipped.
+ */
+declare function getArtefactFlow(client: IndexerClient, id: string, accessQuery?: ArtefactAccessQuery): Promise<SuccessResponse<ArtefactFlow>>;
+
+/**
+ * Fetch a paginated list of blocks, including chain stats.
+ *
+ * `GET /api/blocks`
+ *
+ * Response shape: `{ success: true, data: { blocks: BlockDocument[], stats? } }`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   Pagination — `page` (0-indexed), `page_size`
+ */
+declare function getBlocks(client: IndexerClient, query?: BlocksQuery): Promise<SuccessResponse<BlocksData>>;
+
+/**
+ * Chain summary used by the explorer home and blocks pages.
+ *
+ * `GET /api/overview`
+ *
+ * @param client  Configured {@link IndexerClient}
+ */
+declare function getOverview(client: IndexerClient): Promise<SuccessResponse<Overview>>;
+
+/**
+ * Paginated chain events, newest block first.
+ *
+ * `GET /api/events`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   Pagination — `page` (0-indexed), `page_size`
+ */
+declare function getEvents(client: IndexerClient, query?: EventsQuery): Promise<SuccessResponse<EventsData>>;
+
+/**
+ * Fetch a call by block height and extrinsic index.
+ *
+ * `GET /api/call`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   **Required** — `blockHeight` and `extrinsicIndex`
+ */
+declare function getCall(client: IndexerClient, query: CallQuery): Promise<SuccessResponse<CallDocument>>;
+/**
+ * Fetch call metadata by block height and extrinsic index.
+ *
+ * `GET /api/call-metadata`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   **Required** — `blockHeight` and `extrinsicIndex`
+ */
+declare function getCallMetadata(client: IndexerClient, query: CallMetadataQuery): Promise<SuccessResponse<CallMetadataDocument>>;
+/**
+ * Fetch call arguments by metadata hash.
+ *
+ * `GET /api/call-args`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   **Required** — `metadataHash`
+ */
+declare function getCallArgs(client: IndexerClient, query: CallArgsQuery): Promise<SuccessResponse<CallArgsDocument>>;
+
+/**
+ * Fetch a paginated list of transfers, sorted by block height descending.
+ *
+ * `GET /api/transfers`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   Pagination — `page` (0-indexed), `page_size`
+ */
+declare function getTransfers(client: IndexerClient, query?: TransfersQuery): Promise<SuccessResponse<TransferDocument[]>>;
+
+/**
+ * Fetch a paginated list of extrinsics, sorted by block height descending.
+ *
+ * `GET /api/extrinsics`
+ *
+ * Fields `nonce`, `_id`, `tip`, and `signature` are excluded by the indexer.
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   Pagination — `page` (0-indexed, default 0), `page_size` (default 10, max 100);
+ *                `signed_only: true` filters to signed extrinsics only
+ * @returns `{ success: true, data: ExtrinsicDocument[], total: number }`
+ */
+declare function getExtrinsics(client: IndexerClient, query?: ExtrinsicsQuery): Promise<PaginatedResponse<ExtrinsicDocument>>;
+/**
+ * Fetch a single extrinsic by block index or transaction hash.
+ *
+ * `GET /api/extrinsic/:indexOrHash`
+ *
+ * Accepts either:
+ * - Block index: `blockHeight-extrinsicIndex` (e.g. `"2528092-2"`)
+ * - Transaction hash: `0x`-prefixed 64-char hex string
+ *
+ * @param client       Configured {@link IndexerClient}
+ * @param indexOrHash  Block-index pair or extrinsic hash
+ * @throws {IndexerHttpError} `400` for invalid id format, `404` when not found
+ */
+declare function getExtrinsic(client: IndexerClient, indexOrHash: string): Promise<SuccessResponse<ExtrinsicDocument>>;
+
+/**
+ * Fetch the top 50 addresses by balance.
+ *
+ * `GET /api/addresses`
+ *
+ * **Note:** This endpoint returns a raw array, not a `{ success, data }` envelope.
+ *
+ * @param client  Configured {@link IndexerClient}
+ */
+declare function getAddresses(client: IndexerClient): Promise<AddressDocument[]>;
+/**
+ * Fetch a single address document.
+ *
+ * `GET /api/address/:address`
+ *
+ * **Note:** This endpoint returns `{ data }` without a `success` field.
+ *
+ * @param client   Configured {@link IndexerClient}
+ * @param address  The substrate address to look up
+ */
+declare function getAddress(client: IndexerClient, address: string): Promise<DataOnlyResponse<AddressDocument>>;
+
+/**
+ * Fetch a blob by its block-height ID.
+ *
+ * `GET /api/blob/:id`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param id      Block height (integer) identifying the blob
+ */
+declare function getBlob(client: IndexerClient, id: number): Promise<SuccessResponse<BlobDocument>>;
+
+/**
+ * Fetch guardian groups, optionally filtered by guardian address.
+ * Results are deduplicated and enriched with identity names.
+ *
+ * `GET /api/guardian-groups`
+ *
+ * Each group includes `guardians: string[]` and a parallel `guardianNames`
+ * array (`string | null`) from the identity database.
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   Optional filter — `guardian` address
+ */
+declare function getGuardianGroups(client: IndexerClient, query?: GuardianGroupsQuery): Promise<SuccessResponse<GuardianGroupDocument[]>>;
+/**
+ * Flatten identity-enriched guardian groups into a unique list of guardians.
+ *
+ * Derived from {@link getGuardianGroups}; there is no separate `/api/guardians`
+ * endpoint. A 404 (no groups) returns an empty list.
+ *
+ * @returns `{ success: true, data: GuardianDocument[] }`
+ *          where each item is `{ account, displayName }`.
+ */
+declare function getGuardians(client: IndexerClient): Promise<SuccessResponse<GuardianDocument[]>>;
+/**
+ * Fetch identity for a single guardian account.
+ *
+ * Uses `GET /api/guardian-groups?guardian=<account>` and returns
+ * `{ account, displayName }`. `displayName` is `null` when the account has
+ * no identity or is not in any indexed group.
+ */
+declare function getGuardian(client: IndexerClient, account: string): Promise<SuccessResponse<GuardianDocument>>;
+/**
+ * Fetch a single guardian group by its group ID.
+ *
+ * `GET /api/guardian-group/:id`
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param id      The `groupId`
+ */
+declare function getGuardianGroup(client: IndexerClient, id: string): Promise<SuccessResponse<GuardianGroupDocument>>;
+
+/**
+ * Fetch access records from the **legacy** statescan-polkadot-data database.
+ *
+ * `GET /api/access`
+ *
+ * > **Deprecated** — superseded by `getArtefactAccess`. Kept for backward compatibility.
+ *
+ * @param client  Configured {@link IndexerClient}
+ * @param query   Optional filters — `blockHeight`, `extrinsicIndex`, `retriver`
+ */
+declare function getAccess(client: IndexerClient, query?: AccessQuery): Promise<AccessResponse<AccessDocument>>;
+
 declare function rotateAndSetKeys(account: KeyringPair): Promise<void>;
 declare function setWorker(account: KeyringPair): Promise<void>;
 
-export { API_EXTENSIONS, API_RPC, API_TYPES, AccountSourceType, type AsymmetricHybridParams, type AsymmetricParams, type AtomicPaliAmount, type BlockScanFilter, type BlockScanResult, type CipherSuite, type ComputeContract, CryptoType, type CurrencyId, DEBUG, DEFAULT_COMPUTE_PAYLOAD, DEFAULT_EMPTY_PAYLOAD, type DataAgreementMetadata, type DataAgreementParams, type DataContractParams, type Ed25519Params, type EncryptedInferenceComputeParams, type EncryptedInferenceSubscriptionInvocationParams, type EncryptedInferenceSubscriptionParams, type Fee, FileFromMetadataRef, type GuardianAddress, type GuardianGroupInfo, type GuardianJoinPrefs, type GuardianParticipants, type IdentityFields, type InferenceComputeParams, type KdfParams, MCryptFs, MCryptFsReader, MCryptFsWriter, type OnChainRef, PALI_DECIMALS, PALI_SYMBOL, PALLIORA_RPC_URL, PALLIORA_WS, type PaliAmountInput, type Secp256k1Params, type SilentThresholdParams, type SimpleComputeParams, type SubmissionReceipt, type SubmitTEDataResult, type SymmetricParams, TX_WAIT_FINALIZATION, type ThresholdHybridParams, type ThresholdParams, type UploadOptions, addStake, base64ToUint8Array, buildFee, clearTokenCache, configure, createAccount, createAgreement, createGuardianGroup, createGuardianGroupAndWatch, createSimpleAgreement, dataContract, debugLog, decodeAggregateKey, decodeField, decodePowersOfTau, decrypt, encrypt as ecncryptTest, encodeCiphertext, encrypt$1 as encrypt, encryptedInferenceCompute, encryptedInferenceSubscription, encryptedInferenceSubscriptionInvocation, fetchAndDecodeExtrinsic, fetchTokenProperties, formatBalanceWithTokenProperties, formatPaliAmount, fromAtomicPaliAmount, fundAccount, gen_shared_key, gen_stretched_key, generateRandomBytes, getAgreementCreatedRequestId, getApi, getCachedTokenProperties, getEncKeyring, getFileMetadataCall, getGuardianAddress, getGuardianList, getGuardianNwParams, getGuardianParticipants, getKeyring, hexToUint8Array, inferenceCompute, joinGuardian, joinIdleStaker, joinValidator, newStake, pairFromPrivateKeyHex, payoutStake, provider, reduceStake, registerDataAgreement, removeStake, rotateAndSetKeys, runAgent, scanForBlockEvent, setIdentity, setWorker, signAndSend, simpleCompute, submitData, submitTEData, submitTEDataWithCipher, testCrypt, toAtomicPaliAmount, tokenToBigint, transfer, uint8ArrayToBase64, uploadData, uploadDataLegacy, watchForSubmissionReceipt, withdrawStake, writeMetadata };
+export { API_EXTENSIONS, API_RPC, API_TYPES, type AccessDocument, type AccessQuery, type AccessResponse, type AccountInfo, AccountSourceType, type ActiveGuardian, type AddressDocument, type AgreementStatus, type ArtefactAccessQuery, type ArtefactContractsQuery, type ArtefactDocument, type ArtefactFlow, type ArtefactType, type ArtefactsQuery, type AsymmetricHybridParams, type AsymmetricParams, type AtomicPaliAmount, type AuctionDetail, type AuctionWinner, type Balance, type BlobDocument, type BlockDocument, type BlockScanFilter, type BlockScanResult, type BlocksData, type BlocksQuery, COMPUTE_TYPES, type CallArgsDocument, type CallArgsQuery, type CallDocument, type CallMetadataDocument, type CallMetadataQuery, type CallQuery, type ChainEvent, type CipherSuite, type ComputeContract, type ComputeDocument, type ComputeMetadataInput, type ComputeMode, type ComputeType, type ContractDocument, type ContractFlow, type ContractFlowPhase, type ContractFlowStatus, type ContractInfo, type ContractParams, type ContractResponse, type ContractType, type ContractsQuery, CostEstimationError, CryptoType, type CurrencyId, DEFAULT_COMPUTE_PAYLOAD, DEFAULT_EMPTY_PAYLOAD, type DataAgreementMetadata, type DataAgreementParams, type DataContractParams, type DataOnlyResponse, type Ed25519Params, type EncryptedInferenceComputeParams, type EncryptedInferenceSubscriptionInvocationParams, type EncryptedInferenceSubscriptionParams, type ErrorResponse, type EstimateResult, type EstimateStatusResponse, type EventsData, type EventsQuery, type ExtrinsicDocument, type ExtrinsicsQuery, type Fee, type FeeParams, type FeeThresholdInput, FileFromMetadataRef, type GuardianAddress, type GuardianDocument, type GuardianEntry, type GuardianGroupDocument, type GuardianGroupInfo, type GuardianGroupsQuery, type GuardianJoinPrefs, type GuardianParticipants, type IdentityFields, IndexerClient, type IndexerClientOptions, IndexerHttpError, type IndexerMeta, type InferenceComputeParams, type InvokeAgreementInput, type KdfParams, type LatestBlock, type LatestBlocksResult, MCryptFs, MCryptFsReader, MCryptFsWriter, type MinFeeBreakdown, type MinFeeInput, NO_GUARDIAN_GROUP, type OnChainRef, type OpenAuction, type Overview, PALI_DECIMALS, PALI_SYMBOL, type PaginatedResponse, type PaliAmountInput, type PallioraConfig, type ResolvedAuction, type ResultDocument, type ResultFeeBreakdown, type ResultFeeParty, type ResultsQuery, S3Provider, type Secp256k1Params, type SilentThresholdParams, type SimpleComputeParams, type StartedEstimate, type StorageProvider, StorageRouter, type StoreType, type StoredComputeParams, type SubmissionReceipt, type SubmitTEDataResult, type SuccessResponse, type SymmetricParams, type ThresholdHybridParams, type ThresholdParams, type TransferDocument, type TransfersQuery, type UploadOptions, type WaitForEstimateOptions, addStake, base64ToUint8Array, buildComputeMetadata, buildContractPhases, buildFee, clearTokenCache, createAccount, createAccountFromMagicLink, createAgreement, createGuardianGroup, createGuardianGroupAndWatch, createSimpleAgreement, dataContract, debugLog, decodeAggregateKey, decodeField, decodePowersOfTau, decrypt, deriveContractStatus, disconnectApi, encrypt as ecncryptTest, encodeCiphertext, encrypt$1 as encrypt, encryptedInferenceCompute, encryptedInferenceSubscription, encryptedInferenceSubscriptionInvocation, estimateMinFee, fetchAndDecodeExtrinsic, fetchTokenProperties, findEvent, formatBalanceWithTokenProperties, formatPaliAmount, fromAtomicPaliAmount, fundAccount, gen_shared_key, gen_stretched_key, generateRandomBytes, getAccess, getAccountInfo, getActiveGuardians, getAddress, getAddresses, getAgents, getAgreementCreatedRequestId, getApi, getArtefact, getArtefactAccess, getArtefactContracts, getArtefactFlow, getArtefacts, getArtefactsByStoreType, getAuction, getAuthServiceUrl, getAwsRegion, getAwsS3Bucket, getBalance, getBlob, getBlocks, getCachedTokenProperties, getCall, getCallArgs, getCallMetadata, getCompute, getContract, getContractFlow, getContractInfo, getContracts, getCostEstimatorUrl, getDatasets, getEncKeyring, getEstimateResult, getEvents, getExecutables, getExtrinsic, getExtrinsics, getFeeParams, getFileMetadataCall, getGuardian, getGuardianAddress, getGuardianGroup, getGuardianGroupInfo, getGuardianGroups, getGuardianList, getGuardianNwParams, getGuardianParticipants, getGuardians, getKeyring, getLatestBlocks, getModels, getOverview, getPallioraRpcUrl, getPallioraWs, getProvider, getResult, getResults, getTransfers, healthCheck, hexToUint8Array, inferenceCompute, init, invokeAgreement, isArtefactUsage, isDebug, isInitialized, joinGuardian, joinIdleStaker, joinValidator, listGuardianAuctions, listOpenAuctions, listResolvedGuardianAuctions, newStake, normalizeComputes, pairFromPrivateKeyHex, payoutStake, reduceStake, registerDataAgreement, registerGuardianWebhook, removeStake, resetConfig, resultToCompute, retrySignAndSend, rotateAndSetKeys, runAgent, scanForBlockEvent, setIdentity, setWorker, signAndSend, simpleCompute, startEstimate, storageRouter, storedCompute, submitAuctionBid, submitData, submitTEData, submitTEDataWithCipher, testCrypt, toAtomicPaliAmount, tokenToBigint, transfer, uint8ArrayToBase64, uploadData, uploadDataLegacy, waitForEstimate, waitForNextBlock, waitsForFinalization, watchForSubmissionReceipt, withdrawStake, writeMetadata };