@molpha/sdk 0.1.0 → 0.2.0-dev-20260911113923

package/README.md

@@ -5,9 +5,9 @@ Browser-first TypeScript SDK for **Molpha data consumers and feed owners**.
 Use it to:
 
 - subscribe to a Molpha plan on Solana;
-- derive a feed id from owner + API config hash + quorum;
-- request a threshold-signed data update from the gateway;
-- submit the signed result on-chain;
+- derive a source id from an API config;
+- request a threshold-signed attestation from the gateway;
+- submit the signed result on-chain (`submit_attestation`);
 - verify/read the latest feed value;
 - build EVM and Starknet verifier arguments from the same signed result.
 
@@ -20,12 +20,13 @@ Molpha turns off-chain API responses into verified on-chain data.
 At a high level:
 
 ```text
-Consumer / feed owner
+Consumer
   └─ subscribes (USDC) on Solana
-  └─ derives feedId from owner + apiConfigHash + signaturesRequired
+  └─ derives sourceId = keccak256(canonical apiConfig)
+  └─ signs a RequestAuth bound to (programId, gateway, sourceId, signaturesRequired, timestamp)
 
 Gateway
-  └─ coordinates a signing round for a feedId
+  └─ coordinates a signing round for (sourceId, signaturesRequired)
 
 Verifier nodes
   └─ fetch/recompute the API result independently
@@ -38,7 +39,18 @@ Solana / EVM / Starknet verifiers
 
 The gateway is a coordination layer, not a trusted oracle. A result is trusted only if it carries a valid threshold signature from the selected verifier nodes for the current registry version.
 
-Molpha uses Solana as the canonical protocol chain for subscriptions, registry state, node accounts, and feed state. EVM and Starknet verifier contracts are stateless verification surfaces: they verify signed Molpha data updates without managing subscriptions or feed configuration locally.
+Molpha uses Solana as the canonical protocol chain for subscriptions, registry snapshots, node accounts, and feed state. EVM and Starknet verifier contracts are stateless verification surfaces: they verify signed Molpha attestations without managing subscriptions or source configuration locally.
+
+Every signed attestation commits to the same message across chains:
+
+```text
+message = keccak256(
+  keccak256("MOLPHA_MESSAGE_V1") || sourceId || u32be(registryVersion) ||
+  u32be(signaturesRequired) || signersBitmap || value || u64be(canonicalTimestamp)
+)
+```
+
+`attestationMessageHash` / `attestationMessageHashFromResult` recompute it client-side.
 
 ## Install
 
@@ -59,7 +71,7 @@ Runtime dependencies include `@solana/kit`, `@anchor-lang/core`, and `@noble/*`.
 
 | Import | Use |
 |---|---|
-| `@molpha/sdk` | Facade (`MolphaSDK`), `MolphaGateway`, `MolphaSolanaClient`, core types, EVM/Starknet helpers. Browser-safe; no `fs` in the main entry. |
+| `@molpha/sdk` | Facade (`MolphaSDK`), `MolphaGateway`, `MolphaSolanaClient`, core hashing (`deriveSourceId`, `attestationMessageHash`, `hashRequestAuth`), EVM/Starknet helpers. Browser-safe; no `fs` in the main entry. |
 | `@molpha/sdk/utils` | `walletFromKeypairFile`, `loadKeypair` — load a Solana CLI keypair as an Anchor `Wallet`. Node.js only. |
 
 The package is ESM with `"sideEffects": false`, so gateway-only or read-only apps can tree-shake unused paths.
@@ -68,18 +80,14 @@ The package is ESM with `"sideEffects": false`, so gateway-only or read-only app
 
 ```ts
 import { web3 } from "@anchor-lang/core";
-import {
-  MolphaSDK,
-  PlanType,
-  deriveApiConfigHash,
-  deriveFeedIdString,
-} from "@molpha/sdk";
+import { MolphaSDK, PlanType, deriveSourceIdString } from "@molpha/sdk";
 import { walletFromKeypairFile } from "@molpha/sdk/utils";
 
 const wallet = walletFromKeypairFile("~/.config/solana/id.json");
 const sdk = new MolphaSDK({
   connection: new web3.Connection("https://api.devnet.solana.com", "confirmed"),
   wallet,
+  // endpoints: [{ url: "https://gateway.example.com", gatewayAuthority: "<base58>" }],
 });
 
 // Subscribe if needed (USDC on Solana)
@@ -93,19 +101,17 @@ const apiConfig = {
   responseParser: "$.price",
 };
 const signaturesRequired = 3;
-const feedId = deriveFeedIdString(
-  wallet.publicKey.toBytes(),
-  deriveApiConfigHash(apiConfig),
-  signaturesRequired,
-);
 
-const { result, signature } = await sdk.requestAndSubmit(feedId, {
+const { result, signature, feed } = await sdk.requestAndSubmit({
   apiConfig,
   signaturesRequired,
 });
+
+// The round's identity, for reads and cross-chain verification.
+const sourceId = deriveSourceIdString(apiConfig); // === result.sourceId
 ```
 
-`requestAndSubmit` requests a threshold-signed data update from the gateway (against the current on-chain registry version) and submits it to Solana in one call. The first successful submit creates the feed account if it does not already exist.
+`requestAndSubmit` requests a threshold-signed attestation from the gateway (against the current on-chain registry version) and submits it to Solana via `submit_attestation` in one call. The first successful submit creates the feed account for `(sourceId, signaturesRequired, submitter)` if it does not already exist.
 
 ## Configuration
 
@@ -120,8 +126,8 @@ const { result, signature } = await sdk.requestAndSubmit(feedId, {
 
 | Option | Default |
 |---|---|
-| `endpoints` | `DEFAULT_GATEWAY_ENDPOINT` — string or array for failover |
-| `programId` | `MOLPHA_PROGRAM_ADDRESS` from the vendored IDL |
+| `endpoints` | `DEFAULT_GATEWAY_ENDPOINT` — URL, `{ url, gatewayAuthority }`, or an array of either for failover (see [Gateway identity](#gateway-identity)) |
+| `programId` | `MOLPHA_PROGRAM_ADDRESS` from the vendored IDL; also bound into gateway request auth |
 | `idl` | `MOLPHA_IDL` from `idl/molpha.json` |
 | `commitment` | `"confirmed"` |
 
@@ -135,20 +141,42 @@ import {
 const sdk = new MolphaSDK({
   connection,
   wallet,
-  endpoints: [DEFAULT_GATEWAY_ENDPOINT, "https://backup.example.com"],
+  endpoints: [
+    DEFAULT_GATEWAY_ENDPOINT,
+    { url: "https://backup.example.com", gatewayAuthority: "<gateway base58 pubkey>" },
+  ],
   // programId: "YourProgramAddress...",
   // idl: MOLPHA_IDL,
 });
 ```
 
+### Gateway identity
+
+Gateway request authorization binds the gateway's on-chain account, so the client must know which gateway it is talking to:
+
+```text
+requestAuthHash = keccak256(
+  "MOLPHA_REQAUTH_V1" || programId || gatewayPda || sourceId || u8(signaturesRequired) || u64le(timestamp)
+)
+gatewayPda = PDA(["molpha_gateway", gatewayAuthority], programId)
+```
+
+Pass `gatewayAuthority` (the gateway's base58 signing pubkey) per endpoint to pin it. When omitted, the SDK calls `GET {url}/v1/info` once per endpoint and reads:
+
+```json
+{ "status": "ok", "data": { "gatewayAuthority": "<base58>", "programId": "<base58>" } }
+```
+
+A `programId` that differs from the client's is rejected. Because the hash differs per gateway, the auth signature is recomputed for every endpoint actually tried during failover — with a browser wallet that means one signing prompt per endpoint tried. `/v1/info` is never contacted when no signer is configured (dev zero-signature path).
+
 ## Wallet
 
 `wallet` is a single `MolphaWallet` used across both protocol surfaces:
 
 | Layer | What it signs |
 |---|---|
-| Solana client | Transactions such as `subscribe`, `extendSubscription`, `submitDataUpdate` |
-| Gateway client | `authMessage(feedId, timestamp)` for authenticated gateway requests |
+| Solana client | Transactions such as `subscribe`, `extendSubscription`, `submitAttestation` |
+| Gateway client | `hashRequestAuth({ programId, gateway, sourceId, signaturesRequired, timestamp })` for authenticated gateway requests |
 
 Gateway auth is resolved automatically when you use `MolphaSDK`:
 
@@ -157,7 +185,7 @@ Gateway auth is resolved automatically when you use `MolphaSDK`:
 3. Else omit auth and use an all-zero `authSig`.
 
 `MolphaSDK` passes the resolved signer to `sdk.gateway` as its default, so
-`sdk.gateway.requestSignedData({ feedId, apiConfig, signaturesRequired })` authenticates without an
+`sdk.gateway.requestSignedData({ apiConfig, signaturesRequired })` authenticates without an
 explicit `signer`. Standalone `new MolphaGateway(...)` omits auth unless you pass
 a `defaultSigner` (third constructor arg) or per-call `signer`.
 
@@ -223,12 +251,12 @@ const { pricePaid } = await sdk.solana.subscribe(PlanType.Basic, {
 
 `maxPriceUsdc` is a safety bound. The transaction aborts if the live plan price is higher than the amount the user approved.
 
-### 2. Derive a feed id
+### 2. Source id
 
-There is no separate `createJob` instruction. Feed identity is deterministic:
+There is no create-feed instruction. A data source is identified by its canonical API config:
 
 ```text
-feedId = keccak256("MOLPHA_JOB_V1" || owner || apiConfigHash || [signaturesRequired])
+sourceId = keccak256(JSON.stringify(canonicalizeAPIConfig(apiConfig)))
 ```
 
 ```ts
@@ -237,21 +265,16 @@ const apiConfig = {
   responseParser: "$.price",
 };
 
-const signaturesRequired = 3;
-const feedId = deriveFeedIdString(
-  wallet.publicKey.toBytes(),
-  deriveApiConfigHash(apiConfig),
-  signaturesRequired,
-);
+const sourceId = deriveSourceIdString(apiConfig); // 64 hex chars, no 0x
 ```
 
-The on-chain feed commits to the `apiConfigHash`, not the full API config. This binds the feed to a specific off-chain data source and parsing logic while keeping large config payloads and secrets off-chain. Pass the same `apiConfig` (including `{{secret.*}}` placeholders) to gateway requests that you hashed when deriving the feed id.
+The gateway, the Solana program and the EVM/Starknet verifiers all recompute `sourceId` from the same canonical config, so pass the same `apiConfig` (including `{{secret.*}}` placeholders) every time. `signaturesRequired` is **not** part of `sourceId`: on Solana a feed account is keyed by `(sourceId, signaturesRequired, submitter)`, so the same source can be tracked at different quorums.
 
 ### 3. Request signed data from the gateway
 
 ```ts
+const signaturesRequired = 3;
 const result = await sdk.gateway.requestSignedData({
-  feedId,
   apiConfig,
   signaturesRequired,
 });
@@ -259,24 +282,24 @@ const result = await sdk.gateway.requestSignedData({
 
 The gateway round uses the current on-chain registry version. Selected verifier nodes independently fetch/recompute the result and sign only if the observed value matches the canonical result.
 
-The returned `DataUpdateResult` includes the signed value, canonical timestamp, registry version, required quorum, signer bitmap, and aggregate signature.
+The returned `DataUpdateResult` includes `sourceId`, the signed value, canonical timestamp, registry version, required quorum, signer bitmap, and aggregate signature. `signaturesRequired` must be at least the protocol's `min_signers` (currently 3) or the chain rejects the submit.
 
 ### 4. Submit on Solana
 
 ```ts
-const { signature } = await sdk.solana.submitDataUpdate(result);
+const { signature, feed } = await sdk.solana.submitAttestation(result);
 ```
 
-Then read the finalized feed:
+Then read the feed this wallet wrote for that source and quorum:
 
 ```ts
-const feed = await sdk.solana.readFeed(feedId);
+const feedState = await sdk.solana.readFeed(result.sourceId, signaturesRequired);
 ```
 
 ### One-call request + submit
 
 ```ts
-const { result, signature } = await sdk.requestAndSubmit(feedId, {
+const { result, signature, feed } = await sdk.requestAndSubmit({
   apiConfig,
   signaturesRequired,
 });
@@ -285,23 +308,24 @@ const { result, signature } = await sdk.requestAndSubmit(feedId, {
 This is equivalent to:
 
 ```ts
-const result = await sdk.gateway.requestSignedData({ feedId, apiConfig, signaturesRequired });
-const { signature } = await sdk.solana.submitDataUpdate(result);
+const result = await sdk.gateway.requestSignedData({ apiConfig, signaturesRequired });
+const { signature, feed } = await sdk.solana.submitAttestation(result);
 ```
 
 ### Fast requests with a cached context
 
-By default every `requestSignedData` call fetches slow-changing inputs up
-front (in parallel): the on-chain registry version and redundancy buffer (one
-account read), and the node set. When you run many rounds for the same feed,
-fetch these once and reuse them so each round is a single gateway POST.
+By default every `requestSignedData` call reads the on-chain registry up front
+(current version, redundancy buffer and node count of that snapshot) and fetches
+the gateway node set only when the round needs it (private API encryption). When
+you run many rounds for the same source, fetch these once and reuse them so each
+round is a single gateway POST.
 
 ```ts
-// Fetch registryVersion + redundancyBuffer + nodes once.
-const context = await sdk.gateway.prepareContext(feedId);
+// Fetch registryVersion + redundancyBuffer + nodeCount + nodes once.
+const context = await sdk.gateway.prepareContext();
 
 // Reuse it across rounds — no prelude fetches.
-const result = await sdk.gateway.requestSignedData({ feedId, apiConfig, signaturesRequired, context });
+const result = await sdk.gateway.requestSignedData({ apiConfig, signaturesRequired, context });
 ```
 
 `context` is a `Partial<RoundContext>`, so you can cache only what you have
@@ -309,25 +333,24 @@ and let `requestSignedData` fetch the rest:
 
 ```ts
 const result = await sdk.gateway.requestSignedData({
-  feedId,
   apiConfig,
   signaturesRequired,
-  context: { nodes }, // registryVersion + redundancyBuffer still fetched fresh
+  context: { nodes }, // registryVersion + redundancyBuffer + nodeCount still fetched fresh
 });
 ```
 
 Caching is opt-in because these inputs can drift. A stale `registryVersion`,
-`redundancyBuffer`, or node set yields a result the chain will reject — refresh
-the context when the on-chain registry changes. The same `context` field is
-accepted by `requestAndSubmit`.
+`redundancyBuffer`, `nodeCount`, or node set yields a result the chain will reject —
+refresh the context when the on-chain registry changes. The SDK derives the
+selection from the on-chain `nodeCount` and refuses a cached node list whose length
+disagrees with it. The same `context` field is accepted by `requestAndSubmit`.
 
 ## Private APIs and encrypted secrets
 
-Jobs can use private APIs without sending plaintext secrets to the gateway.
+Sources can use private APIs without sending plaintext secrets to the gateway.
 
 ```ts
 const result = await sdk.gateway.requestSignedData({
-  feedId,
   apiConfig: {
     url: "https://api.example.com/private-price?key={{secret.apiKey}}",
     responseParser: "$.price",
@@ -341,7 +364,7 @@ const result = await sdk.gateway.requestSignedData({
 });
 ```
 
-`MolphaSDK` wires `verifyNodeKeys` to `solana.verifyNodeKeysForPrivateApi`, which authenticates gateway node encryption keys against on-chain Node accounts before secrets are encrypted.
+`MolphaSDK` wires `verifyNodeKeys` to `solana.verifyNodeKeysForPrivateApi`, which authenticates gateway node encryption keys against the on-chain `Node` accounts of the round's registry snapshot (`registry.nodes[index]`) before secrets are encrypted.
 
 Secrets are encrypted into per-node envelopes. The gateway coordinates the round but should not receive plaintext API credentials.
 
@@ -371,7 +394,7 @@ Supported network ids (selection helpers only): `evm-sepolia`, `arbitrum-sepolia
 ```ts
 import { buildEvmVerifierArgs } from "@molpha/sdk";
 
-const result = await sdk.gateway.requestSignedData({ feedId, apiConfig, signaturesRequired });
+const result = await sdk.gateway.requestSignedData({ apiConfig, signaturesRequired });
 
 const { dataUpdate, signature } = buildEvmVerifierArgs(result);
 ```
@@ -380,7 +403,7 @@ The generated tuples match the Molpha EVM verifier ABI:
 
 ```ts
 // dataUpdate:
-// [bytes32 feedId,
+// [bytes32 sourceId,
 //  uint32 registryVersion,
 //  uint32 signaturesRequired,
 //  bytes32 valuePacked,
@@ -392,7 +415,7 @@ The generated tuples match the Molpha EVM verifier ABI:
 //  uint256 signersBitmap]
 ```
 
-Note: the shipped `MOLPHA_VERIFIER_ABI` still names the first struct field `jobId` for contract compatibility; the SDK value is the feed id bytes32.
+Note: the deployed contract's source names the first struct field `jobId`; the SDK ABI names it `sourceId` (component names do not affect encoding) and the value is the 32-byte source id.
 
 ### ethers
 
@@ -437,7 +460,7 @@ await client.readContract({
   functionName: "verify",
   args: [
     {
-      jobId: dataUpdate[0],
+      sourceId: dataUpdate[0],
       registryVersion: dataUpdate[1],
       signaturesRequired: dataUpdate[2],
       value: dataUpdate[3],
@@ -494,17 +517,17 @@ const sepoliaDirect = MOLPHA_VERIFIER_STARKNET_SEPOLIA;
 ```ts
 import { buildStarknetVerifierArgs } from "@molpha/sdk";
 
-const result = await sdk.gateway.requestSignedData({ feedId, apiConfig, signaturesRequired });
+const result = await sdk.gateway.requestSignedData({ apiConfig, signaturesRequired });
 
 const { dataUpdate, signature } = buildStarknetVerifierArgs(result);
 ```
 
-The generated objects match the Molpha Starknet verifier interface:
+The generated objects match the Molpha Starknet verifier interface (the Cairo struct still names the first field `feed_id`; positional calldata is unchanged):
 
 ```ts
 // dataUpdate:
 // {
-//   feed_id: u256,
+//   source_id: u256,
 //   registry_version: u32,
 //   signatures_required: u32,
 //   value: u256,
@@ -530,18 +553,17 @@ import {
 
 ## What verification checks
 
-A Molpha data update is valid only if the verifier can confirm:
+A Molpha attestation is valid only if the verifier can confirm:
 
-- the update targets the expected `feedId`;
-- the result was signed against a specific `registryVersion`;
+- the update targets the expected `sourceId`;
+- the result was signed against a specific `registryVersion` (an immutable node-set snapshot);
 - the quorum satisfies `signaturesRequired`;
-- the signer bitmap maps to valid selected nodes;
-- the aggregate Schnorr signature is valid;
-- the signed value and canonical timestamp match the message;
+- the signer bitmap is a subset of the deterministic selection for `(sourceId, registryVersion, canonicalTimestamp)`;
+- the aggregate Schnorr signature over `attestationMessageHash(...)` is valid;
 - the timestamp is within the accepted freshness bounds;
-- on Solana, remaining accounts resolve correctly for the registry version (including previous-version remap during transitions).
+- on Solana, the signer `Node` accounts passed as remaining accounts are exactly `registry.nodes[bit]` for every set bit.
 
-Solana verification finalizes feed state via `submit_data_update`. EVM and Starknet verification are stateless and return whether the signed Molpha update is valid for the deployed verifier registry.
+Solana verification finalizes feed state via `submit_attestation`. EVM and Starknet verification are stateless and return whether the signed Molpha attestation is valid for the deployed verifier registry.
 
 ## IDL vendoring
 
@@ -595,9 +617,9 @@ The facade wires the registry selection config resolver, gateway signer, subscri
 Current scope:
 
 - Solana subscription and extend flow;
-- deterministic feed ID derivation;
-- gateway signed-data requests (failover, retries, context cache);
-- Solana data update submission and feed reads;
+- deterministic source id and attestation message hashing;
+- gateway signed-data requests (failover, retries, per-gateway request auth, context cache);
+- Solana attestation submission and feed/registry reads;
 - private API encryption helpers (pre-production);
 - EVM and Starknet verifier argument building;
 - deployed testnet verifier address helpers.
@@ -609,7 +631,25 @@ Known limitations:
 - production deployments should use authenticated gateway requests;
 - testnet verifier addresses may change between protocol releases.
 
-Solana paths such as selection bitmap, previous-version remap, and `submit_data_update` remaining-accounts resolution are aligned with the Molpha program version vendored in this repo.
+Solana paths such as selection bitmap and `submit_attestation` remaining-accounts resolution are aligned with the Molpha program version vendored in this repo (`MoLFnEbuMS5gWnXNfUMLAYSqRM3eQZKWRzjeMQfqbT3`, not yet deployed).
+
+## Migrating from 0.1.x
+
+| Before | After |
+|---|---|
+| `deriveFeedId(owner, apiConfigHash, sigReq)` / `deriveFeedIdString` | removed — use `deriveSourceId(apiConfig)` / `deriveSourceIdString` |
+| `deriveApiConfigHash(apiConfig)` | `deriveSourceId(apiConfig)` (old name kept as a deprecated alias, same bytes) |
+| `requestSignedData({ feedId, ... })` | `requestSignedData({ apiConfig, signaturesRequired, ... })` — `sourceId` is derived from `apiConfig` |
+| `prepareContext(feedId)` | `prepareContext()` |
+| `requestAndSubmit(feedId, opts)` | `requestAndSubmit(opts)` |
+| `authMessage(feedId, timestamp)` (sha256) | `hashRequestAuth({ programId, gateway, sourceId, signaturesRequired, timestamp })` (keccak) |
+| `endpoints: string[]` | `endpoints: (string \| { url, gatewayAuthority })[]` |
+| `submitDataUpdate(result)` | `submitAttestation(result)` (deprecated alias kept); returns `{ signature, feed }` |
+| `readFeed(feedId)` | `readFeed(sourceId, signaturesRequired, submitter?)` |
+| `result.feedId` / `NodeKeyVerifierArgs.feedId` | `.sourceId` |
+| EVM tuple `feedId`, ABI `jobId` | `sourceId` |
+| Starknet `feed_id` | `source_id` |
+| `resolveRegistryIndexForVersion`, `VIRTUAL_INDEX`, `nodePda(index)` | removed — signer accounts are `registry.nodes[bit]`; `nodePda(owner)` |
 
 ## Develop
 
@@ -671,13 +711,19 @@ Versions follow semver and are driven by the nature of each change, not by the b
 
 ### One-time setup
 
-1. Add `NPM_TOKEN` under GitHub repo settings:
+1. Configure npm [trusted publishing](https://docs.npmjs.com/trusted-publishers/) for `@molpha/sdk`:
 
    ```text
-   Settings → Secrets and variables → Actions
+   npmjs.com → @molpha/sdk → Settings → Trusted publishing
    ```
 
-   Use a granular npm automation token with publish access to the `@molpha` scope.
+   Add a trusted publisher for the release workflow:
+
+   | Workflow file | Branches       | Purpose                         |
+   | ------------- | -------------- | ------------------------------- |
+   | `release.yml` | `main`, `dev`  | Stable releases + dev snapshots |
+
+   Use organization `Molpha`, repository `sdk`, and the exact workflow filename (including `.yml`). No `NPM_TOKEN` secret is required.
 
 2. Publish a stable release from `main` first.
 

package/dist/{chunk-MFELBWSL.js → chunk-DT6IKCWB.js}

@@ -1,5 +1,5 @@
 import { web3 } from '@anchor-lang/core';
-import { address, getAddressEncoder } from '@solana/kit';
+import { address, getAddressEncoder, getAddressDecoder } from '@solana/kit';
 import { ed25519 } from '@noble/curves/ed25519.js';
 
 // src/solana/kit.ts
@@ -9,6 +9,7 @@ var ASSOCIATED_TOKEN_PROGRAM_ADDRESS = address(
 );
 var SYSTEM_PROGRAM_ADDRESS = address("11111111111111111111111111111111");
 var addressEncoder = getAddressEncoder();
+var addressDecoder = getAddressDecoder();
 function toSolanaAddress(value) {
   return address(typeof value === "string" ? value : value.toBase58());
 }
@@ -18,6 +19,9 @@ function toPublicKey(value) {
 function addressBytes(value) {
   return Uint8Array.from(addressEncoder.encode(toSolanaAddress(value)));
 }
+function addressFromBytes(bytes) {
+  return addressDecoder.decode(bytes);
+}
 function findProgramAddressSync(seeds, programAddress) {
   const [pda] = web3.PublicKey.findProgramAddressSync(seeds, toPublicKey(programAddress));
   return toSolanaAddress(pda);
@@ -46,6 +50,6 @@ function gatewaySignerFromWallet(wallet) {
   return void 0;
 }
 
-export { SYSTEM_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, addressBytes, findProgramAddressSync, gatewaySignerFromWallet, getAssociatedTokenAddressSync, keypairFromSecretKey, setComputeUnitLimit, signerFromKeypair, toPublicKey, toSolanaAddress };
-//# sourceMappingURL=chunk-MFELBWSL.js.map
-//# sourceMappingURL=chunk-MFELBWSL.js.map
+export { SYSTEM_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, addressBytes, addressFromBytes, findProgramAddressSync, gatewaySignerFromWallet, getAssociatedTokenAddressSync, keypairFromSecretKey, setComputeUnitLimit, signerFromKeypair, toPublicKey, toSolanaAddress };
+//# sourceMappingURL=chunk-DT6IKCWB.js.map
+//# sourceMappingURL=chunk-DT6IKCWB.js.map

package/dist/chunk-DT6IKCWB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/solana/kit.ts","../src/wallet.ts"],"names":[],"mappings":";;;;;AAaO,IAAM,qBAAA,GAAwB,QAAQ,6CAA6C;AACnF,IAAM,gCAAA,GAAmC,OAAA;AAAA,EAC9C;AACF,CAAA;AACO,IAAM,sBAAA,GAAyB,QAAQ,kCAAkC;AAEhF,IAAM,iBAAiB,iBAAA,EAAkB;AACzC,IAAM,iBAAiB,iBAAA,EAAkB;AAElC,SAAS,gBAAgB,KAAA,EAA+B;AAC7D,EAAA,OAAO,QAAQ,OAAO,KAAA,KAAU,WAAW,KAAA,GAAQ,KAAA,CAAM,UAAU,CAAA;AACrE;AAEO,SAAS,YAAY,KAAA,EAA2D;AACrF,EAAA,OAAO,iBAAiB,IAAA,CAAK,SAAA,GAAY,QAAQ,IAAI,IAAA,CAAK,UAAU,KAAK,CAAA;AAC3E;AAEO,SAAS,aAAa,KAAA,EAAkC;AAC7D,EAAA,OAAO,WAAW,IAAA,CAAK,cAAA,CAAe,OAAO,eAAA,CAAgB,KAAK,CAAC,CAAC,CAAA;AACtE;AAGO,SAAS,iBAAiB,KAAA,EAA4B;AAC3D,EAAA,OAAO,cAAA,CAAe,OAAO,KAAK,CAAA;AACpC;AAEO,SAAS,sBAAA,CACd,OACA,cAAA,EACS;AACT,EAAA,MAAM,CAAC,GAAG,CAAA,GAAI,IAAA,CAAK,UAAU,sBAAA,CAAuB,KAAA,EAAO,WAAA,CAAY,cAAc,CAAC,CAAA;AACtF,EAAA,OAAO,gBAAgB,GAAG,CAAA;AAC5B;AAUO,SAAS,6BAAA,CACd,IAAA,EACA,KAAA,EACA,YAAA,GAA8B,qBAAA,EACrB;AACT,EAAA,OAAO,sBAAA;AAAA,IACL,CAAC,aAAa,KAAK,CAAA,EAAG,aAAa,YAAY,CAAA,EAAG,YAAA,CAAa,IAAI,CAAC,CAAA;AAAA,IACpE;AAAA,GACF;AACF;AAEO,SAAS,oBAAoB,KAAA,EAAkC;AACpE,EAAA,OAAO,IAAA,CAAK,oBAAA,CAAqB,mBAAA,CAAoB,EAAE,OAAO,CAAA;AAChE;AAEO,SAAS,qBAAqB,SAAA,EAAsC;AACzE,EAAA,OAAO,IAAA,CAAK,OAAA,CAAQ,aAAA,CAAc,SAAS,CAAA;AAC7C;ACvDA,IAAM,SAAA,GAAY,CAAC,KAAA,KACjB,OAAO,KAAA,KAAU,QAAA,IACjB,KAAA,KAAU,IAAA,IACV,WAAA,IAAe,KAAA,IACf,KAAA,CAAM,SAAA,YAAqB,UAAA;AAGtB,SAAS,kBAAkB,OAAA,EAAgC;AAChE,EAAA,MAAM,IAAA,GAAO,OAAA,CAAQ,SAAA,CAAU,KAAA,CAAM,GAAG,EAAE,CAAA;AAC1C,EAAA,OAAO,OAAO,OAAA,KAA6C,OAAA,CAAQ,IAAA,CAAK,SAAS,IAAI,CAAA;AACvF;AAGO,SAAS,wBAAwB,MAAA,EAAoC;AAC1E,EAAA,MAAM,MAAA,GAAS,MAAA;AACf,EAAA,IAAI,MAAA,CAAO,eAAA,EAAiB,OAAO,MAAA,CAAO,eAAA;AAC1C,EAAA,IAAI,OAAA,IAAW,UAAU,SAAA,CAAU,MAAA,CAAO,KAAK,CAAA,EAAG,OAAO,iBAAA,CAAkB,MAAA,CAAO,KAAK,CAAA;AACvF,EAAA,OAAO,MAAA;AACT","file":"chunk-DT6IKCWB.js","sourcesContent":["import { web3 } from \"@anchor-lang/core\";\nimport { address, getAddressDecoder, getAddressEncoder, type Address } from \"@solana/kit\";\n\nexport type SolanaAddress = Address | string | InstanceType<typeof web3.PublicKey>;\nexport type SolanaConnection = InstanceType<typeof web3.Connection>;\nexport type SolanaKeypair = InstanceType<typeof web3.Keypair>;\nexport type SolanaInstruction = InstanceType<typeof web3.TransactionInstruction>;\nexport type SolanaAccountMeta = {\n  pubkey: InstanceType<typeof web3.PublicKey>;\n  isSigner: boolean;\n  isWritable: boolean;\n};\n\nexport const TOKEN_PROGRAM_ADDRESS = address(\"TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA\");\nexport const ASSOCIATED_TOKEN_PROGRAM_ADDRESS = address(\n  \"ATokenGPvbdGVxr1b2hvZbsiqW5xWH25efTNsLJA8knL\",\n);\nexport const SYSTEM_PROGRAM_ADDRESS = address(\"11111111111111111111111111111111\");\n\nconst addressEncoder = getAddressEncoder();\nconst addressDecoder = getAddressDecoder();\n\nexport function toSolanaAddress(value: SolanaAddress): Address {\n  return address(typeof value === \"string\" ? value : value.toBase58());\n}\n\nexport function toPublicKey(value: SolanaAddress): InstanceType<typeof web3.PublicKey> {\n  return value instanceof web3.PublicKey ? value : new web3.PublicKey(value);\n}\n\nexport function addressBytes(value: SolanaAddress): Uint8Array {\n  return Uint8Array.from(addressEncoder.encode(toSolanaAddress(value)));\n}\n\n/** Base58 `Address` from 32 raw bytes (e.g. a `Registry.nodes[i]` entry). */\nexport function addressFromBytes(bytes: Uint8Array): Address {\n  return addressDecoder.decode(bytes);\n}\n\nexport function findProgramAddressSync(\n  seeds: Uint8Array[],\n  programAddress: SolanaAddress,\n): Address {\n  const [pda] = web3.PublicKey.findProgramAddressSync(seeds, toPublicKey(programAddress));\n  return toSolanaAddress(pda);\n}\n\nexport function findProgramPublicKeySync(\n  seeds: Uint8Array[],\n  programAddress: SolanaAddress,\n): InstanceType<typeof web3.PublicKey> {\n  const [pda] = web3.PublicKey.findProgramAddressSync(seeds, toPublicKey(programAddress));\n  return pda;\n}\n\nexport function getAssociatedTokenAddressSync(\n  mint: SolanaAddress,\n  owner: SolanaAddress,\n  tokenProgram: SolanaAddress = TOKEN_PROGRAM_ADDRESS,\n): Address {\n  return findProgramAddressSync(\n    [addressBytes(owner), addressBytes(tokenProgram), addressBytes(mint)],\n    ASSOCIATED_TOKEN_PROGRAM_ADDRESS,\n  );\n}\n\nexport function setComputeUnitLimit(units: number): SolanaInstruction {\n  return web3.ComputeBudgetProgram.setComputeUnitLimit({ units });\n}\n\nexport function keypairFromSecretKey(secretKey: Uint8Array): SolanaKeypair {\n  return web3.Keypair.fromSecretKey(secretKey);\n}\n\nexport function generateKeypair(): SolanaKeypair {\n  return web3.Keypair.generate();\n}\n","/**\n * Unified wallet surface: Anchor txs + optional gateway authSig signing.\n */\nimport type { Wallet } from \"@anchor-lang/core\";\nimport { ed25519 } from \"@noble/curves/ed25519.js\";\nimport type { Signer } from \"./core/types.js\";\nimport type { SolanaKeypair } from \"./solana/kit.js\";\n\n/** Anchor `Wallet` plus optional gateway auth override. */\nexport type MolphaWallet = Wallet & {\n  /**\n   * Signs gateway request-auth hashes (`hashRequestAuth`). When omitted, derived from Anchor\n   * `Wallet.payer` when the keypair secret is available (Node `Wallet`, etc.).\n   */\n  signAuthMessage?: Signer;\n};\n\nconst isKeypair = (value: unknown): value is SolanaKeypair =>\n  typeof value === \"object\" &&\n  value !== null &&\n  \"secretKey\" in value &&\n  value.secretKey instanceof Uint8Array;\n\n/** ed25519 gateway signer from a Solana keypair's 32-byte seed. */\nexport function signerFromKeypair(keypair: SolanaKeypair): Signer {\n  const seed = keypair.secretKey.slice(0, 32);\n  return async (message: Uint8Array): Promise<Uint8Array> => ed25519.sign(message, seed);\n}\n\n/** Resolve the gateway auth signer for a Molpha wallet, if available. */\nexport function gatewaySignerFromWallet(wallet: Wallet): Signer | undefined {\n  const molpha = wallet as MolphaWallet;\n  if (molpha.signAuthMessage) return molpha.signAuthMessage;\n  if (\"payer\" in wallet && isKeypair(wallet.payer)) return signerFromKeypair(wallet.payer);\n  return undefined;\n}\n"]}