@secondlayer/stacks 2.3.0 → 2.5.0

package/dist/src/x402/index.d.ts

@@ -0,0 +1,424 @@
+/** Full chain descriptor used by clients and transports for network-aware operations. */
+type StacksChain = {
+	/** Chain ID (e.g. 0x00000001 for mainnet) */
+	id: number
+	/** Human-readable name */
+	name: string
+	/** Network type */
+	network: "mainnet" | "testnet"
+	/** Transaction version byte for serialization */
+	transactionVersion: number
+	/** Peer network ID for P2P broadcasting */
+	peerNetworkId: number
+	/** Address version bytes */
+	addressVersion: {
+		singleSig: number
+		multiSig: number
+	}
+	/** Magic bytes for network identification */
+	magicBytes: string
+	/** Boot address (system contracts deployer) */
+	bootAddress: string
+	/** Native currency info */
+	nativeCurrency: {
+		name: string
+		symbol: string
+		decimals: number
+	}
+	/** Default RPC URLs */
+	rpcUrls: {
+		default: {
+			http: string[]
+			ws?: string[]
+		}
+	}
+	/** Block explorer URLs */
+	blockExplorers?: {
+		default: {
+			name: string
+			url: string
+		}
+	}
+};
+type IntCV = {
+	readonly type: "int"
+	readonly value: bigint
+};
+type UIntCV = {
+	readonly type: "uint"
+	readonly value: bigint
+};
+type BooleanCV = TrueCV | FalseCV;
+type TrueCV = {
+	readonly type: "true"
+};
+type FalseCV = {
+	readonly type: "false"
+};
+type BufferCV = {
+	readonly type: "buffer"
+	readonly value: string
+};
+type NoneCV = {
+	readonly type: "none"
+};
+type SomeCV = {
+	readonly type: "some"
+	readonly value: ClarityValue
+};
+type ResponseOkCV = {
+	readonly type: "ok"
+	readonly value: ClarityValue
+};
+type ResponseErrorCV = {
+	readonly type: "err"
+	readonly value: ClarityValue
+};
+type StandardPrincipalCV = {
+	readonly type: "address"
+	readonly value: string
+};
+type ContractPrincipalCV = {
+	readonly type: "contract"
+	readonly value: string
+};
+type ListCV = {
+	type: "list"
+	value: ClarityValue[]
+};
+type TupleData = {
+	[key: string]: ClarityValue
+};
+type TupleCV = {
+	type: "tuple"
+	value: TupleData
+};
+type StringAsciiCV = {
+	readonly type: "ascii"
+	readonly value: string
+};
+type StringUtf8CV = {
+	readonly type: "utf8"
+	readonly value: string
+};
+type ClarityValue = IntCV | UIntCV | BooleanCV | BufferCV | NoneCV | SomeCV | ResponseOkCV | ResponseErrorCV | StandardPrincipalCV | ContractPrincipalCV | ListCV | TupleCV | StringAsciiCV | StringUtf8CV;
+declare const AuthType: {
+	readonly Standard: 0x04
+	readonly Sponsored: 0x05
+};
+type AuthType = (typeof AuthType)[keyof typeof AuthType];
+declare const PayloadType: {
+	readonly TokenTransfer: 0x00
+	readonly SmartContract: 0x01
+	readonly ContractCall: 0x02
+	readonly PoisonMicroblock: 0x03
+	readonly Coinbase: 0x04
+	readonly CoinbaseToAltRecipient: 0x05
+	readonly VersionedSmartContract: 0x06
+	readonly TenureChange: 0x07
+	readonly NakamotoCoinbase: 0x08
+};
+type PayloadType = (typeof PayloadType)[keyof typeof PayloadType];
+declare const ClarityVersion: {
+	readonly Clarity1: 1
+	readonly Clarity2: 2
+	readonly Clarity3: 3
+	readonly Clarity4: 4
+	readonly Clarity5: 5
+};
+type ClarityVersion = (typeof ClarityVersion)[keyof typeof ClarityVersion];
+declare const AnchorMode: {
+	readonly OnChainOnly: 0x01
+	readonly OffChainOnly: 0x02
+	readonly Any: 0x03
+};
+type AnchorMode = (typeof AnchorMode)[keyof typeof AnchorMode];
+declare const PostConditionModeWire: {
+	readonly Allow: 0x01
+	readonly Deny: 0x02
+};
+type PostConditionModeWire = (typeof PostConditionModeWire)[keyof typeof PostConditionModeWire];
+declare const AddressHashMode: {
+	readonly P2PKH: 0x00
+	readonly P2SH: 0x01
+	readonly P2WPKH: 0x02
+	readonly P2WSH: 0x03
+	readonly P2SH_NonSequential: 0x05
+	readonly P2WSH_P2SH_NonSequential: 0x07
+};
+type AddressHashMode = (typeof AddressHashMode)[keyof typeof AddressHashMode];
+declare const PubKeyEncoding: {
+	readonly Compressed: 0x00
+	readonly Uncompressed: 0x01
+};
+type PubKeyEncoding = (typeof PubKeyEncoding)[keyof typeof PubKeyEncoding];
+declare const TenureChangeCause: {
+	readonly BlockFound: 0x00
+	readonly Extended: 0x01
+	readonly ExtendedRuntime: 0x02
+	readonly ExtendedReadCount: 0x03
+	readonly ExtendedReadLength: 0x04
+	readonly ExtendedWriteCount: 0x05
+	readonly ExtendedWriteLength: 0x06
+};
+type TenureChangeCause = (typeof TenureChangeCause)[keyof typeof TenureChangeCause];
+type TokenTransferPayload = {
+	payloadType: typeof PayloadType.TokenTransfer
+	recipient: ClarityValue
+	amount: bigint
+	memo: string
+};
+type ContractCallPayload = {
+	payloadType: typeof PayloadType.ContractCall
+	contractAddress: string
+	contractName: string
+	functionName: string
+	functionArgs: ClarityValue[]
+};
+type SmartContractPayload = {
+	payloadType: typeof PayloadType.SmartContract | typeof PayloadType.VersionedSmartContract
+	clarityVersion?: ClarityVersion
+	contractName: string
+	codeBody: string
+};
+type CoinbasePayload = {
+	payloadType: typeof PayloadType.Coinbase
+	coinbaseBuffer: string
+};
+type CoinbaseToAltRecipientPayload = {
+	payloadType: typeof PayloadType.CoinbaseToAltRecipient
+	coinbaseBuffer: string
+	recipient: ClarityValue
+};
+type PoisonMicroblockPayload = {
+	payloadType: typeof PayloadType.PoisonMicroblock
+	header1: string
+	header2: string
+};
+type TenureChangePayload = {
+	payloadType: typeof PayloadType.TenureChange
+	tenureConsensusHash: string
+	prevTenureConsensusHash: string
+	burnViewConsensusHash: string
+	previousTenureEnd: string
+	previousTenureBlocks: number
+	cause: TenureChangeCause
+	pubkeyHash: string
+};
+type NakamotoCoinbasePayload = {
+	payloadType: typeof PayloadType.NakamotoCoinbase
+	coinbaseBuffer: string
+	recipient: ClarityValue | null
+	vrfProof: string
+};
+type TransactionPayload = TokenTransferPayload | ContractCallPayload | SmartContractPayload | CoinbasePayload | CoinbaseToAltRecipientPayload | PoisonMicroblockPayload | TenureChangePayload | NakamotoCoinbasePayload;
+type SingleSigSpendingCondition = {
+	hashMode: typeof AddressHashMode.P2PKH | typeof AddressHashMode.P2WPKH
+	signer: string
+	nonce: bigint
+	fee: bigint
+	keyEncoding: PubKeyEncoding
+	signature: string
+};
+type TransactionAuthField = {
+	pubKeyEncoding: PubKeyEncoding
+	type: "publicKey" | "signature"
+	data: string
+};
+type MultiSigHashMode = typeof AddressHashMode.P2SH | typeof AddressHashMode.P2WSH | typeof AddressHashMode.P2SH_NonSequential | typeof AddressHashMode.P2WSH_P2SH_NonSequential;
+type MultiSigSpendingCondition = {
+	hashMode: MultiSigHashMode
+	signer: string
+	nonce: bigint
+	fee: bigint
+	fields: TransactionAuthField[]
+	signaturesRequired: number
+};
+type SpendingCondition = SingleSigSpendingCondition | MultiSigSpendingCondition;
+type StandardAuthorization = {
+	authType: typeof AuthType.Standard
+	spendingCondition: SpendingCondition
+};
+type SponsoredAuthorization = {
+	authType: typeof AuthType.Sponsored
+	spendingCondition: SpendingCondition
+	sponsorSpendingCondition: SpendingCondition
+};
+type Authorization = StandardAuthorization | SponsoredAuthorization;
+type StacksTransaction = {
+	version: number
+	chainId: number
+	auth: Authorization
+	anchorMode: AnchorMode
+	postConditionMode: PostConditionModeWire
+	postConditions: PostConditionWire[]
+	payload: TransactionPayload
+};
+type PostConditionWire = StxPostConditionWire | FtPostConditionWire | NftPostConditionWire;
+type StxPostConditionWire = {
+	type: "stx"
+	principal: PostConditionPrincipalWire
+	conditionCode: number
+	amount: bigint
+};
+type FtPostConditionWire = {
+	type: "ft"
+	principal: PostConditionPrincipalWire
+	asset: AssetInfoWire
+	conditionCode: number
+	amount: bigint
+};
+type NftPostConditionWire = {
+	type: "nft"
+	principal: PostConditionPrincipalWire
+	asset: AssetInfoWire
+	conditionCode: number
+	assetId: ClarityValue
+};
+type PostConditionPrincipalWire = {
+	type: "origin"
+} | {
+	type: "standard"
+	address: string
+} | {
+	type: "contract"
+	address: string
+	contractName: string
+};
+type AssetInfoWire = {
+	address: string
+	contractName: string
+	assetName: string
+};
+type IntegerType = number | string | bigint | Uint8Array;
+/**
+* The asset an x402 payment moves. Either native STX or a SIP-010 token,
+* in which case the fully-qualified contract id and the fungible-token asset
+* name (the `::<asset-name>` suffix, e.g. `sbtc-token`) are both required —
+* the asset name is not always equal to the contract name.
+*/
+type X402Asset = {
+	kind: "stx"
+} | {
+	kind: "sip010"
+	contractId: string
+	assetName: string
+};
+type BuildExactTransferOptions = {
+	/** The asset and amount to move. */
+	asset: X402Asset
+	amount: IntegerType
+	/** Recipient principal (the resource server's `payTo`). */
+	payTo: string
+	/** Origin/payer principal — pinned by the post-condition. */
+	payer: string
+	/** Origin compressed public key (the payer signs origin-only). */
+	payerPublicKey: string
+	/** The payer account's next nonce. */
+	accountNonce: IntegerType
+	/**
+	* The x402 challenge nonce, carried in the on-chain memo so the facilitator
+	* can correlate the settled tx with the challenge. Bound to ≤ 34 bytes
+	* (UTF-8) — both the STX memo and the SIP-010 `(buff 34)` memo arg cap there.
+	*/
+	nonce: string
+	chain?: StacksChain
+};
+/**
+* Build an exact-amount, Deny-mode, post-conditioned, **sponsored** transfer
+* (origin-only, un-broadcast). The origin sets fee `0`; the facilitator's
+* sponsor fills in + pays the fee at settle time. The Deny-mode post-condition
+* asserts EXACTLY `amount` leaves `payer` to `payTo`, so settlement aborts
+* on-chain if anything differs — the "exact amount" x402 guarantee is enforced
+* by Clarity, not just by facilitator simulation.
+*/
+declare function buildExactTransfer(options: BuildExactTransferOptions): StacksTransaction;
+/** Account derived from a local private key (mnemonic or raw key). */
+type LocalAccount = {
+	type: "local"
+	address: string
+	/** Compressed public key (hex) */
+	publicKey: string
+	/** Raw ECDSA sign over a hash */
+	sign(hash: Uint8Array): Uint8Array
+	/** Sign a structured message (SIP-018) */
+	signMessage(message: string | Uint8Array): string
+};
+/** Account with a user-provided signing function (sync or async). */
+type CustomAccount = {
+	type: "custom"
+	address: string
+	publicKey: string
+	sign(hash: Uint8Array): Promise<Uint8Array> | Uint8Array
+};
+/** Browser wallet provider interface (e.g. Leather, Xverse). */
+type StacksProvider = {
+	request(method: string, params?: any): Promise<any>
+};
+/** Account backed by a browser wallet {@link StacksProvider}. */
+type ProviderAccount = {
+	type: "provider"
+	address: string
+	publicKey: string
+	provider: StacksProvider
+};
+/** Function that sends an HTTP request to a Stacks node API path. */
+type RequestFn = (path: string, options?: RequestOptions) => Promise<any>;
+/** Options for a transport-level HTTP request. */
+type RequestOptions = {
+	method?: "GET" | "POST" | "PUT" | "DELETE"
+	body?: unknown
+	headers?: Record<string, string>
+};
+/** Shared configuration for all transport types. */
+type TransportConfig = {
+	url?: string
+	timeout?: number
+	retryCount?: number
+	retryDelay?: number
+	fetchOptions?: RequestInit
+	apiKey?: string
+};
+/** A resolved transport instance with a bound request function. */
+type Transport = {
+	type: string
+	request: RequestFn
+	config: TransportConfig
+	destroy?: () => void
+};
+/** Union of all supported account types (local key, custom signer, or browser provider). */
+type Account = LocalAccount | CustomAccount | ProviderAccount;
+/**
+* Core client instance that holds chain context, transport, and extensible actions.
+* Created via {@link createClient}, {@link createPublicClient}, or {@link createWalletClient}.
+*/
+type Client<TExtended extends Record<string, unknown> = Record<string, unknown>> = {
+	chain?: StacksChain
+	account?: Account
+	transport: Transport
+	request: RequestFn
+	extend: <const TNew extends Record<string, unknown>>(fn: (client: Client<TExtended>) => TNew) => Client<TExtended & TNew> & TNew
+} & TExtended;
+type SponsorAndBroadcastOptions = {
+	/** Override the sponsor fee (µSTX). Defaults to a fee estimate. */
+	fee?: IntegerType
+	/** Override the sponsor account nonce. Defaults to the on-chain nonce. */
+	nonce?: IntegerType
+};
+type SponsorAndBroadcastResult = {
+	txid: string
+};
+/**
+* Take an origin-signed, sponsored transfer (hex) from the payer, sponsor-sign
+* it with `client`'s account (paying the STX fee), and broadcast it.
+*
+* The payer never holds STX: they sign origin-only with fee `0`; this fills in
+* the sponsor spending condition + fee and POSTs to `/v2/transactions`. The
+* sponsor cannot grief the payer — amount/recipient/asset are pinned by the
+* origin signature + Deny-mode post-conditions baked into the tx.
+*
+* @param client a wallet client whose `account` is the funded sponsor signer.
+* @param signedTxHex the payer's origin-signed sponsored tx, hex-serialized.
+*/
+declare function sponsorAndBroadcast(client: Client, signedTxHex: string, options?: SponsorAndBroadcastOptions): Promise<SponsorAndBroadcastResult>;
+export { sponsorAndBroadcast, buildExactTransfer, X402Asset, SponsorAndBroadcastResult, SponsorAndBroadcastOptions, BuildExactTransferOptions };

package/dist/src/x402/index.js

@@ -0,0 +1,88 @@
+import {
+  sponsorTransaction
+} from "../../shared/stacks-4z1jhw6y.js";
+import {
+  sendTransaction
+} from "../../shared/stacks-y8e3gx6w.js";
+import"../../shared/stacks-709tra19.js";
+import {
+  Pc
+} from "../../shared/stacks-a36n7sjz.js";
+import {
+  deserializeTransaction
+} from "../../shared/stacks-wqgepfab.js";
+import {
+  MEMO_MAX_LENGTH_BYTES,
+  buildContractCall,
+  buildTokenTransfer
+} from "../../shared/stacks-4trgpb5a.js";
+import {
+  Cl
+} from "../../shared/stacks-0zysn74p.js";
+import"../../shared/stacks-xxn5ma6g.js";
+import {
+  parseContractId
+} from "../../shared/stacks-6xmk24yw.js";
+import {
+  utf8ToBytes
+} from "../../shared/stacks-2h8d2y27.js";
+import"../../shared/stacks-cfazrteq.js";
+
+// src/x402/build.ts
+function buildExactTransfer(options) {
+  const { asset, amount, payTo, payer, payerPublicKey, accountNonce, chain } = options;
+  if (utf8ToBytes(options.nonce).byteLength > MEMO_MAX_LENGTH_BYTES) {
+    throw new Error(`x402 nonce exceeds the ${MEMO_MAX_LENGTH_BYTES}-byte memo budget`);
+  }
+  if (asset.kind === "stx") {
+    return buildTokenTransfer({
+      recipient: payTo,
+      amount,
+      memo: options.nonce,
+      fee: 0,
+      nonce: accountNonce,
+      publicKey: payerPublicKey,
+      chain,
+      sponsored: true
+    });
+  }
+  const [contractAddress, contractName] = parseContractId(asset.contractId);
+  const postConditions = [
+    Pc.principal(payer).willSendEq(amount).ft(asset.contractId, asset.assetName)
+  ];
+  return buildContractCall({
+    contractAddress,
+    contractName,
+    functionName: "transfer",
+    functionArgs: [
+      Cl.uint(amount),
+      Cl.principal(payer),
+      Cl.principal(payTo),
+      Cl.some(Cl.bufferFromUtf8(options.nonce))
+    ],
+    fee: 0,
+    nonce: accountNonce,
+    publicKey: payerPublicKey,
+    chain,
+    postConditionMode: "deny",
+    postConditions,
+    sponsored: true
+  });
+}
+// src/x402/settle.ts
+async function sponsorAndBroadcast(client, signedTxHex, options = {}) {
+  const transaction = deserializeTransaction(signedTxHex);
+  const sponsored = await sponsorTransaction(client, {
+    transaction,
+    fee: options.fee,
+    nonce: options.nonce
+  });
+  return sendTransaction(client, { transaction: sponsored });
+}
+export {
+  sponsorAndBroadcast,
+  buildExactTransfer
+};
+
+//# debugId=42F79D53766B4A5064756E2164756E21
+//# sourceMappingURL=index.js.map

package/dist/src/x402/index.js.map

@@ -0,0 +1,11 @@
+{
+  "version": 3,
+  "sources": ["../src/x402/build.ts", "../src/x402/settle.ts"],
+  "sourcesContent": [
+    "import type { StacksChain } from \"../chains/types.ts\";\nimport { Cl } from \"../clarity/values.ts\";\nimport { Pc } from \"../postconditions/builder.ts\";\nimport type { PostCondition } from \"../postconditions/types.ts\";\nimport {\n\tbuildContractCall,\n\tbuildTokenTransfer,\n} from \"../transactions/build.ts\";\nimport {\n\tMEMO_MAX_LENGTH_BYTES,\n\ttype StacksTransaction,\n} from \"../transactions/types.ts\";\nimport { parseContractId } from \"../utils/address.ts\";\nimport { type IntegerType, utf8ToBytes } from \"../utils/encoding.ts\";\n\n/**\n * The asset an x402 payment moves. Either native STX or a SIP-010 token,\n * in which case the fully-qualified contract id and the fungible-token asset\n * name (the `::<asset-name>` suffix, e.g. `sbtc-token`) are both required —\n * the asset name is not always equal to the contract name.\n */\nexport type X402Asset =\n\t| { kind: \"stx\" }\n\t| { kind: \"sip010\"; contractId: string; assetName: string };\n\nexport type BuildExactTransferOptions = {\n\t/** The asset and amount to move. */\n\tasset: X402Asset;\n\tamount: IntegerType;\n\t/** Recipient principal (the resource server's `payTo`). */\n\tpayTo: string;\n\t/** Origin/payer principal — pinned by the post-condition. */\n\tpayer: string;\n\t/** Origin compressed public key (the payer signs origin-only). */\n\tpayerPublicKey: string;\n\t/** The payer account's next nonce. */\n\taccountNonce: IntegerType;\n\t/**\n\t * The x402 challenge nonce, carried in the on-chain memo so the facilitator\n\t * can correlate the settled tx with the challenge. Bound to ≤ 34 bytes\n\t * (UTF-8) — both the STX memo and the SIP-010 `(buff 34)` memo arg cap there.\n\t */\n\tnonce: string;\n\tchain?: StacksChain;\n};\n\n/**\n * Build an exact-amount, Deny-mode, post-conditioned, **sponsored** transfer\n * (origin-only, un-broadcast). The origin sets fee `0`; the facilitator's\n * sponsor fills in + pays the fee at settle time. The Deny-mode post-condition\n * asserts EXACTLY `amount` leaves `payer` to `payTo`, so settlement aborts\n * on-chain if anything differs — the \"exact amount\" x402 guarantee is enforced\n * by Clarity, not just by facilitator simulation.\n */\nexport function buildExactTransfer(\n\toptions: BuildExactTransferOptions,\n): StacksTransaction {\n\tconst { asset, amount, payTo, payer, payerPublicKey, accountNonce, chain } =\n\t\toptions;\n\n\tif (utf8ToBytes(options.nonce).byteLength > MEMO_MAX_LENGTH_BYTES) {\n\t\tthrow new Error(\n\t\t\t`x402 nonce exceeds the ${MEMO_MAX_LENGTH_BYTES}-byte memo budget`,\n\t\t);\n\t}\n\n\tif (asset.kind === \"stx\") {\n\t\t// A TokenTransfer payload CANNOT carry post-conditions (Stacks consensus\n\t\t// rejects it: \"TokenTransfer transactions do not support post-conditions\").\n\t\t// STX exactness is inherent — the amount + recipient are in the signed\n\t\t// payload, so there is nothing a post-condition would add.\n\t\treturn buildTokenTransfer({\n\t\t\trecipient: payTo,\n\t\t\tamount,\n\t\t\tmemo: options.nonce,\n\t\t\tfee: 0,\n\t\t\tnonce: accountNonce,\n\t\t\tpublicKey: payerPublicKey,\n\t\t\tchain,\n\t\t\tsponsored: true,\n\t\t});\n\t}\n\n\tconst [contractAddress, contractName] = parseContractId(asset.contractId);\n\tconst postConditions: PostCondition[] = [\n\t\tPc.principal(payer)\n\t\t\t.willSendEq(amount)\n\t\t\t.ft(asset.contractId, asset.assetName),\n\t];\n\t// SIP-010: (transfer (amount uint) (sender principal) (recipient principal) (memo (optional (buff 34))))\n\treturn buildContractCall({\n\t\tcontractAddress,\n\t\tcontractName,\n\t\tfunctionName: \"transfer\",\n\t\tfunctionArgs: [\n\t\t\tCl.uint(amount),\n\t\t\tCl.principal(payer),\n\t\t\tCl.principal(payTo),\n\t\t\tCl.some(Cl.bufferFromUtf8(options.nonce)),\n\t\t],\n\t\tfee: 0,\n\t\tnonce: accountNonce,\n\t\tpublicKey: payerPublicKey,\n\t\tchain,\n\t\tpostConditionMode: \"deny\",\n\t\tpostConditions,\n\t\tsponsored: true,\n\t});\n}\n",
+    "import { sendTransaction } from \"../actions/wallet/sendTransaction.ts\";\nimport { sponsorTransaction } from \"../actions/wallet/sponsorTransaction.ts\";\nimport type { Client } from \"../clients/types.ts\";\nimport { deserializeTransaction } from \"../transactions/wire/deserialize.ts\";\nimport type { IntegerType } from \"../utils/encoding.ts\";\n\nexport type SponsorAndBroadcastOptions = {\n\t/** Override the sponsor fee (µSTX). Defaults to a fee estimate. */\n\tfee?: IntegerType;\n\t/** Override the sponsor account nonce. Defaults to the on-chain nonce. */\n\tnonce?: IntegerType;\n};\n\nexport type SponsorAndBroadcastResult = {\n\ttxid: string;\n};\n\n/**\n * Take an origin-signed, sponsored transfer (hex) from the payer, sponsor-sign\n * it with `client`'s account (paying the STX fee), and broadcast it.\n *\n * The payer never holds STX: they sign origin-only with fee `0`; this fills in\n * the sponsor spending condition + fee and POSTs to `/v2/transactions`. The\n * sponsor cannot grief the payer — amount/recipient/asset are pinned by the\n * origin signature + Deny-mode post-conditions baked into the tx.\n *\n * @param client a wallet client whose `account` is the funded sponsor signer.\n * @param signedTxHex the payer's origin-signed sponsored tx, hex-serialized.\n */\nexport async function sponsorAndBroadcast(\n\tclient: Client,\n\tsignedTxHex: string,\n\toptions: SponsorAndBroadcastOptions = {},\n): Promise<SponsorAndBroadcastResult> {\n\tconst transaction = deserializeTransaction(signedTxHex);\n\tconst sponsored = await sponsorTransaction(client, {\n\t\ttransaction,\n\t\tfee: options.fee,\n\t\tnonce: options.nonce,\n\t});\n\treturn sendTransaction(client, { transaction: sponsored });\n}\n"
+  ],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDO,SAAS,kBAAkB,CACjC,SACoB;AAAA,EACpB,QAAQ,OAAO,QAAQ,OAAO,OAAO,gBAAgB,cAAc,UAClE;AAAA,EAED,IAAI,YAAY,QAAQ,KAAK,EAAE,aAAa,uBAAuB;AAAA,IAClE,MAAM,IAAI,MACT,0BAA0B,wCAC3B;AAAA,EACD;AAAA,EAEA,IAAI,MAAM,SAAS,OAAO;AAAA,IAKzB,OAAO,mBAAmB;AAAA,MACzB,WAAW;AAAA,MACX;AAAA,MACA,MAAM,QAAQ;AAAA,MACd,KAAK;AAAA,MACL,OAAO;AAAA,MACP,WAAW;AAAA,MACX;AAAA,MACA,WAAW;AAAA,IACZ,CAAC;AAAA,EACF;AAAA,EAEA,OAAO,iBAAiB,gBAAgB,gBAAgB,MAAM,UAAU;AAAA,EACxE,MAAM,iBAAkC;AAAA,IACvC,GAAG,UAAU,KAAK,EAChB,WAAW,MAAM,EACjB,GAAG,MAAM,YAAY,MAAM,SAAS;AAAA,EACvC;AAAA,EAEA,OAAO,kBAAkB;AAAA,IACxB;AAAA,IACA;AAAA,IACA,cAAc;AAAA,IACd,cAAc;AAAA,MACb,GAAG,KAAK,MAAM;AAAA,MACd,GAAG,UAAU,KAAK;AAAA,MAClB,GAAG,UAAU,KAAK;AAAA,MAClB,GAAG,KAAK,GAAG,eAAe,QAAQ,KAAK,CAAC;AAAA,IACzC;AAAA,IACA,KAAK;AAAA,IACL,OAAO;AAAA,IACP,WAAW;AAAA,IACX;AAAA,IACA,mBAAmB;AAAA,IACnB;AAAA,IACA,WAAW;AAAA,EACZ,CAAC;AAAA;;AC9EF,eAAsB,mBAAmB,CACxC,QACA,aACA,UAAsC,CAAC,GACF;AAAA,EACrC,MAAM,cAAc,uBAAuB,WAAW;AAAA,EACtD,MAAM,YAAY,MAAM,mBAAmB,QAAQ;AAAA,IAClD;AAAA,IACA,KAAK,QAAQ;AAAA,IACb,OAAO,QAAQ;AAAA,EAChB,CAAC;AAAA,EACD,OAAO,gBAAgB,QAAQ,EAAE,aAAa,UAAU,CAAC;AAAA;",
+  "debugId": "42F79D53766B4A5064756E2164756E21",
+  "names": []
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@secondlayer/stacks",
-	"version": "2.3.0",
+	"version": "2.5.0",
 	"license": "MIT",
 	"repository": {
 		"type": "git",
@@ -98,6 +98,11 @@
 			"types": "./dist/src/tools/btc/index.d.ts",
 			"import": "./dist/src/tools/btc/index.js",
 			"require": "./dist/src/tools/btc/index.cjs"
+		},
+		"./x402": {
+			"types": "./dist/src/x402/index.d.ts",
+			"import": "./dist/src/x402/index.js",
+			"require": "./dist/src/x402/index.cjs"
 		}
 	},
 	"files": [
@@ -113,6 +118,7 @@
 		"access": "public"
 	},
 	"devDependencies": {
+		"@stacks/transactions": "7.0.6",
 		"@types/bun": "latest"
 	},
 	"peerDependencies": {