@secondlayer/sdk 6.18.0 → 6.19.0

package/dist/index.d.ts

@@ -232,6 +232,13 @@ declare class Contracts extends BaseClient {
 	constructor(options?: Partial<SecondLayerOptions>);
 	/** Find contracts conforming to `trait`. `trait` is required (server 400s without it). */
 	list(params: ContractsListParams): Promise<ContractsEnvelope>;
+	/**
+	* Fetch a single contract from the registry by id (the prod-safe ABI source).
+	* Pass `{ includeAbi: true }` for the full ABI blob. Resolves null on 404.
+	*/
+	get(contractId: string, opts?: {
+		includeAbi?: boolean
+	}): Promise<ContractSummary | null>;
 }
 /**
 * Typed client for the Foundation Datasets REST API (`/v1/datasets/*`).
@@ -382,6 +389,85 @@ declare class Datasets extends BaseClient {
 	private paramsToQuery;
 	private cursorDataset;
 }
+import { RewardSet } from "@secondlayer/shared/node/consensus";
+import { MerkleProofStep } from "@secondlayer/shared/node/nakamoto";
+/**
+* Trustless transaction-inclusion proof verification.
+*
+* Given a proof from `GET /v1/index/transactions/:txid/proof`, the consumer
+* re-derives everything itself — it does NOT trust any value Secondlayer
+* computed. Anchored level: (1) recompute the txid from the raw tx bytes, (2)
+* fold it up the merkle path to the header's `tx_merkle_root`, (3) recompute the
+* header's `block_hash` and `index_block_hash` from the raw header — "this tx is
+* included in a header any node can corroborate". Consensus level (when the proof
+* carries a `consensus` field, or a `rewardSet` is passed): additionally recover
+* the header's signer signatures and confirm ≥70% of reward-set signer weight
+* signed the block.
+*
+* Note: uses Node's crypto via `@secondlayer/shared` (same as the Streams
+* signature verify); intended for Node/server verification.
+*/
+interface TransactionProof {
+	txid: string;
+	index_block_hash: string;
+	block_height: number;
+	tx_index: number;
+	/** Raw consensus-serialized transaction bytes (hex). */
+	raw_tx: string;
+	/** Raw Nakamoto block-header bytes (hex) — parsed + re-hashed by the verifier. */
+	raw_header: string;
+	/** Authentication path from the tx leaf to `tx_merkle_root`. */
+	tx_merkle_path: MerkleProofStep[];
+	/** Present when consensus-level verification is available: the reward cycle and
+	*  its signer set, against which the header's signer signatures are checked. */
+	consensus?: {
+		reward_cycle: number
+		reward_set: RewardSet
+	};
+}
+interface TransactionProofVerifyResult {
+	/** Highest level actually verified. "consensus" requires the proof's
+	*  `consensus` field and a met signer-weight threshold. */
+	level: "anchored" | "consensus";
+	/** Recomputed txid === proof.txid. */
+	txidMatches: boolean;
+	/** Merkle path folds the txid to the header's tx_merkle_root. */
+	includedInHeader: boolean;
+	/** Recomputed block_hash + index_block_hash match the header / proof. */
+	headerSelfConsistent: boolean;
+	/** Basis points (0–10000) of reward-set signer weight that signed the block.
+	*  Only set when the proof carries a `consensus` field. */
+	signerWeightBps?: number;
+	/** ≥70% of signer weight signed. Only set with a `consensus` field. */
+	thresholdMet?: boolean;
+	/** Which reward set the signer check used: "provided" (caller-resolved →
+	*  fully trustless) or "embedded" (the one Secondlayer put in the proof). */
+	rewardSetSource?: "provided" | "embedded";
+	/** All applicable checks passed (incl. the threshold when consensus is present). */
+	ok: boolean;
+	errors: string[];
+}
+/**
+* Resolve a reward set directly from a stacks-node (`/v3/stacker_set/{cycle}`),
+* so a caller can verify the consensus layer against a node IT trusts rather than
+* the reward set Secondlayer embedded in the proof. Pass the result as
+* `verifyTransactionProof(proof, { rewardSet })`.
+*/
+declare function fetchRewardSet(opts: {
+	nodeUrl: string
+	cycle: number
+	fetchImpl?: typeof fetch
+}): Promise<RewardSet | null>;
+/**
+* Verify a transaction-inclusion proof. Every check is recomputed client-side,
+* so a `true` result does not rely on trusting Secondlayer. Pass
+* `{ rewardSet }` (resolved via {@link fetchRewardSet} from your own node) to
+* verify the consensus layer against a reward set you trust rather than the one
+* embedded in the proof.
+*/
+declare function verifyTransactionProof(proof: TransactionProof, opts?: {
+	rewardSet?: RewardSet
+}): TransactionProofVerifyResult;
 type IndexTip = {
 	block_height: number
 	lag_seconds: number
@@ -941,6 +1027,7 @@ declare class Index extends BaseClient {
 		list: (params?: TransactionsListParams) => Promise<TransactionsEnvelope>
 		walk: (params?: TransactionsWalkParams) => AsyncIterable<IndexTransaction>
 		get: (txId: string) => Promise<TransactionEnvelope | null>
+		getProof: (txId: string) => Promise<TransactionProof | null>
 	};
 	/** Decoded PoX-4 stacking actions. Empty (with a `notes` hint) when the
 	*  platform's PoX-4 decoder is disabled. */
@@ -970,6 +1057,11 @@ declare class Index extends BaseClient {
 	private walkBlocks;
 	private listTransactions;
 	private getTransaction;
+	/** Fetch the inclusion proof for a tx (raw tx + Nakamoto header + merkle path)
+	*  to verify client-side with `verifyTransactionProof`. 404 → null. A 503
+	*  (`PROOF_TX_SET_INCOMPLETE` / `PROOF_NODE_UNAVAILABLE`) surfaces as an
+	*  ApiError — the proof can't be assembled on this deployment right now. */
+	private getTransactionProof;
 	private walkTransactions;
 	private listStacking;
 	private walkStacking;
@@ -2026,85 +2118,6 @@ declare function verifyWebhookSignature(rawBody: string, headers: WebhookHeaderI
 * ```
 */
 declare function verifySecondlayerSignature(rawBody: string, headers: WebhookHeaderInput, publicKeyPem: string): boolean;
-import { RewardSet } from "@secondlayer/shared/node/consensus";
-import { MerkleProofStep } from "@secondlayer/shared/node/nakamoto";
-/**
-* Trustless transaction-inclusion proof verification.
-*
-* Given a proof from `GET /v1/index/transactions/:txid/proof`, the consumer
-* re-derives everything itself — it does NOT trust any value Secondlayer
-* computed. Anchored level: (1) recompute the txid from the raw tx bytes, (2)
-* fold it up the merkle path to the header's `tx_merkle_root`, (3) recompute the
-* header's `block_hash` and `index_block_hash` from the raw header — "this tx is
-* included in a header any node can corroborate". Consensus level (when the proof
-* carries a `consensus` field, or a `rewardSet` is passed): additionally recover
-* the header's signer signatures and confirm ≥70% of reward-set signer weight
-* signed the block.
-*
-* Note: uses Node's crypto via `@secondlayer/shared` (same as the Streams
-* signature verify); intended for Node/server verification.
-*/
-interface TransactionProof {
-	txid: string;
-	index_block_hash: string;
-	block_height: number;
-	tx_index: number;
-	/** Raw consensus-serialized transaction bytes (hex). */
-	raw_tx: string;
-	/** Raw Nakamoto block-header bytes (hex) — parsed + re-hashed by the verifier. */
-	raw_header: string;
-	/** Authentication path from the tx leaf to `tx_merkle_root`. */
-	tx_merkle_path: MerkleProofStep[];
-	/** Present when consensus-level verification is available: the reward cycle and
-	*  its signer set, against which the header's signer signatures are checked. */
-	consensus?: {
-		reward_cycle: number
-		reward_set: RewardSet
-	};
-}
-interface TransactionProofVerifyResult {
-	/** Highest level actually verified. "consensus" requires the proof's
-	*  `consensus` field and a met signer-weight threshold. */
-	level: "anchored" | "consensus";
-	/** Recomputed txid === proof.txid. */
-	txidMatches: boolean;
-	/** Merkle path folds the txid to the header's tx_merkle_root. */
-	includedInHeader: boolean;
-	/** Recomputed block_hash + index_block_hash match the header / proof. */
-	headerSelfConsistent: boolean;
-	/** Basis points (0–10000) of reward-set signer weight that signed the block.
-	*  Only set when the proof carries a `consensus` field. */
-	signerWeightBps?: number;
-	/** ≥70% of signer weight signed. Only set with a `consensus` field. */
-	thresholdMet?: boolean;
-	/** Which reward set the signer check used: "provided" (caller-resolved →
-	*  fully trustless) or "embedded" (the one Secondlayer put in the proof). */
-	rewardSetSource?: "provided" | "embedded";
-	/** All applicable checks passed (incl. the threshold when consensus is present). */
-	ok: boolean;
-	errors: string[];
-}
-/**
-* Resolve a reward set directly from a stacks-node (`/v3/stacker_set/{cycle}`),
-* so a caller can verify the consensus layer against a node IT trusts rather than
-* the reward set Secondlayer embedded in the proof. Pass the result as
-* `verifyTransactionProof(proof, { rewardSet })`.
-*/
-declare function fetchRewardSet(opts: {
-	nodeUrl: string
-	cycle: number
-	fetchImpl?: typeof fetch
-}): Promise<RewardSet | null>;
-/**
-* Verify a transaction-inclusion proof. Every check is recomputed client-side,
-* so a `true` result does not rely on trusting Secondlayer. Pass
-* `{ rewardSet }` (resolved via {@link fetchRewardSet} from your own node) to
-* verify the consensus layer against a reward set you trust rather than the one
-* embedded in the proof.
-*/
-declare function verifyTransactionProof(proof: TransactionProof, opts?: {
-	rewardSet?: RewardSet
-}): TransactionProofVerifyResult;
 import { RewardSet as RewardSet2 } from "@secondlayer/shared/node/consensus";
 /** Make a cvToValue result JSON-serializable: Clarity (u)ints decode to bigint,
 *  which JSON.stringify can't handle — convert recursively to strings. */

package/dist/index.js

@@ -417,6 +417,16 @@ class Contracts extends BaseClient {
       cursor: params.cursor
     })}`);
   }
+  async get(contractId, opts = {}) {
+    try {
+      const { contract } = await this.request("GET", `/v1/contracts/${encodeURIComponent(contractId)}${opts.includeAbi ? "?include=abi" : ""}`);
+      return contract;
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404)
+        return null;
+      throw err;
+    }
+  }
 }
 
 // src/datasets/client.ts
@@ -624,7 +634,8 @@ class Index extends BaseClient {
   transactions = {
     list: (params = {}) => this.listTransactions(params),
     walk: (params = {}) => this.walkTransactions(params),
-    get: (txId) => this.getTransaction(txId)
+    get: (txId) => this.getTransaction(txId),
+    getProof: (txId) => this.getTransactionProof(txId)
   };
   stacking = {
     list: (params = {}) => this.listStacking(params),
@@ -886,6 +897,15 @@ class Index extends BaseClient {
       throw err;
     }
   }
+  async getTransactionProof(txId) {
+    try {
+      return await this.request("GET", `/v1/index/transactions/${encodeURIComponent(txId)}/proof`);
+    } catch (err) {
+      if (err instanceof ApiError && err.status === 404)
+        return null;
+      throw err;
+    }
+  }
   async* walkTransactions(params = {}) {
     const batchSize = params.batchSize ?? 200;
     let cursor = params.cursor ?? params.fromCursor ?? null;
@@ -2249,5 +2269,5 @@ export {
   ApiError
 };
 
-//# debugId=DBAA238399806ED364756E2164756E21
+//# debugId=AD881ECDD1B046B864756E2164756E21
 //# sourceMappingURL=index.js.map