@molpha/sdk 0.1.0 → 0.2.0-dev-20260911113923

package/dist/index.d.ts

@@ -1,13 +1,70 @@
 import { Address } from '@solana/kit';
 import { Wallet, Idl, AnchorProvider } from '@anchor-lang/core';
-import { R as RegistrySelectionConfig, S as Signer, N as NodeKeyVerifier, a as Node, A as APIConfig, D as DataUpdateResult, b as SolanaConnection, c as SolanaAddress, d as NodeKeyVerifierArgs, e as SolanaAccountMeta, M as MolphaWallet } from './wallet-CbpYQO4l.js';
-export { E as EncKeyBundle, f as SchnorrSignature, g as gatewaySignerFromWallet, s as signerFromKeypair } from './wallet-CbpYQO4l.js';
+import { R as RegistrySelectionConfig, S as Signer, N as NodeKeyVerifier, a as Node, A as APIConfig, D as DataUpdateResult, b as SolanaAccountMeta, c as SolanaConnection, d as SolanaAddress, e as NodeKeyVerifierArgs, M as MolphaWallet } from './wallet-udLZ5Iy0.js';
+export { E as EncKeyBundle, f as SchnorrSignature, g as gatewaySignerFromWallet, s as signerFromKeypair } from './wallet-udLZ5Iy0.js';
 import BN from 'bn.js';
 
-interface RequestSignedDataOptions {
-    feedId: string;
+/**
+ * Gateway on-chain identity. The request-auth hash binds the Gateway PDA
+ * (`["molpha_gateway", gatewayAuthority]`), so the client must know which gateway it is
+ * talking to. Kit-only — no `@anchor-lang/core` / web3.js on the gateway path.
+ */
+
+/** One gateway endpoint plus, optionally, the authority key its `Gateway` PDA derives from. */
+interface GatewayEndpoint {
+    /** Base URL, e.g. `https://gateway.example.com` (trailing slash ignored). */
+    url: string;
+    /**
+     * Base58 Solana pubkey of the gateway's signing authority. When omitted the client
+     * fetches it once from `GET {url}/v1/info` (`data.gatewayAuthority`) the first time an
+     * authenticated request targets this endpoint.
+     */
+    gatewayAuthority?: string;
+}
+type GatewayEndpointInput = string | GatewayEndpoint;
+/** Payload of `GET /v1/info` (inside the usual `{ status, data }` envelope). */
+interface GatewayInfo {
+    gatewayAuthority: string;
+    /** Program id the gateway settles against; must match the client's when present. */
+    programId?: string;
+}
+declare function normalizeEndpoint(input: GatewayEndpointInput): GatewayEndpoint;
+/** 32-byte form of a base58 address. */
+declare function addressToBytes(value: string): Uint8Array;
+/** `["molpha_gateway", gatewayAuthority]` under `programId`, as a base58 address. */
+declare function deriveGatewayPdaAddress(gatewayAuthority: string, programId: string): Promise<Address>;
+/** 32-byte Gateway PDA — the `gateway` field of `RequestAuth`. */
+declare function deriveGatewayPda(gatewayAuthority: string, programId: string): Promise<Uint8Array>;
+/** Validate an unwrapped `/v1/info` payload. */
+declare function parseGatewayInfo(data: unknown): GatewayInfo;
+
+declare const REQUEST_AUTH_DOMAIN: Uint8Array;
+interface RequestAuthFields {
+    /** Program id, 32 bytes (see `addressToBytes` for base58). */
+    programId: Uint8Array;
+    /** Gateway PDA `["molpha_gateway", gatewayAuthority]`, 32 bytes (see `deriveGatewayPda`). */
+    gateway: Uint8Array;
+    /** 32-byte source id, hex or bytes. */
+    sourceId: Uint8Array | string;
+    /** u8 — the per-request quorum. */
     signaturesRequired: number;
+    /** u64 unix seconds. */
+    timestamp: number | bigint;
+}
+/** Borsh encoding of `RequestAuth` — the hash body, without the domain. */
+declare function encodeRequestAuth(fields: RequestAuthFields): Uint8Array;
+/** `keccak256(REQUEST_AUTH_DOMAIN || encodeRequestAuth(fields))` — the message the consumer signs. */
+declare function hashRequestAuth(fields: RequestAuthFields): Uint8Array;
+
+interface RequestSignedDataOptions {
+    /**
+     * The API definition to resolve. Its canonical form determines the round's
+     * `sourceId = keccak256(JSON.stringify(canonicalizeAPIConfig(apiConfig)))`, so pass the
+     * same config (including `{{secret.*}}` placeholders) every time.
+     */
     apiConfig: APIConfig;
+    /** Requested quorum (u8, ≥ the protocol `min_signers`). */
+    signaturesRequired: number;
     /**
      * Solana pubkey (base58) of the subscription owner.
      * Overrides the gateway's `defaultSubscriptionOwner` when set.
@@ -19,9 +76,10 @@ interface RequestSignedDataOptions {
      */
     consumerAuthority?: string;
     /**
-     * Signs `authMessage(feedId, timestamp)`. Overrides the gateway's
-     * `defaultSigner` when set. When both are omitted, sends all-zero authSig
-     * (dev only).
+     * Signs `hashRequestAuth({ programId, gateway, sourceId, signaturesRequired, timestamp })`.
+     * The hash binds the gateway's on-chain account, so it is computed — and the signer
+     * invoked — once per endpoint actually tried. Overrides the gateway's `defaultSigner`
+     * when set. When both are omitted, sends an all-zero authSig (dev only).
      */
     signer?: Signer;
     encrypt?: {
@@ -40,8 +98,8 @@ interface RequestSignedDataOptions {
      * {@link MolphaGateway.prepareContext}.
      *
      * Caching is opt-in because these inputs can drift: a stale `registryVersion`,
-     * `redundancyBuffer`, or `nodes` set produces a result the chain will reject.
-     * Refresh the context when the on-chain registry version changes.
+     * `redundancyBuffer`, `nodeCount`, or `nodes` set produces a result the chain will
+     * reject. Refresh the context when the on-chain registry version changes.
      */
     context?: Partial<RoundContext>;
     /**
@@ -61,6 +119,11 @@ interface MolphaGatewayOptions {
     defaultSubscriptionOwner?: string;
     /** Solana pubkey (base58) of the consumer authority used when a request omits it. */
     defaultConsumerAuthority?: string;
+    /**
+     * Molpha program id the request authorization is bound to. Defaults to the vendored
+     * `MOLPHA_PROGRAM_ID`; must match the gateway's deployment.
+     */
+    programId?: string;
     /**
      * Authenticates selected gateway node encryption keys before private API
      * secrets are encrypted.
@@ -74,10 +137,10 @@ interface MolphaGatewayOptions {
 }
 /**
  * The slow-changing inputs a `requestSignedData` round binds to. Fetch once with
- * {@link MolphaGateway.prepareContext} and reuse across many rounds
+ * {@link MolphaGateway.prepareContext} and reuse across many rounds.
  */
 interface RoundContext extends RegistrySelectionConfig {
-    /** Full node set used to derive the selection bitmap. */
+    /** Full node set used to encrypt private API secrets for the selected nodes. */
     nodes: Node[];
 }
 /** Default gateway base URL when `endpoints` is omitted. */
@@ -95,7 +158,12 @@ declare class MolphaGateway {
     private readonly defaultConsumerAuthority?;
     private readonly verifyNodeKeys?;
     private readonly allowUnverifiedNodeKeysForPrivateApi;
-    constructor(endpoints?: string | string[], getRegistrySelectionConfig?: () => Promise<RegistrySelectionConfig>, defaultSigner?: Signer, 
+    /** Program id the request authorization is bound to (base58). */
+    readonly programId: string;
+    private readonly programIdBytes;
+    /** Gateway PDA per endpoint URL; resolved once per client lifetime. */
+    private readonly gatewayPdas;
+    constructor(endpoints?: GatewayEndpointInput | GatewayEndpointInput[], getRegistrySelectionConfig?: () => Promise<RegistrySelectionConfig>, defaultSigner?: Signer, 
     /**
      * Either a default subscription owner (base58) or gateway options. A string
      * keeps the previous positional form used by standalone callers/tests.
@@ -104,40 +172,90 @@ declare class MolphaGateway {
     /** Tries endpoints in order; returns the first node list it can fetch. */
     getNodes(): Promise<Node[]>;
     isHealthy(): Promise<boolean>;
+    /**
+     * `GET {url}/v1/info` — the gateway's on-chain identity. Throws when the gateway
+     * reports a `programId` different from this client's.
+     */
+    fetchGatewayInfo(endpoint: GatewayEndpointInput, timeoutMs?: number): Promise<GatewayInfo>;
     /**
      * Fetch the slow-changing round inputs (registry version, redundancy buffer,
-     * node set) once so they can be reused across many {@link requestSignedData}
-     * calls. Pass the result back via `requestSignedData({ ..., context })` to
-     * skip the prelude and run a single-round "short" flow.
+     * node count, node set) once so they can be reused across many
+     * {@link requestSignedData} calls. Pass the result back via
+     * `requestSignedData({ ..., context })` to skip the prelude and run a
+     * single-round "short" flow.
      *
-     * Both fetches run in parallel. Registry version and redundancy buffer come
-     * from a single on-chain `RegistryState` read.
+     * Both fetches run in parallel. Registry version, redundancy buffer and node
+     * count come from the on-chain registry read.
      */
-    prepareContext(_feedId: string): Promise<RoundContext>;
+    prepareContext(): Promise<RoundContext>;
     /**
      * Request a threshold-signed data update from the gateway, with retry +
      * failover. Per attempt a fresh timestamp yields a fresh selection bitmap; the
      * body is POSTed to each endpoint in order until one `completed`s.
      *
-     * By default this fetches the registry selection config and node set up front
-     * (in parallel). Supply `opts.context` (e.g. from {@link prepareContext}) to
-     * reuse cached inputs and skip those fetches — a fully-populated context
-     * collapses the call to a single POST round.
+     * The round's `sourceId` is derived from `apiConfig`. The request authorization
+     * binds the program id and each gateway's on-chain account, so the auth signature
+     * is recomputed for every endpoint tried.
+     *
+     * By default this fetches the registry selection config up front and the node
+     * set only when the round needs it (private API encryption, or when the registry
+     * read does not report `nodeCount`). Supply `opts.context` (e.g. from
+     * {@link prepareContext}) to reuse cached inputs and skip those fetches — a
+     * fully-populated context collapses the call to a single POST round.
      */
     requestSignedData(opts: RequestSignedDataOptions): Promise<DataUpdateResult>;
     /**
      * Resolve the round inputs, fetching only the fields absent from `cached`.
-     * Registry version and redundancy buffer are treated as a unit (one account
-     * read). Whatever fetching remains runs in parallel.
+     * Registry version, redundancy buffer and node count are treated as a unit (one
+     * snapshot read). The node list is fetched only when `needNodes` (private API
+     * encryption) or when nothing else can tell us the node count.
      */
     private resolveContext;
+    /** Gateway PDA bytes for an endpoint, cached per URL. A failed lookup is not cached. */
+    private resolveGatewayPda;
+    private lookupGatewayPda;
     private firstReachableData;
     private post;
+    private fetchWithTimeout;
+}
+
+/**
+ * Account views and remaining-accounts construction for `submit_attestation`.
+ */
+
+/** On-chain `RegistryState` (Anchor camelCase): pointer to the current immutable snapshot. */
+interface RegistryStateView {
+    currentVersion: number;
+    nextVersion: number;
 }
+/**
+ * Immutable, version-addressed `Registry` snapshot. `nodes` holds only the populated
+ * `[..nodeCount]` entries; entry `i` is the `Node` account address for signer bit `i`.
+ */
+interface RegistryView {
+    version: number;
+    nodeCount: number;
+    /** Selection padding: `min(signaturesRequired + redundancyBuffer, nodeCount)`. */
+    redundancyBuffer: number;
+    nodes: Address[];
+    /** Unix seconds until which this superseded snapshot still verifies; `0n` while current. */
+    graceActiveUntil: bigint;
+}
+/** Set-bit indices of a 32-byte big-endian bitmap (full 256-bit scan). */
+declare function bitmapToIndices(signersBitmapHex: string): number[];
+/**
+ * Signer `Node` accounts for `submit_attestation`, in ascending signers-bitmap bit order.
+ * Bit `i` resolves to `registry.nodes[i]` of the snapshot the round was signed against;
+ * a bit at or beyond `nodeCount` can never verify, so it is rejected client-side.
+ */
+declare function resolveRemainingAccounts(signersBitmapHex: string, registry: RegistryView): SolanaAccountMeta[];
 
 /** On-chain subscription plan (`PlanType` in the Molpha program IDL). */
 declare enum PlanType {
-    Basic = 0
+    Basic = 0,
+    Standard = 1,
+    Professional = 2,
+    Enterprise = 3
 }
 /** Numeric plan index used for PDA derivation and on-chain reads. */
 type PlanId = 0 | 1 | 2 | 3;
@@ -155,9 +273,9 @@ declare function planIdFromVariant(variant: Record<string, unknown>): PlanId;
 
 /**
  * `MolphaSolanaClient` — consumer on-chain surface only (subscribe, extend,
- * submitDataUpdate, readFeed/readPlan/readSubscription,
- * getRegistrySelectionConfig, verifyNodeKeysForPrivateApi). Built from an
- * Anchor `Program` over the vendored IDL.
+ * submitAttestation, readFeed/readPlan/readSubscription/readRegistry,
+ * getRegistrySelectionConfig, verifyNodeKeysForPrivateApi). Built from an Anchor
+ * `Program` over the vendored IDL.
  */
 
 type Commitment$1 = NonNullable<ConstructorParameters<typeof AnchorProvider>[2]>["commitment"];
@@ -172,6 +290,8 @@ interface PlanInfo {
     subscriptionPrice: bigint;
     maxSigners: number;
     maxDelegates: number;
+    /** Rounds a subscription on this plan may settle per period. */
+    maxRounds: bigint;
     privateApiEnabled: boolean;
     isActive: boolean;
 }
@@ -192,21 +312,36 @@ interface SubscriptionInfo {
 }
 interface SubmitResult {
     signature: string;
+    /** Feed PDA written by this submit (`["molpha_feed", sourceId, [signaturesRequired], submitter]`). */
+    feed: Address;
 }
 interface FeedAccount {
-    feedId: number[];
-    value: number[];
+    sourceId: number[];
+    /** Stored payload: raw value (`valueKind.value`) or keccak digest (`valueKind.hash`), ≤ 32 bytes. */
+    value: Uint8Array | number[];
     valueKind: {
         value: Record<string, never>;
     } | {
         hash: Record<string, never>;
     };
+    /** u64 unix seconds. */
     canonicalTimestamp: BN;
     signaturesRequired: number;
     signersBitmap: number[];
     registryVersion: number;
     bump: number;
 }
+/** Anchor-encoded `SubmitAttestationArgs` (camelCase field names). */
+interface SubmitAttestationArgs {
+    sourceId: number[];
+    registryVersion: number;
+    value: number[];
+    canonicalTimestamp: BN;
+    signaturesRequired: number;
+    aggSigS: number[];
+    commitment: number[];
+    signersBitmap: number[];
+}
 interface CreateClientOpts {
     connection: SolanaConnection;
     wallet: Wallet;
@@ -225,12 +360,15 @@ declare class MolphaSolanaClient {
     private get methods();
     private get accounts();
     /**
-     * Current registry version and selection `redundancy_buffer` from a single
-     * `RegistryState` account read. Prefer this over {@link getRegistryVersion}
-     * when deriving gateway selection bitmaps.
+     * Current registry version plus the selection inputs of that snapshot
+     * (`redundancy_buffer`, `node_count`). Two account reads: `RegistryState`, then the
+     * version-addressed `Registry`. Prefer this over {@link getRegistryVersion} when
+     * deriving gateway selection bitmaps.
      */
-    getRegistrySelectionConfig(): Promise<RegistrySelectionConfig>;
+    getRegistrySelectionConfig(): Promise<Required<RegistrySelectionConfig>>;
     getRegistryVersion(): Promise<number>;
+    /** Read an immutable registry snapshot; defaults to the current version. */
+    readRegistry(version?: number): Promise<RegistryView>;
     /** Fetch a plan's on-chain terms, including the USDC `subscriptionPrice` charged on `subscribe`. */
     getPlan(plan: PlanType): Promise<PlanInfo>;
     /** Read a plan account, or `null` if it has not been initialized. */
@@ -267,30 +405,59 @@ declare class MolphaSolanaClient {
      * the caller agreed to pay. Returns the price (USDC base units) on success.
      */
     private confirmPlanPrice;
+    /**
+     * Submit a gateway attestation via `submit_attestation`. The feed account for
+     * `(sourceId, signaturesRequired, submitter)` is created on first use. Signer
+     * `Node` accounts are resolved from the registry snapshot the round was signed
+     * against and passed as remaining accounts.
+     */
+    submitAttestation(result: DataUpdateResult, opts?: {
+        computeUnitLimit?: number;
+    }): Promise<SubmitResult>;
+    /** @deprecated Renamed to {@link submitAttestation}. */
     submitDataUpdate(result: DataUpdateResult, opts?: {
         computeUnitLimit?: number;
     }): Promise<SubmitResult>;
-    readFeed(feedId: string): Promise<FeedAccount | null>;
+    /**
+     * Read the feed written by `submitter` (default: this wallet) for
+     * `(sourceId, signaturesRequired)`, or `null` before its first submit.
+     */
+    readFeed(sourceId: string, signaturesRequired: number, submitter?: SolanaAddress): Promise<FeedAccount | null>;
     /**
      * Authenticate gateway-provided private API encryption keys against the
-     * on-chain Node accounts for the round's registry version.
+     * on-chain Node accounts of the round's registry snapshot (`registry.nodes[index]`).
      */
     verifyNodeKeysForPrivateApi(args: NodeKeyVerifierArgs): Promise<void>;
-    private buildSubmitArgs;
     private decodePlan;
+    private fetchRegistryState;
     private fetchRegistry;
     private fetchNodeAccount;
+    /** `usdc_mint` from `ProtocolConfig`; the treasury is its ATA owned by the config PDA. */
     private fetchProtocolTokens;
 }
+/** Build the Anchor `SubmitAttestationArgs` for a gateway result. */
+declare function buildSubmitAttestationArgs(result: DataUpdateResult): SubmitAttestationArgs;
 
 /** Gateway wire shape — defaults applied before hash / encryption. */
 declare function canonicalizeAPIConfig(apiConfig: APIConfig): APIConfig;
 /**
- * `apiConfigHash = keccak256(JSON.stringify(canonical apiConfig))`.
- * Pass the same config (including `{{secret.*}}` placeholders) you will send to
- * `MolphaGateway.requestSignedData` when deriving a feed id.
+ * `sourceId = keccak256(JSON.stringify(canonical apiConfig))` — the 32-byte identity of a
+ * data source. Hash the same config (including `{{secret.*}}` placeholders) you send to
+ * `MolphaGateway.requestSignedData`; the gateway and every verifier recompute it from
+ * `apiConfig`.
  */
-declare function deriveApiConfigHash(apiConfig: APIConfig): Uint8Array;
+declare function deriveSourceId(apiConfig: APIConfig): Uint8Array;
+/** Hex-encoded {@link deriveSourceId} (64 lowercase hex chars, no `0x`). */
+declare function deriveSourceIdString(apiConfig: APIConfig): string;
+/** @deprecated Renamed to {@link deriveSourceId}; identical bytes. */
+declare const deriveApiConfigHash: typeof deriveSourceId;
+
+/**
+ * Protocol-wide constants that must stay in sync with the vendored IDL. Kept as plain
+ * literals so gateway-only / browser bundles never pull in `idl/molpha.json`.
+ */
+/** Molpha program id (`idl/molpha.json` → `address`). Asserted equal in `test/gateway-auth.test.ts`. */
+declare const MOLPHA_PROGRAM_ID = "MoLFnEbuMS5gWnXNfUMLAYSqRM3eQZKWRzjeMQfqbT3";
 
 declare const utf8: (s: string) => Uint8Array;
 declare const concatBytes: (...arrays: Uint8Array[]) => Uint8Array;
@@ -317,15 +484,25 @@ declare function ensureLength(bytes: Uint8Array, len: number, label: string): Ui
 /** Coerce hex string or bytes to a fixed-length byte array. */
 declare function toFixedBytes(value: string | Uint8Array, len: number, label: string): Uint8Array;
 
-/**
- * `feedId = keccak256(FEED_ID_PREFIX || owner || apiConfigHash || [signaturesRequired])`.
- * @param owner 32-byte owner pubkey.
- * @param apiConfigHash 32-byte API config hash.
- * @param signaturesRequired Per-feed quorum threshold (u8 on-chain).
- */
-declare function deriveFeedId(owner: Uint8Array, apiConfigHash: Uint8Array, signaturesRequired: number): Uint8Array;
-/** Hex-encoded `deriveFeedId` (64 lowercase hex chars). */
-declare function deriveFeedIdString(owner: Uint8Array, apiConfigHash: Uint8Array, signaturesRequired: number): string;
+/** `keccak256("MOLPHA_MESSAGE_V1")` domain separator. */
+declare const MESSAGE_PREFIX: Uint8Array;
+interface AttestationMessageFields {
+    /** 32-byte source id (hex or bytes). */
+    sourceId: string | Uint8Array;
+    registryVersion: number;
+    /** Encoded as `uint32` in the message even though the program stores a `u8`. */
+    signaturesRequired: number;
+    /** 32-byte big-endian signers bitmap (hex or bytes). */
+    signersBitmap: string | Uint8Array;
+    /** 32-byte packed value (hex or bytes). */
+    value: string | Uint8Array;
+    /** Unix seconds (u64). */
+    canonicalTimestamp: number | bigint;
+}
+/** Compute the attestation message hash (32 bytes). */
+declare function attestationMessageHash(fields: AttestationMessageFields): Uint8Array;
+/** Message hash of a completed gateway round (`valuePacked` is the signed value). */
+declare function attestationMessageHashFromResult(result: DataUpdateResult): Uint8Array;
 
 /**
  * Parse a secp256k1 public key and return canonical compressed lower-case hex.
@@ -336,9 +513,9 @@ declare function normalizeSecp256k1PublicKeyHex(publicKeyHex: string, label?: st
 declare function secp256k1PublicKeyFromCoordinates(x: Uint8Array, y: Uint8Array, label?: string): string;
 
 /**
- * `seed = keccak256(keccak256("MOLPHA_SELECTION_V1") || feedId || be32(rv) || be64(ts))`.
+ * `seed = keccak256(keccak256("MOLPHA_SELECTION_V1") || sourceId || be32(rv) || be64(ts))`.
  */
-declare function deriveSelectionSeed(feedId: Uint8Array, registryVersion: number, canonicalTimestamp: number | bigint): Uint8Array;
+declare function deriveSelectionSeed(sourceId: Uint8Array, registryVersion: number, canonicalTimestamp: number | bigint): Uint8Array;
 /** `min(signaturesRequired + redundancyBuffer, nodeCount)`. */
 declare function effectiveSelectionSize(signaturesRequired: number, redundancyBuffer: number, nodeCount: number): number;
 /** Is bit `bit` set in the 32-byte big-endian `bitmap`? */
@@ -355,11 +532,13 @@ declare function deriveGroupBitmap(seed: Uint8Array, nodeCount: number, groupSiz
  * Convenience orchestrator: derive the selection bitmap end-to-end.
  * `redundancy` defaults to 0; `ts` defaults to the current unix second.
  */
-declare function deriveSelectionBitmap(feedId: Uint8Array, registryVersion: number, nodeCount: number, signaturesRequired: number, redundancy?: number, ts?: number | bigint): Uint8Array;
+declare function deriveSelectionBitmap(sourceId: Uint8Array, registryVersion: number, nodeCount: number, signaturesRequired: number, redundancy?: number, ts?: number | bigint): Uint8Array;
 
 /**
  * Minimal Molpha verifier ABI for `verify` and registry reads.
- * Matches `IValidator` in the Molpha EVM contracts repo.
+ * Matches the deployed `verify(DataUpdate, SchnorrSignature)` verifier. The first tuple
+ * component carries the 32-byte source id (the contract source names it `jobId`;
+ * component names do not affect ABI encoding).
  */
 declare const MOLPHA_VERIFIER_ABI: readonly [{
     readonly type: "function";
@@ -369,7 +548,7 @@ declare const MOLPHA_VERIFIER_ABI: readonly [{
         readonly name: "dataUpdate";
         readonly type: "tuple";
         readonly components: readonly [{
-            readonly name: "jobId";
+            readonly name: "sourceId";
             readonly type: "bytes32";
         }, {
             readonly name: "registryVersion";
@@ -422,9 +601,9 @@ type MolphaEvmNetwork = "evm-sepolia" | "arbitrum-sepolia" | "avalanche-fuji" |
 /** CREATE2 Molpha verifier address — identical on all supported EVM chains. */
 declare const MOLPHA_VERIFIER_ADDRESS: "0xE1fd792b7E54e0C8F0Cd1c8055E446ff36d233eB";
 
-/** `(bytes32 feedId, uint32 registryVersion, uint32 signaturesRequired, bytes32 valuePacked, uint64 timestamp)` */
+/** `(bytes32 sourceId, uint32 registryVersion, uint32 signaturesRequired, bytes32 valuePacked, uint64 timestamp)` */
 type EvmDataUpdateTuple = readonly [
-    feedId: `0x${string}`,
+    sourceId: `0x${string}`,
     registryVersion: number,
     signaturesRequired: number,
     valuePacked: `0x${string}`,
@@ -466,7 +645,8 @@ declare function getMolphaStarknetVerifierAddress(network: MolphaStarknetNetwork
 
 /** Starknet calldata shape for `DataUpdate`. */
 interface StarknetDataUpdate {
-    feed_id: bigint;
+    /** 32-byte source id as u256 (the Cairo struct still names this field `feed_id`). */
+    source_id: bigint;
     registry_version: number;
     signatures_required: number;
     value: bigint;
@@ -490,49 +670,31 @@ declare function signersBitmapToStarknetUint256(value: string): bigint;
 declare function buildStarknetVerifierArgs(result: DataUpdateResult): StarknetVerifierArgs;
 
 /**
- * Consumer PDA derivations (no node PDA). Seed byte strings are cross-checked
- * against the IDL const seeds.
+ * Consumer PDA derivations. Seed byte strings are cross-checked against the IDL const
+ * seeds in `test/solana.test.ts` / `test/idl.test.ts`.
  */
 
-/** Virtual registry index used for a removed slot during a version transition. */
-declare const VIRTUAL_INDEX = 4294967295;
 declare const protocolConfigPda: (programId: SolanaAddress) => Address;
+/** Mutable pointer to the current registry snapshot: `["molpha_registry"]`. */
 declare const registryStatePda: (programId: SolanaAddress) => Address;
-/** Slot-keyed `Node` account PDA: `["molpha_node", index u32 LE]`. */
-declare const nodePda: (index: number, programId: SolanaAddress) => Address;
-/** Plan PDA is `[b"molpha_plan", [planType as u8]]` in `subscribe`. */
+/** Immutable, version-addressed registry snapshot: `["molpha_registry", version u32 LE]`. */
+declare const registryPda: (version: number, programId: SolanaAddress) => Address;
+/**
+ * Owner-keyed `Node` account: `["molpha_node", owner]`. Registry snapshots store these
+ * addresses directly in `nodes[i]`, so consumers rarely need to derive them.
+ */
+declare const nodePda: (owner: SolanaAddress, programId: SolanaAddress) => Address;
+/** Bonded gateway account: `["molpha_gateway", gatewayAuthority]` — the `gateway` bound into `RequestAuth`. */
+declare const gatewayPda: (authority: SolanaAddress, programId: SolanaAddress) => Address;
+/** Plan PDA is `[b"molpha_plan", [planType as u8]]`. */
 declare const planPda: (planId: number, programId: SolanaAddress) => Address;
 declare const subscriptionPda: (owner: SolanaAddress, programId: SolanaAddress) => Address;
-declare const feedPda: (feedId: Uint8Array, programId: SolanaAddress) => Address;
-
-/** The subset of on-chain `RegistryState` the client needs (Anchor camelCase). */
-interface RegistryStateView {
-    currentVersion: number;
-    previousVersion: number;
-    previousExpiresAt: bigint;
-    /** On-chain selection padding: `signatures_required + redundancy_buffer`. */
-    redundancyBuffer: number;
-    lastTransitionType: {
-        none: Record<string, never>;
-    } | {
-        add: Record<string, never>;
-    } | {
-        removeTail: Record<string, never>;
-    } | {
-        removeSwap: Record<string, never>;
-    };
-    removedOldIndex: number;
-    movedOldIndex: number;
-}
-/** Set-bit indices of a 32-byte big-endian bitmap (full 256-bit scan). */
-declare function bitmapToIndices(signersBitmapHex: string): number[];
 /**
- * Build the registry-index remaining accounts for a submit. Valid only
- * against the current or previous registry version (else thrown client-side).
+ * Feed state, keyed per `(sourceId, signaturesRequired, submitter)`:
+ * `["molpha_feed", sourceId, [signaturesRequired], submitter]`. Created lazily by the
+ * first `submit_attestation` from that submitter.
  */
-declare function resolveRemainingAccounts(result: DataUpdateResult, registry: RegistryStateView, programId: SolanaAddress): SolanaAccountMeta[];
-/** Map a selected node index to its registry-index PDA index for a registry version. */
-declare function resolveRegistryIndexForVersion(index: number, registryVersion: number, registry: RegistryStateView): number;
+declare function feedPda(sourceId: Uint8Array, signaturesRequired: number, submitter: SolanaAddress, programId: SolanaAddress): Address;
 
 /**
  * Vendored Molpha Anchor IDL (`target/idl/molpha.json` from the program repo).
@@ -556,12 +718,16 @@ declare const MOLPHA_PROGRAM_ADDRESS: string;
 type Commitment = NonNullable<ConstructorParameters<typeof AnchorProvider>[2]>["commitment"];
 
 interface MolphaSDKOptions {
-    /** Defaults to `DEFAULT_GATEWAY_ENDPOINT`. Pass multiple URLs for failover. */
-    endpoints?: string | string[];
+    /**
+     * Defaults to `DEFAULT_GATEWAY_ENDPOINT`. Pass multiple entries for failover. Each
+     * entry is a URL or `{ url, gatewayAuthority }`; when the authority is omitted it is
+     * discovered from the gateway's `GET /v1/info`.
+     */
+    endpoints?: GatewayEndpointInput | GatewayEndpointInput[];
     connection: SolanaConnection;
     /** On-chain txs + gateway auth (see `MolphaWallet`). */
     wallet: MolphaWallet;
-    /** Defaults to the vendored IDL's program address. */
+    /** Defaults to the vendored IDL's program address. Bound into gateway request auth. */
     programId?: Address | string;
     /** Defaults to `MOLPHA_IDL`. Override when pinning a different deployment. */
     idl?: Idl;
@@ -573,12 +739,13 @@ declare class MolphaSDK {
     constructor(opts: MolphaSDKOptions);
     /**
      * Request a threshold-signed data update from the gateway (against the current
-     * on-chain registry version) and submit it to the feed.
+     * on-chain registry version) and submit it via `submit_attestation`.
      */
-    requestAndSubmit(feedId: string, opts: Omit<RequestSignedDataOptions, "feedId">): Promise<{
+    requestAndSubmit(opts: RequestSignedDataOptions): Promise<{
         result: DataUpdateResult;
         signature: string;
+        feed: Address;
     }>;
 }
 
-export { APIConfig, DEFAULT_GATEWAY_ENDPOINT, DataUpdateResult, type EvmDataUpdateTuple, type EvmSchnorrSignatureTuple, type EvmVerifierArgs, type FeedAccount, GatewayError, MOLPHA_IDL, MOLPHA_PROGRAM_ADDRESS, MOLPHA_VERIFIER_ABI, MOLPHA_VERIFIER_ADDRESS, MOLPHA_VERIFIER_STARKNET_ADDRESSES, MOLPHA_VERIFIER_STARKNET_SEPOLIA, type MolphaEvmNetwork, MolphaGateway, type MolphaGatewayOptions, MolphaSDK, type MolphaSDKOptions, MolphaSolanaClient, type MolphaStarknetNetwork, MolphaWallet, Node, NodeKeyVerifier, NodeKeyVerifierArgs, type PlanId, type PlanInfo, PlanType, RegistrySelectionConfig, type RegistryStateView, type RequestSignedDataOptions, type RoundContext, Signer, type StarknetDataUpdate, type StarknetSchnorrSignature, type StarknetVerifierArgs, type SubmitResult, type SubscribeResult, type SubscriptionInfo, VIRTUAL_INDEX, bigIntFromBytesBe, bitmapBitSet, bitmapToIndices, buildEvmVerifierArgs, buildStarknetVerifierArgs, bytesToHex, bytesToHex0x, canonicalizeAPIConfig, commitmentAddressToStarknetFelt, concatBytes, deriveApiConfigHash, deriveFeedId, deriveFeedIdString, deriveGroupBitmap, deriveSelectionBitmap, deriveSelectionSeed, effectiveSelectionSize, ensureLength, feedPda, getMolphaStarknetVerifierAddress, hexToBytes, nodePda, normalizeSecp256k1PublicKeyHex, planIdFromVariant, planPda, planVariant, protocolConfigPda, registryStatePda, resolveRegistryIndexForVersion, resolveRemainingAccounts, secp256k1PublicKeyFromCoordinates, selectedIndices, signersBitmapToDecimal, signersBitmapToStarknetUint256, signersBitmapToUint256, subscriptionPda, toFixedBytes, toFixedHex, u256beFromBigInt, u32be, u32le, u64be, u64le, utf8 };
+export { APIConfig, type AttestationMessageFields, DEFAULT_GATEWAY_ENDPOINT, DataUpdateResult, type EvmDataUpdateTuple, type EvmSchnorrSignatureTuple, type EvmVerifierArgs, type FeedAccount, type GatewayEndpoint, type GatewayEndpointInput, GatewayError, type GatewayInfo, MESSAGE_PREFIX, MOLPHA_IDL, MOLPHA_PROGRAM_ADDRESS, MOLPHA_PROGRAM_ID, MOLPHA_VERIFIER_ABI, MOLPHA_VERIFIER_ADDRESS, MOLPHA_VERIFIER_STARKNET_ADDRESSES, MOLPHA_VERIFIER_STARKNET_SEPOLIA, type MolphaEvmNetwork, MolphaGateway, type MolphaGatewayOptions, MolphaSDK, type MolphaSDKOptions, MolphaSolanaClient, type MolphaStarknetNetwork, MolphaWallet, Node, NodeKeyVerifier, NodeKeyVerifierArgs, type PlanId, type PlanInfo, PlanType, REQUEST_AUTH_DOMAIN, RegistrySelectionConfig, type RegistryStateView, type RegistryView, type RequestAuthFields, type RequestSignedDataOptions, type RoundContext, Signer, type StarknetDataUpdate, type StarknetSchnorrSignature, type StarknetVerifierArgs, type SubmitAttestationArgs, type SubmitResult, type SubscribeResult, type SubscriptionInfo, addressToBytes, attestationMessageHash, attestationMessageHashFromResult, bigIntFromBytesBe, bitmapBitSet, bitmapToIndices, buildEvmVerifierArgs, buildStarknetVerifierArgs, buildSubmitAttestationArgs, bytesToHex, bytesToHex0x, canonicalizeAPIConfig, commitmentAddressToStarknetFelt, concatBytes, deriveApiConfigHash, deriveGatewayPda, deriveGatewayPdaAddress, deriveGroupBitmap, deriveSelectionBitmap, deriveSelectionSeed, deriveSourceId, deriveSourceIdString, effectiveSelectionSize, encodeRequestAuth, ensureLength, feedPda, gatewayPda, getMolphaStarknetVerifierAddress, hashRequestAuth, hexToBytes, nodePda, normalizeEndpoint, normalizeSecp256k1PublicKeyHex, parseGatewayInfo, planIdFromVariant, planPda, planVariant, protocolConfigPda, registryPda, registryStatePda, resolveRemainingAccounts, secp256k1PublicKeyFromCoordinates, selectedIndices, signersBitmapToDecimal, signersBitmapToStarknetUint256, signersBitmapToUint256, subscriptionPda, toFixedBytes, toFixedHex, u256beFromBigInt, u32be, u32le, u64be, u64le, utf8 };