@secondlayer/stacks 2.0.1 → 2.1.1

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

@@ -0,0 +1,399 @@
+/** 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
+};
+/** 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
+		}
+	}
+};
+/** 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;
+/**
+* sBTC mainnet contract identifiers.
+*
+* The protocol uses three contracts:
+* - `sbtc-token` — SIP-010 fungible token with mint/burn/transfer SIP-005 events.
+* - `sbtc-deposit` — entry point for deposit completion calls (no print events).
+* - `sbtc-registry` — emits all protocol-state print events (deposits, withdrawals,
+*   signer-set rotations, governance).
+*
+* Verified against the deployed mainnet contracts via Hiro's
+* `/v2/contracts/source/...` endpoint.
+*/
+declare const SBTC_CONTRACTS: {
+	readonly mainnet: {
+		readonly address: "SM3VDXK3WZZSA84XXFKAFAF15NNZX32CTSG82JFQ4"
+		readonly token: "sbtc-token"
+		readonly deposit: "sbtc-deposit"
+		readonly registry: "sbtc-registry"
+	}
+	readonly testnet: {
+		readonly address: "SN3R84XZYA63QS28932XQF3G1J8R9PC3W76P9CSQS"
+		readonly token: "sbtc-token"
+		readonly deposit: "sbtc-deposit"
+		readonly registry: "sbtc-registry"
+	}
+};
+type SbtcNetwork = keyof typeof SBTC_CONTRACTS;
+/** Asset identifier for `sbtc-token` (mainnet). */
+declare const SBTC_ASSET_IDENTIFIER_MAINNET: string;
+/** Asset identifier for `sbtc-token` (testnet). */
+declare const SBTC_ASSET_IDENTIFIER_TESTNET: string;
+/** All print-event topic strings emitted by `sbtc-registry`. */
+declare const SBTC_EVENT_TOPICS: readonly ["completed-deposit", "withdrawal-create", "withdrawal-accept", "withdrawal-reject", "key-rotation", "update-protocol-contract"];
+type SbtcEventTopic = (typeof SBTC_EVENT_TOPICS)[number];
+/** Bitcoin address version bytes used in BTC recipient tuples. Same byte map as PoX. */
+declare const SBTC_BTC_ADDRESS_VERSION: {
+	readonly p2pkh: 0x00
+	readonly p2sh: 0x01
+	readonly p2sh_p2wpkh: 0x02
+	readonly p2sh_p2wsh: 0x03
+	readonly p2wpkh: 0x04
+	readonly p2wsh: 0x05
+	readonly p2tr: 0x06
+};
+/** Number of decimal places in the sBTC fungible token (matches BTC). */
+declare const SBTC_DECIMALS = 8;
+/** Smallest unit of sBTC, denominated in satoshis. */
+declare const SBTC_UNIT_NAME: "satoshis";
+/**
+* Resolve the qualified contract identifier for a given protocol contract.
+*
+* @example
+* sbtcContractId("mainnet", "registry")
+* // => "SM3VDXK3WZZSA84XXFKAFAF15NNZX32CTSG82JFQ4.sbtc-registry"
+*/
+declare function sbtcContractId(network: SbtcNetwork, contract: "token" | "deposit" | "registry"): string;
+/**
+* Bitcoin recipient address as encoded in `withdrawal-create` events.
+* `version` is a single byte mapping to {@link SBTC_BTC_ADDRESS_VERSION};
+* `hashbytes` is the 20- or 32-byte hash payload.
+*/
+type SbtcBtcRecipient = {
+	version: number
+	hashbytes: Uint8Array
+};
+/** `(print { topic: "completed-deposit", ... })` from `sbtc-registry`. */
+type CompletedDepositEvent = {
+	topic: "completed-deposit"
+	bitcoinTxid: Uint8Array
+	outputIndex: bigint
+	amount: bigint
+	burnHash: Uint8Array
+	burnHeight: bigint
+	sweepTxid: Uint8Array
+};
+/** `(print { topic: "withdrawal-create", ... })`. */
+type WithdrawalCreateEvent = {
+	topic: "withdrawal-create"
+	requestId: bigint
+	amount: bigint
+	sender: string
+	recipient: SbtcBtcRecipient
+	blockHeight: bigint
+	maxFee: bigint
+};
+/** `(print { topic: "withdrawal-accept", ... })`. */
+type WithdrawalAcceptEvent = {
+	topic: "withdrawal-accept"
+	requestId: bigint
+	bitcoinTxid: Uint8Array
+	signerBitmap: bigint
+	outputIndex: bigint
+	fee: bigint
+	burnHash: Uint8Array
+	burnHeight: bigint
+	sweepTxid: Uint8Array
+};
+/** `(print { topic: "withdrawal-reject", ... })`. */
+type WithdrawalRejectEvent = {
+	topic: "withdrawal-reject"
+	requestId: bigint
+	signerBitmap: bigint
+};
+/** `(print { topic: "key-rotation", ... })` — signer-set rotation. */
+type KeyRotationEvent = {
+	topic: "key-rotation"
+	newKeys: Uint8Array[]
+	newAddress: string
+	newAggregatePubkey: Uint8Array
+	newSignatureThreshold: bigint
+};
+/** `(print { topic: "update-protocol-contract", ... })` — governance hook. */
+type UpdateProtocolContractEvent = {
+	topic: "update-protocol-contract"
+	contractType: Uint8Array
+	newContract: string
+};
+/** Discriminated union of every protocol-state event from `sbtc-registry`. */
+type SbtcRegistryEvent = CompletedDepositEvent | WithdrawalCreateEvent | WithdrawalAcceptEvent | WithdrawalRejectEvent | KeyRotationEvent | UpdateProtocolContractEvent;
+type SbtcTokenTransferEvent = {
+	type: "transfer"
+	sender: string
+	recipient: string
+	amount: bigint
+	memo: Uint8Array | null
+};
+type SbtcTokenMintEvent = {
+	type: "mint"
+	recipient: string
+	amount: bigint
+};
+type SbtcTokenBurnEvent = {
+	type: "burn"
+	sender: string
+	amount: bigint
+};
+type SbtcTokenEvent = SbtcTokenTransferEvent | SbtcTokenMintEvent | SbtcTokenBurnEvent;
+/** Helper for narrowing on `topic`. */
+type SbtcEventByTopic<T extends SbtcEventTopic> = Extract<SbtcRegistryEvent, {
+	topic: T
+}>;
+/**
+* Format a `(buff 1) + (buff 32)` BTC recipient tuple into a canonical
+* mainnet Bitcoin address string.
+*
+* Used to decode the `recipient` field of `withdrawal-create` events
+* into a human-readable address. Mirrors the reverse direction of the
+* `parseBtcAddress` helper in `pox/utils.ts`.
+*/
+declare function formatBtcAddress(recipient: SbtcBtcRecipient): string;
+/**
+* Validate that a buffer is a 32-byte Bitcoin transaction id.
+* Throws if the buffer is the wrong length.
+*/
+declare function validateBitcoinTxid(buf: Uint8Array): void;
+/**
+* Hex-encode a Bitcoin txid for storage / display. Throws if the input is
+* not 32 bytes.
+*/
+declare function bitcoinTxidToHex(buf: Uint8Array): string;
+/**
+* Parse a hex string back into a 32-byte txid. Mirrors `bitcoinTxidToHex`.
+*/
+declare function bitcoinTxidFromHex(hex: string): Uint8Array;
+/**
+* Convert satoshis (BigInt) to a decimal-string sBTC amount.
+*
+* sBTC has 8 decimals (matching BTC). 100_000_000 sats = 1 sBTC.
+*/
+declare function satsToSbtc(sats: bigint): string;
+/**
+* Parse a decimal-string sBTC amount into satoshis. Inverse of
+* {@link satsToSbtc}.
+*/
+declare function sbtcToSats(amount: string): bigint;
+/**
+* Minimal read-only ABI for `sbtc-token`.
+*
+* Only covers the SIP-010 fungible-token getters needed for supply / balance
+* queries. Public mutating functions are intentionally omitted; the data plane
+* doesn't sign sBTC token transfers itself, and the dataset captures
+* mutation effects through SIP-005 token events on the indexer side.
+*/
+declare const SBTC_TOKEN_ABI: {
+	readonly functions: readonly [{
+		readonly name: "get-name"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: {
+					readonly "string-ascii": {
+						readonly length: 32
+					}
+				}
+				readonly error: "none"
+			}
+		}
+	}, {
+		readonly name: "get-symbol"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: {
+					readonly "string-ascii": {
+						readonly length: 10
+					}
+				}
+				readonly error: "none"
+			}
+		}
+	}, {
+		readonly name: "get-decimals"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "none"
+			}
+		}
+	}, {
+		readonly name: "get-total-supply"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "none"
+			}
+		}
+	}, {
+		readonly name: "get-balance"
+		readonly access: "read-only"
+		readonly args: readonly [{
+			readonly name: "owner"
+			readonly type: "principal"
+		}]
+		readonly outputs: {
+			readonly response: {
+				readonly ok: "uint128"
+				readonly error: "none"
+			}
+		}
+	}, {
+		readonly name: "get-token-uri"
+		readonly access: "read-only"
+		readonly args: readonly []
+		readonly outputs: {
+			readonly response: {
+				readonly ok: {
+					readonly optional: {
+						readonly "string-utf8": {
+							readonly length: 256
+						}
+					}
+				}
+				readonly error: "none"
+			}
+		}
+	}]
+};
+/** Actions provided by the sBTC extension. */
+type SbtcActions = {
+	sbtc: {
+		getTotalSupply: () => Promise<bigint>
+		getBalance: (owner: string) => Promise<bigint>
+		getName: () => Promise<string>
+		getSymbol: () => Promise<string>
+		getDecimals: () => Promise<bigint>
+		getTokenUri: () => Promise<string | null>
+	}
+};
+/**
+* sBTC extension for the Stacks client.
+*
+* @example
+* import { createWalletClient, http, mainnet } from "stacks";
+* import { sbtc } from "stacks/sbtc";
+*
+* const client = createWalletClient({
+*   chain: mainnet,
+*   transport: http(),
+* }).extend(sbtc());
+*
+* const supply = await client.sbtc.getTotalSupply();
+* const balance = await client.sbtc.getBalance("SP1...");
+*/
+declare function sbtc(): (client: Client) => SbtcActions;
+export { validateBitcoinTxid, sbtcToSats, sbtcContractId, sbtc, satsToSbtc, formatBtcAddress, bitcoinTxidToHex, bitcoinTxidFromHex, WithdrawalRejectEvent, WithdrawalCreateEvent, WithdrawalAcceptEvent, UpdateProtocolContractEvent, SbtcTokenTransferEvent, SbtcTokenMintEvent, SbtcTokenEvent, SbtcTokenBurnEvent, SbtcRegistryEvent, SbtcNetwork, SbtcEventTopic, SbtcEventByTopic, SbtcBtcRecipient, SbtcActions, SBTC_UNIT_NAME, SBTC_TOKEN_ABI, SBTC_EVENT_TOPICS, SBTC_DECIMALS, SBTC_CONTRACTS, SBTC_BTC_ADDRESS_VERSION, SBTC_ASSET_IDENTIFIER_TESTNET, SBTC_ASSET_IDENTIFIER_MAINNET, KeyRotationEvent, CompletedDepositEvent };

package/dist/src/sbtc/index.js

@@ -0,0 +1,286 @@
+import {
+  bech32,
+  bech32m
+} from "../../shared/stacks-9z833ww5.js";
+import {
+  getContract
+} from "../../shared/stacks-7tn3zsbe.js";
+import"../../shared/stacks-g7ys594x.js";
+import"../../shared/stacks-709tra19.js";
+import"../../shared/stacks-g7ffp8aj.js";
+import"../../shared/stacks-kmnthgj7.js";
+import"../../shared/stacks-0zysn74p.js";
+import"../../shared/stacks-v9jqcpd4.js";
+import"../../shared/stacks-xxn5ma6g.js";
+import"../../shared/stacks-6xmk24yw.js";
+import {
+  bytesToHex,
+  hexToBytes
+} from "../../shared/stacks-2h8d2y27.js";
+
+// src/sbtc/abi.ts
+var SBTC_TOKEN_ABI = {
+  functions: [
+    {
+      name: "get-name",
+      access: "read-only",
+      args: [],
+      outputs: {
+        response: { ok: { "string-ascii": { length: 32 } }, error: "none" }
+      }
+    },
+    {
+      name: "get-symbol",
+      access: "read-only",
+      args: [],
+      outputs: {
+        response: { ok: { "string-ascii": { length: 10 } }, error: "none" }
+      }
+    },
+    {
+      name: "get-decimals",
+      access: "read-only",
+      args: [],
+      outputs: { response: { ok: "uint128", error: "none" } }
+    },
+    {
+      name: "get-total-supply",
+      access: "read-only",
+      args: [],
+      outputs: { response: { ok: "uint128", error: "none" } }
+    },
+    {
+      name: "get-balance",
+      access: "read-only",
+      args: [{ name: "owner", type: "principal" }],
+      outputs: { response: { ok: "uint128", error: "none" } }
+    },
+    {
+      name: "get-token-uri",
+      access: "read-only",
+      args: [],
+      outputs: {
+        response: {
+          ok: { optional: { "string-utf8": { length: 256 } } },
+          error: "none"
+        }
+      }
+    }
+  ]
+};
+
+// src/sbtc/constants.ts
+var SBTC_CONTRACTS = {
+  mainnet: {
+    address: "SM3VDXK3WZZSA84XXFKAFAF15NNZX32CTSG82JFQ4",
+    token: "sbtc-token",
+    deposit: "sbtc-deposit",
+    registry: "sbtc-registry"
+  },
+  testnet: {
+    address: "SN3R84XZYA63QS28932XQF3G1J8R9PC3W76P9CSQS",
+    token: "sbtc-token",
+    deposit: "sbtc-deposit",
+    registry: "sbtc-registry"
+  }
+};
+var SBTC_ASSET_IDENTIFIER_MAINNET = `${SBTC_CONTRACTS.mainnet.address}.${SBTC_CONTRACTS.mainnet.token}::sbtc-token`;
+var SBTC_ASSET_IDENTIFIER_TESTNET = `${SBTC_CONTRACTS.testnet.address}.${SBTC_CONTRACTS.testnet.token}::sbtc-token`;
+var SBTC_EVENT_TOPICS = [
+  "completed-deposit",
+  "withdrawal-create",
+  "withdrawal-accept",
+  "withdrawal-reject",
+  "key-rotation",
+  "update-protocol-contract"
+];
+var SBTC_BTC_ADDRESS_VERSION = {
+  p2pkh: 0,
+  p2sh: 1,
+  p2sh_p2wpkh: 2,
+  p2sh_p2wsh: 3,
+  p2wpkh: 4,
+  p2wsh: 5,
+  p2tr: 6
+};
+var SBTC_DECIMALS = 8;
+var SBTC_UNIT_NAME = "satoshis";
+function sbtcContractId(network, contract) {
+  const cfg = SBTC_CONTRACTS[network];
+  return `${cfg.address}.${cfg[contract]}`;
+}
+
+// src/sbtc/actions.ts
+function getTokenContract(client) {
+  if (!client.chain) {
+    throw new Error("Client must have a chain configured");
+  }
+  const network = client.chain.network;
+  const contract = network === "mainnet" ? SBTC_CONTRACTS.mainnet : SBTC_CONTRACTS.testnet;
+  return getContract({
+    client,
+    address: contract.address,
+    name: contract.token,
+    abi: SBTC_TOKEN_ABI
+  });
+}
+async function getTotalSupply(client) {
+  const token = getTokenContract(client);
+  return await token.read.getTotalSupply({});
+}
+async function getBalance(client, owner) {
+  const token = getTokenContract(client);
+  return await token.read.getBalance({ owner });
+}
+async function getName(client) {
+  const token = getTokenContract(client);
+  return await token.read.getName({});
+}
+async function getSymbol(client) {
+  const token = getTokenContract(client);
+  return await token.read.getSymbol({});
+}
+async function getDecimals(client) {
+  const token = getTokenContract(client);
+  return await token.read.getDecimals({});
+}
+async function getTokenUri(client) {
+  const token = getTokenContract(client);
+  return await token.read.getTokenUri({});
+}
+// src/sbtc/utils.ts
+var BASE58_ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+function base58Encode(bytes) {
+  let num = 0n;
+  for (const byte of bytes)
+    num = num * 256n + BigInt(byte);
+  let str = "";
+  while (num > 0n) {
+    const r = num % 58n;
+    str = BASE58_ALPHABET[Number(r)] + str;
+    num /= 58n;
+  }
+  for (const byte of bytes) {
+    if (byte === 0)
+      str = `1${str}`;
+    else
+      break;
+  }
+  return str;
+}
+function sha256(bytes) {
+  const hasher = new Bun.CryptoHasher("sha256");
+  hasher.update(bytes);
+  return hasher.digest();
+}
+function doubleSha256(bytes) {
+  return sha256(sha256(bytes));
+}
+function base58CheckEncode(version, hashbytes) {
+  const payload = new Uint8Array(1 + hashbytes.length);
+  payload[0] = version;
+  payload.set(hashbytes, 1);
+  const checksum = doubleSha256(payload).slice(0, 4);
+  const full = new Uint8Array(payload.length + 4);
+  full.set(payload, 0);
+  full.set(checksum, payload.length);
+  return base58Encode(full);
+}
+function formatBtcAddress(recipient) {
+  const { version, hashbytes } = recipient;
+  switch (version) {
+    case SBTC_BTC_ADDRESS_VERSION.p2pkh:
+      return base58CheckEncode(0, hashbytes);
+    case SBTC_BTC_ADDRESS_VERSION.p2sh:
+    case SBTC_BTC_ADDRESS_VERSION.p2sh_p2wpkh:
+    case SBTC_BTC_ADDRESS_VERSION.p2sh_p2wsh:
+      return base58CheckEncode(5, hashbytes);
+    case SBTC_BTC_ADDRESS_VERSION.p2wpkh:
+    case SBTC_BTC_ADDRESS_VERSION.p2wsh: {
+      const words = bech32.toWords(hashbytes);
+      return bech32.encode("bc", [0, ...words]);
+    }
+    case SBTC_BTC_ADDRESS_VERSION.p2tr: {
+      const words = bech32m.toWords(hashbytes);
+      return bech32m.encode("bc", [1, ...words]);
+    }
+    default:
+      throw new Error(`Unknown BTC address version: ${version}`);
+  }
+}
+function validateBitcoinTxid(buf) {
+  if (buf.length !== 32) {
+    throw new Error(`Bitcoin txid must be 32 bytes, got ${buf.length}`);
+  }
+}
+function bitcoinTxidToHex(buf) {
+  validateBitcoinTxid(buf);
+  return bytesToHex(buf);
+}
+function bitcoinTxidFromHex(hex) {
+  const buf = hexToBytes(hex);
+  validateBitcoinTxid(buf);
+  return buf;
+}
+function satsToSbtc(sats) {
+  const sign = sats < 0n ? "-" : "";
+  const abs = sats < 0n ? -sats : sats;
+  const whole = abs / 100000000n;
+  const frac = abs % 100000000n;
+  if (frac === 0n)
+    return `${sign}${whole}`;
+  const fracStr = frac.toString().padStart(8, "0").replace(/0+$/, "");
+  return `${sign}${whole}.${fracStr}`;
+}
+function sbtcToSats(amount) {
+  const trimmed = amount.trim();
+  if (!/^-?\d+(?:\.\d+)?$/.test(trimmed)) {
+    throw new Error(`Invalid sBTC amount: ${amount}`);
+  }
+  const negative = trimmed.startsWith("-");
+  const body = negative ? trimmed.slice(1) : trimmed;
+  const dotIndex = body.indexOf(".");
+  const whole = dotIndex < 0 ? body : body.slice(0, dotIndex);
+  const frac = dotIndex < 0 ? "" : body.slice(dotIndex + 1);
+  if (frac.length > 8) {
+    throw new Error(`sBTC amount has more than 8 decimal places: ${amount}`);
+  }
+  const padded = frac.padEnd(8, "0");
+  const sats = BigInt(whole) * 100000000n + BigInt(padded);
+  return negative ? -sats : sats;
+}
+
+// src/sbtc/index.ts
+function sbtc() {
+  return (client) => ({
+    sbtc: {
+      getTotalSupply: () => getTotalSupply(client),
+      getBalance: (owner) => getBalance(client, owner),
+      getName: () => getName(client),
+      getSymbol: () => getSymbol(client),
+      getDecimals: () => getDecimals(client),
+      getTokenUri: () => getTokenUri(client)
+    }
+  });
+}
+export {
+  validateBitcoinTxid,
+  sbtcToSats,
+  sbtcContractId,
+  sbtc,
+  satsToSbtc,
+  formatBtcAddress,
+  bitcoinTxidToHex,
+  bitcoinTxidFromHex,
+  SBTC_UNIT_NAME,
+  SBTC_TOKEN_ABI,
+  SBTC_EVENT_TOPICS,
+  SBTC_DECIMALS,
+  SBTC_CONTRACTS,
+  SBTC_BTC_ADDRESS_VERSION,
+  SBTC_ASSET_IDENTIFIER_TESTNET,
+  SBTC_ASSET_IDENTIFIER_MAINNET
+};
+
+//# debugId=ABC665DEBE54FC7C64756E2164756E21
+//# sourceMappingURL=index.js.map