@sequence0/sdk 2.0.0 → 2.1.0

package/dist/chains/stacks.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Stacks (STX) Chain Adapter
+ *
+ * Builds Stacks SIP-005 token transfer transactions, attaches secp256k1 ECDSA
+ * signatures from the FROST threshold signing network, and broadcasts via
+ * Stacks node HTTP API.
+ *
+ * Uses @stacks/transactions if available, falls back to manual serialization
+ * using native fetch and Node.js crypto (no external deps required).
+ *
+ * Stacks uses secp256k1 (same curve as Bitcoin/Ethereum).
+ *
+ * Optional: npm install @stacks/transactions
+ */
+import { ChainAdapter, StacksTransaction } from '../core/types';
+export declare class StacksAdapter implements ChainAdapter {
+    private rpcUrl;
+    private network;
+    private stacksLib;
+    private useNativeLib;
+    constructor(network?: 'mainnet' | 'testnet', rpcUrl?: string);
+    getRpcUrl(): string;
+    /**
+     * Build an unsigned Stacks token transfer transaction (SIP-005).
+     *
+     * The returned hex string encodes a JSON payload containing:
+     * - signingHash: SHA-512/256 digest of the transaction with auth cleared
+     * - serializedTx: hex-encoded unsigned transaction bytes
+     * - nonce, fee, and other metadata needed for signature attachment
+     */
+    buildTransaction(tx: StacksTransaction, fromAddress: string): Promise<string>;
+    getSigningPayload(unsignedTx: string): string;
+    /**
+     * Attach a secp256k1 ECDSA signature to the Stacks transaction.
+     *
+     * Stacks requires a 65-byte recoverable signature in the auth spending condition:
+     * [recovery_id (1 byte)] [r (32 bytes)] [s (32 bytes)]
+     *
+     * The FROST signature is expected as 65 bytes: r (32) + s (32) + v (1),
+     * matching the EVM convention. We reorder to Stacks format.
+     */
+    attachSignature(unsignedTx: string, signature: string): Promise<string>;
+    /**
+     * Broadcast a signed Stacks transaction via /v2/transactions
+     */
+    broadcast(signedTx: string): Promise<string>;
+    /**
+     * Get STX balance in microSTX
+     */
+    getBalance(address: string): Promise<string>;
+    private buildWithLib;
+    private attachWithLib;
+    private buildManual;
+    private attachManual;
+    /**
+     * Serialize a standard single-sig authorization (P2PKH).
+     *
+     * Layout:
+     *   auth_type (1) + hash_mode (1) + signer_hash160 (20) + nonce (8) + fee (8)
+     *   + key_encoding (1) + signature (65, zeroed for unsigned)
+     */
+    private serializeAuth;
+    /**
+     * Serialize token transfer payload.
+     *
+     * Layout:
+     *   payload_type (1) + recipient_principal + amount (8) + memo_length_type (1) + memo (34)
+     */
+    private serializeTokenTransferPayload;
+    /**
+     * Serialize a Stacks principal address.
+     *
+     * Standard principal: type_id (1) + version (1) + hash160 (20)
+     * Contract principal: type_id (1) + version (1) + hash160 (20) + name_length (1) + name
+     */
+    private serializePrincipal;
+    /**
+     * Compute the sighash for a Stacks transaction.
+     *
+     * The sighash is SHA-512/256 of the serialized transaction with the
+     * auth signature field cleared (set to zeros). This is the digest
+     * that needs to be signed by the secp256k1 key.
+     *
+     * Per SIP-005, the initial sighash is computed over the transaction
+     * with auth cleared, then wrapped:
+     *   sighash = SHA-512/256(sighash_presign + auth_type + fee + nonce + key_encoding)
+     *
+     * For simplicity, we compute the presign sighash (SHA-512/256 of the
+     * unsigned serialized tx), which is what the auth spending condition signs.
+     */
+    private computeSighash;
+    /**
+     * Embed a recoverable signature into the serialized transaction.
+     *
+     * The auth section layout (starting after version + chain_id = offset 5):
+     *   auth_type (1) + hash_mode (1) + signer_hash160 (20) + nonce (8) + fee (8)
+     *   + key_encoding (1) + signature (65)
+     *
+     * Signature starts at offset 5 + 1 + 1 + 20 + 8 + 8 + 1 = offset 44.
+     * Stacks signature format: [recovery_id (1)] [r (32)] [s (32)] = 65 bytes.
+     */
+    private embedSignatureInSerialized;
+    /**
+     * Parse a 65-byte signature from FROST (r[32] + s[32] + v[1])
+     * into Stacks format (recovery_id, r, s).
+     */
+    private parseSignature;
+    private fetchNonce;
+    private estimateFee;
+}
+export declare function createStacksAdapter(rpcUrl?: string): StacksAdapter;
+export declare function createStacksTestnetAdapter(rpcUrl?: string): StacksAdapter;
+//# sourceMappingURL=stacks.d.ts.map

package/dist/chains/stacks.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stacks.d.ts","sourceRoot":"","sources":["../../src/chains/stacks.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,EAAE,YAAY,EAAE,iBAAiB,EAAE,MAAM,eAAe,CAAC;AA+BhE,qBAAa,aAAc,YAAW,YAAY;IAC9C,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,SAAS,CAAM;IACvB,OAAO,CAAC,YAAY,CAAU;gBAElB,OAAO,GAAE,SAAS,GAAG,SAAqB,EAAE,MAAM,CAAC,EAAE,MAAM;IAcvE,SAAS,IAAI,MAAM;IAInB;;;;;;;OAOG;IACG,gBAAgB,CAAC,EAAE,EAAE,iBAAiB,EAAE,WAAW,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA2BnF,iBAAiB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;IAS7C;;;;;;;;OAQG;IACG,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAiB7E;;OAEG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA4BlD;;OAEG;IACG,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;YAiBpC,YAAY;IAyD1B,OAAO,CAAC,aAAa;IAuBrB,OAAO,CAAC,WAAW;IAsDnB,OAAO,CAAC,YAAY;IAmBpB;;;;;;OAMG;IACH,OAAO,CAAC,aAAa;IAarB;;;;;OAKG;IACH,OAAO,CAAC,6BAA6B;IAsBrC;;;;;OAKG;IACH,OAAO,CAAC,kBAAkB;IA2B1B;;;;;;;;;;;;;OAaG;IACH,OAAO,CAAC,cAAc;IAOtB;;;;;;;;;OASG;IACH,OAAO,CAAC,0BAA0B;IAgBlC;;;OAGG;IACH,OAAO,CAAC,cAAc;YA2BR,UAAU;YASV,WAAW;CAc5B;AAsHD,wBAAgB,mBAAmB,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAElE;AAED,wBAAgB,0BAA0B,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,aAAa,CAEzE"}

package/dist/chains/stacks.js

@@ -0,0 +1,576 @@
+"use strict";
+/**
+ * Stacks (STX) Chain Adapter
+ *
+ * Builds Stacks SIP-005 token transfer transactions, attaches secp256k1 ECDSA
+ * signatures from the FROST threshold signing network, and broadcasts via
+ * Stacks node HTTP API.
+ *
+ * Uses @stacks/transactions if available, falls back to manual serialization
+ * using native fetch and Node.js crypto (no external deps required).
+ *
+ * Stacks uses secp256k1 (same curve as Bitcoin/Ethereum).
+ *
+ * Optional: npm install @stacks/transactions
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StacksAdapter = void 0;
+exports.createStacksAdapter = createStacksAdapter;
+exports.createStacksTestnetAdapter = createStacksTestnetAdapter;
+const errors_1 = require("../utils/errors");
+const crypto = __importStar(require("crypto"));
+const DEFAULT_RPCS = {
+    'mainnet': 'https://stacks-node-api.mainnet.stacks.co',
+    'testnet': 'https://stacks-node-api.testnet.stacks.co',
+};
+// Stacks transaction versions (SIP-005)
+const TX_VERSION_MAINNET = 0x00;
+const TX_VERSION_TESTNET = 0x80;
+// Network chain IDs
+const CHAIN_ID_MAINNET = 0x00000001;
+const CHAIN_ID_TESTNET = 0x80000000;
+// Auth types and flags
+const AUTH_TYPE_STANDARD = 0x04;
+const PUBKEY_ENCODING_COMPRESSED = 0x00;
+const SINGLE_SIG_SPENDING_CONDITION = 0x00; // hash mode: P2PKH
+// Payload type for token transfer
+const PAYLOAD_TYPE_TOKEN_TRANSFER = 0x00;
+// Post-condition mode: allow
+const POST_CONDITION_MODE_ALLOW = 0x01;
+// Anchor mode
+const ANCHOR_MODE_ANY = 0x03;
+class StacksAdapter {
+    constructor(network = 'mainnet', rpcUrl) {
+        this.network = network;
+        this.rpcUrl = rpcUrl || DEFAULT_RPCS[network];
+        this.useNativeLib = false;
+        try {
+            this.stacksLib = require('@stacks/transactions');
+            this.useNativeLib = true;
+        }
+        catch {
+            // Fall back to manual serialization
+            this.stacksLib = null;
+        }
+    }
+    getRpcUrl() {
+        return this.rpcUrl;
+    }
+    /**
+     * Build an unsigned Stacks token transfer transaction (SIP-005).
+     *
+     * The returned hex string encodes a JSON payload containing:
+     * - signingHash: SHA-512/256 digest of the transaction with auth cleared
+     * - serializedTx: hex-encoded unsigned transaction bytes
+     * - nonce, fee, and other metadata needed for signature attachment
+     */
+    async buildTransaction(tx, fromAddress) {
+        try {
+            // Fetch nonce if not provided
+            const nonce = tx.nonce !== undefined
+                ? tx.nonce
+                : await this.fetchNonce(fromAddress);
+            // Fetch fee estimate if not provided
+            const fee = tx.fee
+                ? BigInt(tx.fee)
+                : await this.estimateFee();
+            const amount = BigInt(tx.amount);
+            if (this.useNativeLib) {
+                return await this.buildWithLib(tx, fromAddress, nonce, fee, amount);
+            }
+            return this.buildManual(tx, fromAddress, nonce, fee, amount);
+        }
+        catch (e) {
+            if (e instanceof errors_1.ChainError)
+                throw e;
+            throw new errors_1.ChainError(`Failed to build Stacks transaction: ${e.message}`, 'stacks');
+        }
+    }
+    getSigningPayload(unsignedTx) {
+        try {
+            const payload = JSON.parse(Buffer.from(unsignedTx, 'hex').toString());
+            return payload.signingHash;
+        }
+        catch {
+            return unsignedTx;
+        }
+    }
+    /**
+     * Attach a secp256k1 ECDSA signature to the Stacks transaction.
+     *
+     * Stacks requires a 65-byte recoverable signature in the auth spending condition:
+     * [recovery_id (1 byte)] [r (32 bytes)] [s (32 bytes)]
+     *
+     * The FROST signature is expected as 65 bytes: r (32) + s (32) + v (1),
+     * matching the EVM convention. We reorder to Stacks format.
+     */
+    async attachSignature(unsignedTx, signature) {
+        try {
+            const payload = JSON.parse(Buffer.from(unsignedTx, 'hex').toString());
+            const sig = signature.startsWith('0x') ? signature.slice(2) : signature;
+            if (this.useNativeLib) {
+                return this.attachWithLib(payload, sig);
+            }
+            return this.attachManual(payload, sig);
+        }
+        catch (e) {
+            throw new errors_1.ChainError(`Failed to attach Stacks signature: ${e.message}`, 'stacks');
+        }
+    }
+    /**
+     * Broadcast a signed Stacks transaction via /v2/transactions
+     */
+    async broadcast(signedTx) {
+        try {
+            const payload = JSON.parse(Buffer.from(signedTx, 'hex').toString());
+            const txHex = payload.signedTx || payload.serializedTx;
+            const response = await fetch(`${this.rpcUrl}/v2/transactions`, {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/octet-stream' },
+                body: Buffer.from(txHex, 'hex'),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`Broadcast failed (${response.status}): ${errorText}`);
+            }
+            // The API returns the txid as a JSON string (quoted hex)
+            const txId = await response.text();
+            return txId.replace(/^"|"$/g, '');
+        }
+        catch (e) {
+            if (e instanceof errors_1.ChainError)
+                throw e;
+            throw new errors_1.ChainError(`Failed to broadcast Stacks tx: ${e.message}`, 'stacks');
+        }
+    }
+    /**
+     * Get STX balance in microSTX
+     */
+    async getBalance(address) {
+        try {
+            const response = await fetch(`${this.rpcUrl}/v2/accounts/${address}?proof=0`);
+            if (!response.ok)
+                return '0';
+            const data = await response.json();
+            // balance is returned as hex string prefixed with 0x
+            const balanceHex = data.balance;
+            return BigInt(balanceHex).toString();
+        }
+        catch {
+            return '0';
+        }
+    }
+    // ────────────────────────────────────────────────
+    // Private: @stacks/transactions library path
+    // ────────────────────────────────────────────────
+    async buildWithLib(tx, fromAddress, nonce, fee, amount) {
+        const { makeUnsignedSTXTokenTransfer, createStacksPrivateKey, serializeTransaction, TransactionVersion, AnchorMode, } = this.stacksLib;
+        // Build with a placeholder public key; we only need the structure
+        const txOptions = {
+            recipient: tx.to,
+            amount: amount,
+            fee: fee,
+            nonce: nonce,
+            anchorMode: AnchorMode?.Any ?? 3,
+            network: this.network,
+        };
+        if (tx.memo) {
+            txOptions.memo = tx.memo;
+        }
+        if (tx.senderPublicKey) {
+            txOptions.publicKey = tx.senderPublicKey;
+        }
+        const transaction = await makeUnsignedSTXTokenTransfer(txOptions);
+        // Serialize unsigned transaction
+        const serialized = Buffer.from(serializeTransaction
+            ? serializeTransaction(transaction)
+            : transaction.serialize());
+        // Compute sighash: the digest that needs signing
+        // For Stacks, this is SHA-512/256 of the transaction with cleared auth
+        const sighash = this.computeSighash(serialized);
+        const payload = {
+            signingHash: sighash,
+            serializedTx: serialized.toString('hex'),
+            nonce,
+            fee: fee.toString(),
+            useLib: true,
+        };
+        return Buffer.from(JSON.stringify(payload)).toString('hex');
+    }
+    attachWithLib(payload, sig) {
+        // Parse r, s, v from the FROST signature
+        const { recoveryId, r, s } = this.parseSignature(sig);
+        const serializedTx = Buffer.from(payload.serializedTx, 'hex');
+        // The auth field in a single-sig spending condition has a fixed layout.
+        // Find the signature slot and write recovery_id + r + s.
+        const signedTx = this.embedSignatureInSerialized(serializedTx, recoveryId, r, s);
+        const signedPayload = {
+            ...payload,
+            signedTx: signedTx.toString('hex'),
+            signature: sig,
+        };
+        return Buffer.from(JSON.stringify(signedPayload)).toString('hex');
+    }
+    // ────────────────────────────────────────────────
+    // Private: Manual serialization path (no deps)
+    // ────────────────────────────────────────────────
+    buildManual(tx, _fromAddress, nonce, fee, amount) {
+        const isMainnet = this.network === 'mainnet';
+        const txVersion = isMainnet ? TX_VERSION_MAINNET : TX_VERSION_TESTNET;
+        const chainId = isMainnet ? CHAIN_ID_MAINNET : CHAIN_ID_TESTNET;
+        // Sender public key (33 bytes compressed)
+        const senderPubKey = tx.senderPublicKey
+            ? Buffer.from(tx.senderPublicKey, 'hex')
+            : Buffer.alloc(33);
+        // Hash the public key for the spending condition (Hash160 = RIPEMD160(SHA256(pubkey)))
+        const pubkeyHash = hash160(senderPubKey);
+        // Build the authorization (standard single-sig, P2PKH)
+        const auth = this.serializeAuth(pubkeyHash, nonce, fee);
+        // Build the payload (token transfer)
+        const tokenPayload = this.serializeTokenTransferPayload(tx.to, amount, tx.memo);
+        // Assemble the full transaction:
+        // version (1) + chain_id (4) + auth + anchor_mode (1) + post_condition_mode (1)
+        // + post_conditions_length (4, 0) + payload
+        const parts = [
+            Buffer.from([txVersion]),
+            writeUint32BE(chainId),
+            auth,
+            Buffer.from([ANCHOR_MODE_ANY]),
+            Buffer.from([POST_CONDITION_MODE_ALLOW]),
+            writeUint32BE(0), // post-conditions: empty list (length 0)
+            tokenPayload,
+        ];
+        const serialized = Buffer.concat(parts);
+        // Compute sighash
+        const sighash = this.computeSighash(serialized);
+        const payload = {
+            signingHash: sighash,
+            serializedTx: serialized.toString('hex'),
+            nonce,
+            fee: fee.toString(),
+            useLib: false,
+        };
+        return Buffer.from(JSON.stringify(payload)).toString('hex');
+    }
+    attachManual(payload, sig) {
+        const { recoveryId, r, s } = this.parseSignature(sig);
+        const serializedTx = Buffer.from(payload.serializedTx, 'hex');
+        const signedTx = this.embedSignatureInSerialized(serializedTx, recoveryId, r, s);
+        const signedPayload = {
+            ...payload,
+            signedTx: signedTx.toString('hex'),
+            signature: sig,
+        };
+        return Buffer.from(JSON.stringify(signedPayload)).toString('hex');
+    }
+    // ────────────────────────────────────────────────
+    // Private: Serialization helpers
+    // ────────────────────────────────────────────────
+    /**
+     * Serialize a standard single-sig authorization (P2PKH).
+     *
+     * Layout:
+     *   auth_type (1) + hash_mode (1) + signer_hash160 (20) + nonce (8) + fee (8)
+     *   + key_encoding (1) + signature (65, zeroed for unsigned)
+     */
+    serializeAuth(signerHash160, nonce, fee) {
+        const parts = [
+            Buffer.from([AUTH_TYPE_STANDARD]),
+            Buffer.from([SINGLE_SIG_SPENDING_CONDITION]),
+            signerHash160,
+            writeUint64BE(BigInt(nonce)),
+            writeUint64BE(fee),
+            Buffer.from([PUBKEY_ENCODING_COMPRESSED]),
+            Buffer.alloc(65), // empty signature placeholder
+        ];
+        return Buffer.concat(parts);
+    }
+    /**
+     * Serialize token transfer payload.
+     *
+     * Layout:
+     *   payload_type (1) + recipient_principal + amount (8) + memo_length_type (1) + memo (34)
+     */
+    serializeTokenTransferPayload(recipient, amount, memo) {
+        const parts = [
+            Buffer.from([PAYLOAD_TYPE_TOKEN_TRANSFER]),
+            this.serializePrincipal(recipient),
+            writeUint64BE(amount),
+        ];
+        // Memo: always 34 bytes, padded with zeros
+        const memoBytes = Buffer.alloc(34);
+        if (memo) {
+            const encoded = Buffer.from(memo, 'utf-8');
+            encoded.copy(memoBytes, 0, 0, Math.min(encoded.length, 34));
+        }
+        parts.push(memoBytes);
+        return Buffer.concat(parts);
+    }
+    /**
+     * Serialize a Stacks principal address.
+     *
+     * Standard principal: type_id (1) + version (1) + hash160 (20)
+     * Contract principal: type_id (1) + version (1) + hash160 (20) + name_length (1) + name
+     */
+    serializePrincipal(address) {
+        // Check if this is a contract principal (contains '.')
+        const parts = address.split('.');
+        // Decode c32check address to get version + hash160
+        const { version, hash160: addrHash } = decodec32Address(parts[0]);
+        if (parts.length === 2) {
+            // Contract principal
+            const contractName = Buffer.from(parts[1], 'ascii');
+            return Buffer.concat([
+                Buffer.from([0x06]), // type: contract principal
+                Buffer.from([version]),
+                addrHash,
+                Buffer.from([contractName.length]),
+                contractName,
+            ]);
+        }
+        // Standard principal
+        return Buffer.concat([
+            Buffer.from([0x05]), // type: standard principal
+            Buffer.from([version]),
+            addrHash,
+        ]);
+    }
+    /**
+     * Compute the sighash for a Stacks transaction.
+     *
+     * The sighash is SHA-512/256 of the serialized transaction with the
+     * auth signature field cleared (set to zeros). This is the digest
+     * that needs to be signed by the secp256k1 key.
+     *
+     * Per SIP-005, the initial sighash is computed over the transaction
+     * with auth cleared, then wrapped:
+     *   sighash = SHA-512/256(sighash_presign + auth_type + fee + nonce + key_encoding)
+     *
+     * For simplicity, we compute the presign sighash (SHA-512/256 of the
+     * unsigned serialized tx), which is what the auth spending condition signs.
+     */
+    computeSighash(serialized) {
+        const hash = crypto.createHash('sha512-256')
+            .update(serialized)
+            .digest();
+        return hash.toString('hex');
+    }
+    /**
+     * Embed a recoverable signature into the serialized transaction.
+     *
+     * The auth section layout (starting after version + chain_id = offset 5):
+     *   auth_type (1) + hash_mode (1) + signer_hash160 (20) + nonce (8) + fee (8)
+     *   + key_encoding (1) + signature (65)
+     *
+     * Signature starts at offset 5 + 1 + 1 + 20 + 8 + 8 + 1 = offset 44.
+     * Stacks signature format: [recovery_id (1)] [r (32)] [s (32)] = 65 bytes.
+     */
+    embedSignatureInSerialized(serialized, recoveryId, r, s) {
+        const signed = Buffer.from(serialized);
+        const sigOffset = 5 + 1 + 1 + 20 + 8 + 8 + 1; // = 44
+        signed[sigOffset] = recoveryId;
+        r.copy(signed, sigOffset + 1);
+        s.copy(signed, sigOffset + 33);
+        return signed;
+    }
+    /**
+     * Parse a 65-byte signature from FROST (r[32] + s[32] + v[1])
+     * into Stacks format (recovery_id, r, s).
+     */
+    parseSignature(sig) {
+        const sigBuf = Buffer.from(sig, 'hex');
+        if (sigBuf.length === 65) {
+            // Format: r(32) + s(32) + v(1) — EVM convention from FROST
+            const r = sigBuf.subarray(0, 32);
+            const s = sigBuf.subarray(32, 64);
+            let v = sigBuf[64];
+            // Normalize v: Ethereum uses 27/28, Stacks uses 0/1
+            if (v >= 27)
+                v -= 27;
+            return { recoveryId: v, r, s };
+        }
+        else if (sigBuf.length === 64) {
+            // Compact format: r(32) + s(32), assume recovery ID 0
+            return {
+                recoveryId: 0,
+                r: sigBuf.subarray(0, 32),
+                s: sigBuf.subarray(32, 64),
+            };
+        }
+        throw new Error(`Unexpected signature length: ${sigBuf.length} bytes`);
+    }
+    // ────────────────────────────────────────────────
+    // Private: RPC helpers
+    // ────────────────────────────────────────────────
+    async fetchNonce(address) {
+        const response = await fetch(`${this.rpcUrl}/v2/accounts/${address}?proof=0`);
+        if (!response.ok) {
+            throw new Error(`Failed to fetch nonce: ${response.status}`);
+        }
+        const data = await response.json();
+        return data.nonce;
+    }
+    async estimateFee() {
+        try {
+            const response = await fetch(`${this.rpcUrl}/v2/fees/transfer`);
+            if (!response.ok) {
+                // Default fee: 200 microSTX
+                return BigInt(200);
+            }
+            const fee = await response.json();
+            // The endpoint returns a number (estimated fee in microSTX)
+            return BigInt(fee);
+        }
+        catch {
+            return BigInt(200);
+        }
+    }
+}
+exports.StacksAdapter = StacksAdapter;
+// ────────────────────────────────────────────────────
+// Standalone utility functions
+// ────────────────────────────────────────────────────
+/**
+ * Hash160 = RIPEMD-160(SHA-256(data))
+ */
+function hash160(data) {
+    const sha256 = crypto.createHash('sha256').update(data).digest();
+    return crypto.createHash('ripemd160').update(sha256).digest();
+}
+/**
+ * Write a 32-bit unsigned integer as big-endian.
+ */
+function writeUint32BE(value) {
+    const buf = Buffer.alloc(4);
+    buf.writeUInt32BE(value, 0);
+    return buf;
+}
+/**
+ * Write a 64-bit unsigned integer as big-endian.
+ */
+function writeUint64BE(value) {
+    const buf = Buffer.alloc(8);
+    buf.writeBigUInt64BE(value, 0);
+    return buf;
+}
+// ────────────────────────────────────────────────────
+// c32check address decoding (minimal, no external deps)
+// ────────────────────────────────────────────────────
+const C32_ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+/**
+ * Decode a Stacks c32check address (SP... or ST...) into version + hash160.
+ *
+ * c32check format: [version_char] [c32-encoded hash160] [4-byte checksum]
+ */
+function decodec32Address(address) {
+    // Strip the leading 'S' prefix
+    if (!address.startsWith('S')) {
+        throw new Error(`Invalid Stacks address: must start with S, got: ${address}`);
+    }
+    // The version character is the second character
+    const versionChar = address[1];
+    let version;
+    switch (versionChar) {
+        case 'P':
+            version = 22;
+            break; // mainnet single-sig (P2PKH)
+        case 'M':
+            version = 20;
+            break; // mainnet multi-sig
+        case 'T':
+            version = 26;
+            break; // testnet single-sig
+        case 'N':
+            version = 21;
+            break; // testnet multi-sig
+        default:
+            throw new Error(`Unknown Stacks address version: S${versionChar}`);
+    }
+    // The rest is c32-encoded: hash160 (20 bytes) + checksum (4 bytes)
+    const dataStr = address.slice(2).toUpperCase();
+    const decoded = c32decode(dataStr);
+    // Last 4 bytes are checksum, first 20 are the hash160
+    if (decoded.length < 20) {
+        throw new Error(`Invalid Stacks address: decoded data too short`);
+    }
+    const hash = decoded.subarray(0, 20);
+    return { version, hash160: hash };
+}
+/**
+ * Decode a c32-encoded string into bytes.
+ *
+ * c32 is a base-32 encoding using the alphabet: 0123456789ABCDEFGHJKMNPQRSTVWXYZ
+ * (no I, L, O, U to avoid confusion).
+ */
+function c32decode(input) {
+    if (input.length === 0)
+        return Buffer.alloc(0);
+    // Convert c32 characters to 5-bit values
+    const values = [];
+    for (const ch of input) {
+        const idx = C32_ALPHABET.indexOf(ch);
+        if (idx === -1) {
+            throw new Error(`Invalid c32 character: ${ch}`);
+        }
+        values.push(idx);
+    }
+    // Convert from base-32 to bytes using BigInt arithmetic
+    let num = BigInt(0);
+    for (const v of values) {
+        num = num * BigInt(32) + BigInt(v);
+    }
+    // Convert BigInt to byte array
+    const hexStr = num.toString(16);
+    const padded = hexStr.length % 2 === 0 ? hexStr : '0' + hexStr;
+    const bytes = Buffer.from(padded, 'hex');
+    // The result should be 24 bytes (20 hash + 4 checksum) for addresses
+    // Pad with leading zeros if needed
+    const expectedLen = 24;
+    if (bytes.length < expectedLen) {
+        return Buffer.concat([Buffer.alloc(expectedLen - bytes.length), bytes]);
+    }
+    return bytes;
+}
+// ────────────────────────────────────────────────────
+// Factory functions
+// ────────────────────────────────────────────────────
+function createStacksAdapter(rpcUrl) {
+    return new StacksAdapter('mainnet', rpcUrl);
+}
+function createStacksTestnetAdapter(rpcUrl) {
+    return new StacksAdapter('testnet', rpcUrl);
+}
+//# sourceMappingURL=stacks.js.map