@bestinslot/wallet-kit 0.7.0 → 0.8.0

package/dist/types/api/brc20.d.ts

@@ -1,4 +1,6 @@
 import { BISWalletPurpose, PaymentOpts } from '../types/common';
+export type { Brc20AmountOptions, Brc20DeployOptions, Brc20PredeployOptions, Brc20PredeployResult, } from '../core/brc20-inscriptions';
+export { computeBrc20PredeployHash, deployBrc20Inscription, generateBrc20Salt, mintBrc20Inscription, predeployInscriptions, transferBrc20Inscription, } from '../core/brc20-inscriptions';
 /**
  * Interface representing the result of an inscription and send to OP_RETURN operation, including transaction IDs, signed transaction hexes, inscription ID, postage, and secret used in the minting process. This interface is used to encapsulate the details of the deploy, call and deposit operations in the BRC2.0 programmable module.
  *

package/dist/types/api/wallet.node.d.ts

@@ -1,4 +1,4 @@
 import { LocalWalletSource, LocalWalletType } from '../provider/local';
-export { createWallet, saveWallet as connectLocalWallet } from '../provider/local';
+export { createWallet, lockLocalWallet, saveWallet as connectLocalWallet } from '../provider/local';
 export * from './wallet';
 export type { LocalWalletSource, LocalWalletType };

package/dist/types/core/bis_swap.d.ts

@@ -502,6 +502,8 @@ export declare function getSwapResult(tokenInAddr: string, tokenOutAddr: string,
     amount_out: bigint;
     quoted_price: number;
     price_impact_bps: bigint;
+    reserve_in: bigint;
+    reserve_out: bigint;
     fees: SwapFees;
 }>;
 interface SwapOrderResponse {
@@ -533,6 +535,8 @@ export declare function getSwap2Result(tokenInAddr: string, tokenOutAddr: string
     amount_in: bigint;
     quoted_price: number;
     price_impact_bps: bigint;
+    reserve_in: bigint;
+    reserve_out: bigint;
     fees: SwapFees;
 }>;
 interface Swap2OrderResponse {

package/dist/types/core/brc20-inscriptions.d.ts

@@ -0,0 +1,122 @@
+import { InscriptionDetails } from '../types/inscription';
+/**
+ * Options shared by the deploy builders.
+ *
+ * @property tick - The BRC-20 ticker. 4 or 5 bytes for {@link deployBrc20Inscription}; 6 bytes for {@link predeployInscriptions}.
+ * @property max - Maximum supply, as a string (BRC-20 amounts are strings).
+ * @property lim - Optional per-mint limit, as a string.
+ * @property dec - Optional decimals, as a string or number (serialised as a string).
+ * @property selfMint - Optional override for the `self_mint` field. 5-byte tickers force `true`; 4-byte tickers default to omitting it unless set to `true`.
+ */
+export interface Brc20DeployOptions {
+    tick: string;
+    max: string;
+    lim?: string;
+    dec?: string | number;
+    selfMint?: boolean;
+}
+/**
+ * Options for {@link mintBrc20Inscription} and {@link transferBrc20Inscription}.
+ *
+ * @property tick - The BRC-20 ticker (4-6 bytes).
+ * @property amt - The amount, as a string (BRC-20 amounts are strings).
+ */
+export interface Brc20AmountOptions {
+    tick: string;
+    amt: string;
+}
+/**
+ * Options for {@link predeployInscriptions}.
+ *
+ * @property tick - The 6-byte namespaced ticker (must match /^[A-Za-z0-9-]{6}$/).
+ * @property address - The deployer's Bitcoin address. Its output script (pkscript) is derived on the current network and bound into the commitment hash, so this must be the address that will receive the deploy reveal.
+ * @property salt - Optional hex salt. Generated automatically when omitted.
+ * @property max - Maximum supply, as a string.
+ * @property lim - Optional per-mint limit, as a string.
+ * @property dec - Optional decimals, as a string or number.
+ */
+export interface Brc20PredeployOptions {
+    tick: string;
+    address: string;
+    salt?: string;
+    max: string;
+    lim?: string;
+    dec?: string | number;
+}
+/**
+ * Result of {@link predeployInscriptions}: the salt/hash used and both ready-to-inscribe payloads.
+ *
+ * @property salt - The hex salt used (echo of the input, or the auto-generated value). Keep it: the deploy reveal must reuse the same salt.
+ * @property hash - The `double_sha256(tick + salt + pkscript)` hex committed to by the predeploy.
+ * @property predeploy - The predeploy inscription (inscribe first).
+ * @property deploy - The matching deploy inscription (inscribe as a child of the predeploy after the required block delay).
+ */
+export interface Brc20PredeployResult {
+    salt: string;
+    hash: string;
+    predeploy: InscriptionDetails;
+    deploy: InscriptionDetails;
+}
+/**
+ * Build a BRC-20 `deploy` inscription for a 4- or 5-byte ticker.
+ *
+ * 4-byte tickers are free to mint (no `self_mint`); 5-byte tickers are
+ * self-issuance and always carry `self_mint: "true"`. For 6-byte namespaced
+ * tickers use {@link predeployInscriptions} instead.
+ *
+ * @param opts - See {@link Brc20DeployOptions}.
+ * @returns An {@link InscriptionDetails} ready to pass to `inscribe`.
+ * @throws If the ticker is not 4 or 5 bytes, if a 6-byte ticker is supplied, or if `self_mint` is disabled for a 5-byte ticker.
+ */
+export declare function deployBrc20Inscription(opts: Brc20DeployOptions): InscriptionDetails;
+/**
+ * Build a BRC-20 `mint` inscription.
+ *
+ * @param opts - See {@link Brc20AmountOptions}.
+ * @returns An {@link InscriptionDetails} ready to pass to `inscribe`.
+ * @throws If the ticker is not 4-6 bytes or the amount is not a non-empty string.
+ */
+export declare function mintBrc20Inscription(opts: Brc20AmountOptions): InscriptionDetails;
+/**
+ * Build a BRC-20 `transfer` inscription.
+ *
+ * @param opts - See {@link Brc20AmountOptions}.
+ * @returns An {@link InscriptionDetails} ready to pass to `inscribe`.
+ * @throws If the ticker is not 4-6 bytes or the amount is not a non-empty string.
+ */
+export declare function transferBrc20Inscription(opts: Brc20AmountOptions): InscriptionDetails;
+/**
+ * Generate a random hex salt for a 6-byte namespace predeploy.
+ *
+ * @param byteLength - Number of random bytes (default 16). The returned hex string is twice this length.
+ * @returns A lowercase hex string.
+ */
+export declare function generateBrc20Salt(byteLength?: number): string;
+/**
+ * Compute the predeploy commitment hash for a 6-byte namespace ticker.
+ *
+ * The preimage is `utf8(tick) ++ hexDecode(salt) ++ hexDecode(pkscript)`, and
+ * the hash is `sha256(sha256(preimage))`. The pkscript binds the commitment to
+ * the deployer, preventing cross-wallet replay.
+ *
+ * @param tick - The 6-byte namespaced ticker (must match /^[A-Za-z0-9-]{6}$/).
+ * @param salt - The salt, as a hex string.
+ * @param pkscript - The deployer's output script, as a hex string.
+ * @returns The commitment hash, as a lowercase hex string.
+ * @throws If the ticker is not a valid 6-byte namespaced ticker, or the salt/pkscript is not valid hex.
+ */
+export declare function computeBrc20PredeployHash(tick: string, salt: string, pkscript: string): string;
+/**
+ * Build the predeploy + deploy inscription pair for a 6-byte namespace ticker.
+ *
+ * Inscribe the returned `predeploy` first, wait the required number of blocks,
+ * then inscribe `deploy` as a child of the predeploy inscription (e.g. via
+ * `inscribeWithParent(result.deploy, predeployInscriptionId, …)`). The salt is
+ * generated automatically unless supplied, and is echoed back so the pair stays
+ * consistent.
+ *
+ * @param opts - See {@link Brc20PredeployOptions}.
+ * @returns The salt, commitment hash, and both {@link InscriptionDetails} payloads.
+ * @throws If the ticker is not a valid 6-byte namespaced ticker, the address is invalid, or the salt is not valid hex.
+ */
+export declare function predeployInscriptions(opts: Brc20PredeployOptions): Brc20PredeployResult;

package/dist/types/lib/uniswap_ops.d.ts

@@ -132,12 +132,16 @@ btcFee: bigint): Promise<{
     success: boolean;
     amounts: bigint[];
     price_impact_bps: bigint;
+    reserve_in: bigint;
+    reserve_out: bigint;
     error_message?: undefined;
 } | {
     success: boolean;
     error_message: any;
     amounts?: undefined;
     price_impact_bps?: undefined;
+    reserve_in?: undefined;
+    reserve_out?: undefined;
 }>;
 /**
  * Handles the swap request with specified output amount for BiS Swap. The swap2Request function takes various parameters including the user's public key, token addresses, maximum input amount, desired output amount, fees, and a BLS signature for authentication. It first checks the validity of the BLS signature to ensure that the request is authorized. Then, it verifies that the user has sufficient balance of the input token and that the maximum input amount is sufficient to receive the desired output amount based on the current reserves. If the signature is valid and the balance is sufficient, it calculates the actual input amount required to receive the desired output amount based on the current reserves and the swap formula. Finally, it updates the internal state of balances and reserves accordingly and returns a success response with the actual input amount used and price impact, or an error message if any step fails.
@@ -169,12 +173,16 @@ btcFee: bigint): Promise<{
     success: boolean;
     amounts: bigint[];
     price_impact_bps: bigint;
+    reserve_in: bigint;
+    reserve_out: bigint;
     error_message?: undefined;
 } | {
     success: boolean;
     error_message: any;
     amounts?: undefined;
     price_impact_bps?: undefined;
+    reserve_in?: undefined;
+    reserve_out?: undefined;
 }>;
 /**
  * Handles the withdraw request for BiS Swap. The withdrawRequest function takes various parameters including the user's public key, token address, target address, amount to withdraw, fees, and a BLS signature for authentication. It first checks the validity of the BLS signature to ensure that the request is authorized. Then, it verifies that the user has sufficient balance of the specified token to withdraw. If the signature is valid and the balance is sufficient, it updates the internal state of balances accordingly and returns a success response with the withdrawn amount, or an error message if any step fails.

package/dist/types/provider/local.d.ts

@@ -36,4 +36,18 @@ export declare function saveWallet(privKeyWIF: string, network: BISNetwork, wall
 export declare function createWallet(network: BISNetwork, walletType?: LocalWalletType, sourceWallet?: LocalWalletSource): Promise<BISWallet & {
     wif: string;
 }>;
+/**
+ * Locks the local (WIF) wallet by evicting all in-memory key material and
+ * clearing the connected session. After calling this, no private key remains
+ * resident in the process: `getSession()` returns `null`, and any subsequent
+ * sign/send call will fail until a wallet is reconnected via {@link saveWallet}
+ * (`connectLocalWallet`) or {@link createWallet}. (The exact error depends on the
+ * call path — e.g. a missing key or, if the network was also cleared, a network
+ * check — so callers should not rely on a specific error message.)
+ *
+ * This is intended for callers (e.g. an MCP server) that want to hold a key
+ * only for the duration of a single approved operation rather than keep it
+ * resident for the life of the process.
+ */
+export declare function lockLocalWallet(): void;
 export declare const LOCAL: BISProvider;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@bestinslot/wallet-kit",
   "type": "module",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": false,
   "description": "A lightweight JavaScript library for connecting Bitcoin wallets with a unified API.",
   "exports": {
@@ -120,6 +120,8 @@
     "lint": "eslint",
     "lint:fix": "prettier --write . && eslint --fix",
     "test": "vitest run",
+    "release": "node scripts/release.mjs",
+    "release:tag": "node scripts/release.mjs --tag",
     "verify:bundles": "node scripts/verify-build-flavours.mjs",
     "test:signet": "vitest run tests/signet/ --config vitest.signet.config.ts",
     "test:mainnet": "vitest run tests/mainnet/ --config vitest.mainnet.config.ts",