@molpha/sdk 0.2.0-dev-20260913100330 → 0.2.0-dev-20261001125531

package/README.md

@@ -45,12 +45,14 @@ 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)
+  keccak256("MOLPHA_MESSAGE_V1") || value || sourceId || u32be(registryVersion) ||
+  u8(signaturesRequired) || u64be(canonicalTimestamp) || signersBitmap
 )
 ```
 
-`attestationMessageHash` / `attestationMessageHashFromResult` recompute it client-side.
+The preimage is 141 bytes (32 + 32 + 32 + 4 + 1 + 8 + 32).
+
+`attestationMessageHash` / `attestationMessageHashFromAttestation` recompute it client-side.
 
 ## Install
 
@@ -60,15 +62,6 @@ pnpm add @molpha/sdk
 
 Runtime dependencies include `@solana/kit`, `@anchor-lang/core`, and `@noble/*`. `bn.js` is an optional peer dependency (used by the Solana / Anchor path).
 
-> **Migration from `@molpha-oracle/sdk`:** The package was renamed to `@molpha/sdk` starting at `0.1.0`. `@molpha-oracle/sdk` is deprecated — update install commands and imports:
->
-> ```bash
-> pnpm remove @molpha-oracle/sdk
-> pnpm add @molpha/sdk
-> ```
->
-> Replace `@molpha-oracle/sdk` with `@molpha/sdk` in all import paths (including `@molpha/sdk/utils`).
-
 | Import | Use |
 |---|---|
 | `@molpha/sdk` | Facade (`MolphaSDK`), `MolphaGateway`, `MolphaSolanaClient`, core hashing (`deriveSourceId`, `attestationMessageHash`, `hashRequestAuth`), EVM/Starknet helpers. Browser-safe; no `fs` in the main entry. |
@@ -108,7 +101,7 @@ const { result, signature, feed } = await sdk.requestAndSubmit({
 });
 
 // The round's identity, for reads and cross-chain verification.
-const sourceId = deriveSourceIdString(apiConfig); // === result.sourceId
+const sourceId = deriveSourceIdString(apiConfig); // === result.payload.sourceId
 ```
 
 `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.
@@ -223,8 +216,7 @@ import { web3 } from "@anchor-lang/core";
 import {
   MolphaSDK,
   PlanType,
-  deriveApiConfigHash,
-  deriveFeedIdString,
+  deriveSourceIdString,
 } from "@molpha/sdk";
 import { walletFromKeypairFile } from "@molpha/sdk/utils";
 
@@ -268,6 +260,8 @@ const apiConfig = {
 const sourceId = deriveSourceIdString(apiConfig); // 64 hex chars, no 0x
 ```
 
+The canonical JSON has the fixed key order `url`, `method`, `headers` (sorted by UTF-16 code units, `{}` if empty), `responseParser`, `valueTransform` and, for [tolerance mode](#median-tolerance-mode), a trailing `aggregation`. The key is omitted for exact mode, so existing five-field configs keep their `sourceId`.
+
 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
@@ -282,7 +276,9 @@ 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 `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.
+The returned `Attestation` matches the cross-VM struct (`payload` + `signature`), plus gateway-only `value` (human-readable) and `fresh`. `payload` carries `sourceId`, the signed 32-byte `value`, `canonicalTimestamp`, `registryVersion`, and `signaturesRequired`; `signature` carries the aggregate Schnorr material and `signersBitmap`. `signaturesRequired` must be at least the protocol's `min_signers` (currently 3) or the chain rejects the submit.
+
+A gateway response is a coordination result, not proof of settlement or of on-chain verification. Consumers still decide freshness, source, quorum and replay policy.
 
 ### 4. Submit on Solana
 
@@ -290,12 +286,24 @@ The returned `DataUpdateResult` includes `sourceId`, the signed value, canonical
 const { signature, feed } = await sdk.solana.submitAttestation(result);
 ```
 
+`submit_attestation` takes `{ attestation: { payload, signature }, rawValue, coalitionKey }` plus one read-only `Node` account per signer (ascending signer-bit order, resolved from the registry snapshot the round was signed against). The SDK builds all of it: it fetches the signer `Node` accounts in one batched read, sums their secp256k1 keys into the affine **coalition key** (`computeCoalitionKey`), and checks the program's signer-count bounds before sending. The coalition key is unsigned instruction data that the program checks projectively against its own sum, so a wrong key only fails the transaction. Pass `{ coalitionKey }` to skip the `Node` fetch when you already hold it.
+
+If the signed 32-byte value is the keccak digest of a longer preimage, pass `{ rawValue }` (up to 256 bytes). The SDK verifies the digest before sending:
+
+```ts
+const { signature, feed } = await sdk.solana.submitAttestation(result, { rawValue });
+```
+
 Then read the feed this wallet wrote for that source and quorum:
 
 ```ts
-const feedState = await sdk.solana.readFeed(result.sourceId, signaturesRequired);
+const feedState = await sdk.solana.readFeed(result.payload.sourceId, signaturesRequired);
 ```
 
+`FeedAccount.value` is the 32 signed bytes (`valueKind.value`) or their keccak preimage hash (`valueKind.hash`); `submitter` is the wallet that created the feed.
+
+The subscription read no longer exposes usage. The program dropped `used_rounds` / `prepaid_usdc` / `price` from `Subscription`; round quota is counted by the gateway's off-chain outbox, so `SubscriptionInfo` carries only `owner`, `planType`, `validUntil`, `maxRounds`, `delegateCount`, `maxDelegates`, `maxSigners`.
+
 ### One-call request + submit
 
 ```ts
@@ -345,6 +353,54 @@ 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`.
 
+## Median tolerance mode
+
+By default every signing node must observe the identical value. For noisy numeric sources
+(prices), add an `aggregation` object and the selected nodes instead exchange signed
+observations, drop stale ones and outliers, and sign the **lower median** of
+`signaturesRequired` surviving observations:
+
+```ts
+const apiConfig = {
+  url: "https://api.example.com/price",
+  responseParser: "$.price",
+  aggregation: {
+    mode: "tolerance",
+    rule: "median",
+    maxDeviationBps: 50, // u32: allowed distance from the lower median, in bps
+    maxAgeMs: 2000, // > 0: max observation age in milliseconds
+    numeric: { type: "int256", decimals: 8 }, // value = round-half-even(price * 10^8)
+  },
+};
+
+const { result } = await sdk.requestAndSubmit({ apiConfig, signaturesRequired: 5 });
+```
+
+Rules (the node is the reference; the SDK rejects violations before any request is made, with `AggregationConfigError`):
+
+- `aggregation` is part of the `sourceId` and is **omitted** for exact mode. `mode: "exact"` is rejected because it would change the identity.
+- Only `rule: "median"` and `numeric.type: "int256"` are supported. `decimals` is `0..255`, `maxDeviationBps` a u32, `maxAgeMs` a positive integer.
+- Tolerance needs `signaturesRequired >= 3`.
+- The nested object is rebuilt in canonical order (`mode`, `rule`, `maxDeviationBps`, `maxAgeMs`, `numeric{type, decimals}`); extra or reordered keys on your input never reach the hash. For the config above, `sourceId` hashes exactly `{"url":...,"method":"GET","headers":{},"responseParser":"$.price","valueTransform":"","aggregation":{"mode":"tolerance","rule":"median","maxDeviationBps":50,"maxAgeMs":2000,"numeric":{"type":"int256","decimals":8}}}` (pinned against the node's Go test `TestAggregationSourceIdentity`).
+- The signed value is a signed `int256` (two's-complement `bytes32`). For tolerance results `Attestation.value` is rendered from the signed `payload.value` at the source's `decimals`, and `signature.signersBitmap` / signature fields must come from the response, since the nodes choose the final signing set after the observation exchange.
+- The gateway must forward `aggregation` to the nodes. If it derives a different identity, the response's `sourceId` / `configHash` will not match and the SDK throws; a gateway that echoes `aggregation` in its response must echo the requested policy.
+
+Helpers for the signed value (mirror the node's `new/tolerance` package):
+
+```ts
+import {
+  encodeInt256Decimal, // ("42150.12345678", 8) -> 32-byte Uint8Array, round half to even, bounds-checked
+  decodeInt256, //        bytes32 (Uint8Array | hex) -> bigint
+  formatInt256Decimal, // bytes32 or bigint, decimals -> "42150.12345678" (trailing zeros trimmed)
+  encodeInt256, //        bigint -> bytes32
+  INT256_MIN,
+  INT256_MAX,
+} from "@molpha/sdk";
+
+const feedState = await sdk.solana.readFeed(result.payload.sourceId, 5);
+const price = formatInt256Decimal(Uint8Array.from(feedState!.value), 8);
+```
+
 ## Private APIs and encrypted secrets
 
 Sources can use private APIs without sending plaintext secrets to the gateway.
@@ -366,7 +422,7 @@ const result = await sdk.gateway.requestSignedData({
 
 `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.
+Secrets are encrypted into per-node envelopes. The gateway coordinates the round but should not receive plaintext API credentials. The encrypted plaintext is the canonical config (including `aggregation`) with secrets substituted.
 
 Private API access is still an active security-sensitive surface. Do not treat encrypted secret delivery as production-ready until gateway/node-side test vectors and validation are complete.
 
@@ -455,90 +511,121 @@ Supported network ids (selection helpers only): `evm-sepolia`, `arbitrum-sepolia
 
 ### Build verifier arguments
 
+The verifier's entrypoint is
+`verify(Attestation attestation, uint64 maxAge) returns (bool success, uint8 code)`.
+
 ```ts
 import { buildEvmVerifierArgs } from "@molpha/sdk";
 
 const result = await sdk.gateway.requestSignedData({ apiConfig, signaturesRequired });
 
-const { dataUpdate, signature } = buildEvmVerifierArgs(result);
+const { attestation, maxAge } = buildEvmVerifierArgs(result, { maxAge: 300 });
 ```
 
-The generated tuples match the Molpha EVM verifier ABI:
+`maxAge` is required. It is the freshness window in seconds: the verifier reports an older
+attestation as `STALE`, and one dated after `block.timestamp` as `MALFORMED`. `0` disables the
+check entirely — pass it only when your contract enforces freshness or ordering itself, because
+a stateless verifier otherwise accepts a correctly signed attestation forever.
 
-```ts
-// dataUpdate:
-// [bytes32 sourceId,
-//  uint32 registryVersion,
-//  uint32 signaturesRequired,
-//  bytes32 valuePacked,
-//  uint64 timestamp]
+The generated object matches the Solidity `IVerifier.Attestation` struct, using viem's
+primitive types so it passes straight into `readContract` or an ethers `Contract`. Member
+order is ABI order (and the signed message's order). The gateway `Attestation` uses the same
+nested shape with lowercase hex strings instead of viem primitives:
 
-// signature:
-// [bytes32 s,
-//  address commitment,
-//  uint256 signersBitmap]
+```ts
+attestation:
+{
+  payload: {
+    value: `0x${string}`,          // bytes32 (Attestation.payload.value)
+    sourceId: `0x${string}`,       // bytes32
+    registryVersion: number,       // uint32
+    signaturesRequired: number,    // uint8
+    canonicalTimestamp: bigint,    // uint64
+  },
+  signature: {
+    signature: `0x${string}`,      // bytes32 (Attestation.signature.s)
+    commitment: `0x${string}`,     // address (Attestation.signature.commitmentAddr)
+    signersBitmap: bigint,         // uint256
+  },
+}
+maxAge: bigint                     // uint64
 ```
 
-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.
+The builder range-checks every integer against its Solidity type. Out-of-range calldata never
+reaches `verify`: the ABI decoder reverts on it instead of returning a result code.
 
-### ethers
+### viem
 
 ```ts
-import { Contract } from "ethers";
+import { createPublicClient, http } from "viem";
 import {
   buildEvmVerifierArgs,
+  MOLPHA_VERIFIER_ABI,
   MOLPHA_VERIFIER_ADDRESS,
+  parseEvmVerifyResult,
 } from "@molpha/sdk";
 
-const verifier = new Contract(
-  MOLPHA_VERIFIER_ADDRESS,
-  abi,
-  signer,
-);
+const client = createPublicClient({ chain, transport: http() });
+const { attestation, maxAge } = buildEvmVerifierArgs(result, { maxAge: 300 });
 
-const { dataUpdate, signature } = buildEvmVerifierArgs(result);
+const returned = await client.readContract({
+  address: MOLPHA_VERIFIER_ADDRESS,
+  abi: MOLPHA_VERIFIER_ABI,
+  functionName: "verify",
+  args: [attestation, maxAge],
+});
 
-await verifier.verify(dataUpdate, signature);
+const { success, code, reason } = parseEvmVerifyResult(returned);
+// { success: true, code: 0, reason: "OK" }
+// { success: false, code: 10, reason: "STALE" }
 ```
 
-### viem
+### ethers
 
 ```ts
-import { createPublicClient, http } from "viem";
+import { Contract } from "ethers";
 import {
   buildEvmVerifierArgs,
   MOLPHA_VERIFIER_ABI,
   MOLPHA_VERIFIER_ADDRESS,
+  parseEvmVerifyResult,
 } from "@molpha/sdk";
 
-const client = createPublicClient({
-  chain,
-  transport: http(),
-});
+const verifier = new Contract(MOLPHA_VERIFIER_ADDRESS, MOLPHA_VERIFIER_ABI, provider);
+const { attestation, maxAge } = buildEvmVerifierArgs(result, { maxAge: 300 });
 
-const { dataUpdate, signature } = buildEvmVerifierArgs(result);
+const { success, code, reason } = parseEvmVerifyResult(await verifier.verify(attestation, maxAge));
+```
 
-await client.readContract({
-  address: MOLPHA_VERIFIER_ADDRESS,
-  abi: MOLPHA_VERIFIER_ABI,
-  functionName: "verify",
-  args: [
-    {
-      sourceId: dataUpdate[0],
-      registryVersion: dataUpdate[1],
-      signaturesRequired: dataUpdate[2],
-      value: dataUpdate[3],
-      canonicalTimestamp: BigInt(dataUpdate[4]),
-    },
-    {
-      signature: signature[0],
-      commitment: signature[1],
-      signersBitmap: signature[2],
-    },
-  ],
-});
+### Raw `eth_call`
+
+`encodeEvmVerifyCalldata` produces the full calldata (selector `0x67e2907b` plus nine static
+words), and `parseEvmVerifyResult` also accepts the raw 64-byte return data:
+
+```ts
+import { buildEvmVerifierArgs, encodeEvmVerifyCalldata, parseEvmVerifyResult } from "@molpha/sdk";
+
+const args = buildEvmVerifierArgs(result, { maxAge: 300 });
+const returnData = await provider.call({ to: verifierAddress, data: encodeEvmVerifyCalldata(args) });
+
+const { success, code, reason } = parseEvmVerifyResult(returnData);
 ```
 
+`verify` never reverts; a rejection is a result code from the shared `VERIFY_CODES` table (see
+[the Starknet section](#call-verify-and-read-the-result) for the full list). The EVM verifier
+returns `MALFORMED` for a zero `signaturesRequired`, a zero or out-of-range signature scalar, a
+zero commitment, or fewer set bitmap bits than `signaturesRequired`. `parseEvmVerifyResult`
+throws when `success` and `code` disagree, which means the call did not reach a Molpha verifier
+of this interface.
+
+### Registry reads
+
+`MOLPHA_VERIFIER_ABI` also covers every read-only registry view — `getRegistryVersion`,
+`getTotalNodes`, `redundancyBuffer`, `getRegistryRoot` / `getRegistryPointer` (current or per
+version), `activatesAt`, `retiredAt`, `isLatestVersion`, `nodeStatus`, `isNode` — and the
+`InvalidRegistryVersion` error the per-version views revert with. Owner-only mutators are not
+included.
+
 Lower-level helpers are also exported for manual integrations:
 
 ```ts
@@ -594,7 +681,8 @@ enforces freshness or ordering itself, because a stateless verifier otherwise ac
 correctly signed attestation forever.
 
 The generated object matches the Cairo `Attestation` struct. Member order is Cairo `Serde`
-order (and the signed message's order), so it differs from `DataUpdateResult`:
+order (and the signed message's order). The gateway `Attestation` uses the same nested shape
+with lowercase hex strings instead of Cairo felts:
 
 ```ts
 attestation:
@@ -685,7 +773,9 @@ A Molpha attestation is valid only if the verifier can confirm:
 - 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, the signer `Node` accounts passed as remaining accounts are exactly `registry.nodes[bit]` for every set bit.
+- on Solana, the signer `Node` accounts passed as remaining accounts are exactly `registry.nodes[bit]` for every set bit, and the supplied coalition key matches the sum of their keys.
+
+A valid signature does not replace consumer policy: freshness, source, quorum and replay checks remain the consumer's responsibility.
 
 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.
 
@@ -701,6 +791,8 @@ import { MOLPHA_IDL, MOLPHA_PROGRAM_ADDRESS } from "@molpha/sdk";
 
 Override `idl` and `programId` when targeting another deployment.
 
+The vendored IDL is `anchor idl build -p molpha` output for `molpha-solana-program` `3d01170` ("Epoch settlements (#47)").
+
 Keep the vendored IDL aligned with the deployed program. Mismatched IDL/program versions can produce invalid account derivations, decoding errors, or failed instruction simulation.
 
 ## Standalone clients
@@ -746,7 +838,7 @@ Current scope:
 - Solana attestation submission and feed/registry reads;
 - private API encryption helpers (pre-production);
 - caller-funded x402 payments for paywalled API sources (Base USDC, pre-production);
-- EVM and Starknet verifier argument building, Starknet `verify` calldata encoding and result decoding;
+- EVM and Starknet verifier argument building, `verify` calldata encoding and result decoding;
 - deployed testnet verifier address helpers.
 
 Known limitations:
@@ -760,27 +852,6 @@ Known limitations:
 
 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` |
-| `buildStarknetVerifierArgs(result)` → `{ dataUpdate, signature }` | `buildStarknetVerifierArgs(result, { maxAge })` → `{ attestation, maxAge }` for `verify(attestation, max_age)` |
-| `StarknetDataUpdate` (`signatures_required: u32`) | `StarknetAttestationPayload` (`signatures_required: u8`, `value` first), nested in `StarknetAttestation` |
-| Starknet `verify` returns `bool` | returns `(bool, u8)` — decode with `parseStarknetVerifyResult` |
-| `resolveRegistryIndexForVersion`, `VIRTUAL_INDEX`, `nodePda(index)` | removed — signer accounts are `registry.nodes[bit]`; `nodePda(owner)` |
-
 ## Develop
 
 ```bash
@@ -861,12 +932,6 @@ Versions follow semver and are driven by the nature of each change, not by the b
 
    The `dev` workflow should guard against this and fail until a stable `latest` exists.
 
-3. Deprecate the legacy package name on npm (one-time, after `@molpha/sdk@0.1.0` is published):
-
-   ```bash
-   npm deprecate "@molpha-oracle/sdk" "Package renamed to @molpha/sdk. Please migrate."
-   ```
-
 If `latest` ever points to a prerelease, repoint it after publishing a stable version:
 
 ```bash

package/dist/{chunk-DT6IKCWB.js → chunk-2X22JY7Q.js}

@@ -1,6 +1,5 @@
 import { web3 } from '@anchor-lang/core';
 import { address, getAddressEncoder, getAddressDecoder } from '@solana/kit';
-import { ed25519 } from '@noble/curves/ed25519.js';
 
 // src/solana/kit.ts
 var TOKEN_PROGRAM_ADDRESS = address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA");
@@ -38,18 +37,7 @@ function setComputeUnitLimit(units) {
 function keypairFromSecretKey(secretKey) {
   return web3.Keypair.fromSecretKey(secretKey);
 }
-var isKeypair = (value) => typeof value === "object" && value !== null && "secretKey" in value && value.secretKey instanceof Uint8Array;
-function signerFromKeypair(keypair) {
-  const seed = keypair.secretKey.slice(0, 32);
-  return async (message) => ed25519.sign(message, seed);
-}
-function gatewaySignerFromWallet(wallet) {
-  const molpha = wallet;
-  if (molpha.signAuthMessage) return molpha.signAuthMessage;
-  if ("payer" in wallet && isKeypair(wallet.payer)) return signerFromKeypair(wallet.payer);
-  return void 0;
-}
 
-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
+export { SYSTEM_PROGRAM_ADDRESS, TOKEN_PROGRAM_ADDRESS, addressBytes, addressFromBytes, findProgramAddressSync, getAssociatedTokenAddressSync, keypairFromSecretKey, setComputeUnitLimit, toPublicKey, toSolanaAddress };
+//# sourceMappingURL=chunk-2X22JY7Q.js.map
+//# sourceMappingURL=chunk-2X22JY7Q.js.map

package/dist/chunk-2X22JY7Q.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/solana/kit.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","file":"chunk-2X22JY7Q.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"]}