@1sat/wallet-toolbox 0.0.8 → 0.0.10

package/dist/api/tokens/index.js

@@ -0,0 +1,457 @@
+/**
+ * Tokens Module
+ *
+ * Skills for managing BSV21 tokens.
+ */
+import { BigNumber, LockingScript, OP, P2PKH, PublicKey, Transaction, TransactionSignature, UnlockingScript, Utils, } from "@bsv/sdk";
+import { BSV21, OrdLock } from "@bopen-io/templates";
+import { BSV21_BASKET } from "../constants";
+// ============================================================================
+// Constants
+// ============================================================================
+const BSV21_PROTOCOL = [1, "bsv21"];
+// ============================================================================
+// Internal helpers
+// ============================================================================
+function buildSerializedOutput(satoshis, script) {
+    const writer = new Utils.Writer();
+    writer.writeUInt64LEBn(new BigNumber(satoshis));
+    writer.writeVarIntNum(script.length);
+    writer.write(script);
+    return writer.toArray();
+}
+async function buildPurchaseUnlockingScript(tx, inputIndex, sourceSatoshis, lockingScript) {
+    if (tx.outputs.length < 2) {
+        throw new Error("Malformed transaction: requires at least 2 outputs");
+    }
+    const script = new UnlockingScript().writeBin(buildSerializedOutput(tx.outputs[0].satoshis ?? 0, tx.outputs[0].lockingScript.toBinary()));
+    if (tx.outputs.length > 2) {
+        const writer = new Utils.Writer();
+        for (const output of tx.outputs.slice(2)) {
+            writer.write(buildSerializedOutput(output.satoshis ?? 0, output.lockingScript.toBinary()));
+        }
+        script.writeBin(writer.toArray());
+    }
+    else {
+        script.writeOpCode(OP.OP_0);
+    }
+    const input = tx.inputs[inputIndex];
+    const sourceTXID = input.sourceTXID ?? input.sourceTransaction?.id("hex");
+    if (!sourceTXID) {
+        throw new Error("sourceTXID is required");
+    }
+    const preimage = TransactionSignature.format({
+        sourceTXID,
+        sourceOutputIndex: input.sourceOutputIndex,
+        sourceSatoshis,
+        transactionVersion: tx.version,
+        otherInputs: [],
+        inputIndex,
+        outputs: tx.outputs,
+        inputSequence: input.sequence ?? 0xffffffff,
+        subscript: lockingScript,
+        lockTime: tx.lockTime,
+        scope: TransactionSignature.SIGHASH_ALL |
+            TransactionSignature.SIGHASH_ANYONECANPAY |
+            TransactionSignature.SIGHASH_FORKID,
+    });
+    return script.writeBin(preimage).writeOpCode(OP.OP_0);
+}
+async function listTokensInternal(ctx, limit = 10000) {
+    const result = await ctx.wallet.listOutputs({
+        basket: BSV21_BASKET,
+        includeTags: true,
+        limit,
+    });
+    return result.outputs;
+}
+/**
+ * List BSV21 token outputs from the wallet.
+ */
+export const listTokens = {
+    meta: {
+        name: "listTokens",
+        description: "List BSV21 token outputs from the wallet",
+        category: "tokens",
+        inputSchema: {
+            type: "object",
+            properties: {
+                limit: { type: "integer", description: "Max number of tokens to return (default: 10000)" },
+            },
+        },
+    },
+    async execute(ctx, input) {
+        return listTokensInternal(ctx, input.limit);
+    },
+};
+/**
+ * Get aggregated BSV21 token balances.
+ */
+export const getBsv21Balances = {
+    meta: {
+        name: "getBsv21Balances",
+        description: "Get aggregated BSV21 token balances grouped by token ID",
+        category: "tokens",
+        inputSchema: {
+            type: "object",
+            properties: {},
+        },
+    },
+    async execute(ctx) {
+        const outputs = await listTokensInternal(ctx);
+        const balanceMap = new Map();
+        for (const o of outputs) {
+            const idTag = o.tags?.find((t) => t.startsWith("id:"));
+            const amtTag = o.tags?.find((t) => t.startsWith("amt:"))?.slice(4);
+            if (!idTag || !amtTag)
+                continue;
+            const idContent = idTag.slice(3);
+            const lastColonIdx = idContent.lastIndexOf(":");
+            if (lastColonIdx === -1)
+                continue;
+            const tokenId = idContent.slice(0, lastColonIdx);
+            const status = idContent.slice(lastColonIdx + 1);
+            if (status === "invalid")
+                continue;
+            const isConfirmed = status === "valid";
+            const amt = BigInt(amtTag);
+            const dec = Number.parseInt(o.tags?.find((t) => t.startsWith("dec:"))?.slice(4) || "0", 10);
+            const symTag = o.tags?.find((t) => t.startsWith("sym:"))?.slice(4);
+            const iconTag = o.tags?.find((t) => t.startsWith("icon:"))?.slice(5);
+            const existing = balanceMap.get(tokenId);
+            if (existing) {
+                if (isConfirmed)
+                    existing.confirmed += amt;
+                else
+                    existing.pending += amt;
+            }
+            else {
+                balanceMap.set(tokenId, {
+                    id: tokenId,
+                    confirmed: isConfirmed ? amt : 0n,
+                    pending: isConfirmed ? 0n : amt,
+                    sym: symTag,
+                    icon: iconTag,
+                    dec,
+                });
+            }
+        }
+        return Array.from(balanceMap.values()).map((b) => ({
+            p: "bsv-20",
+            op: "transfer",
+            dec: b.dec,
+            amt: (b.confirmed + b.pending).toString(),
+            id: b.id,
+            sym: b.sym,
+            icon: b.icon,
+            all: { confirmed: b.confirmed, pending: b.pending },
+            listed: { confirmed: 0n, pending: 0n },
+        }));
+    },
+};
+/**
+ * Send BSV21 tokens to an address.
+ */
+export const sendBsv21 = {
+    meta: {
+        name: "sendBsv21",
+        description: "Send BSV21 tokens to a counterparty, address, or paymail",
+        category: "tokens",
+        inputSchema: {
+            type: "object",
+            properties: {
+                tokenId: { type: "string", description: "Token ID (txid_vout format)" },
+                amount: { type: "string", description: "Amount to send (as string for bigint)" },
+                counterparty: { type: "string", description: "Recipient identity public key (hex)" },
+                address: { type: "string", description: "Recipient P2PKH address" },
+                paymail: { type: "string", description: "Recipient paymail address" },
+            },
+            required: ["tokenId", "amount"],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            const { tokenId, counterparty, address, paymail, amount: rawAmount } = input;
+            const amount = typeof rawAmount === "string" ? BigInt(rawAmount) : rawAmount;
+            if (!counterparty && !address && !paymail) {
+                return { error: "must-provide-counterparty-address-or-paymail" };
+            }
+            if (amount <= 0n) {
+                return { error: "amount-must-be-positive" };
+            }
+            const parts = tokenId.split("_");
+            if (parts.length !== 2 || parts[0].length !== 64 || !/^\d+$/.test(parts[1])) {
+                return { error: "invalid-token-id-format" };
+            }
+            const result = await ctx.wallet.listOutputs({
+                basket: BSV21_BASKET,
+                includeTags: true,
+                include: "locking scripts",
+                limit: 10000,
+            });
+            const tokenUtxos = result.outputs.filter((o) => {
+                const idTag = o.tags?.find((t) => t.startsWith("id:"));
+                if (!idTag)
+                    return false;
+                const idContent = idTag.slice(3);
+                const lastColonIdx = idContent.lastIndexOf(":");
+                if (lastColonIdx === -1)
+                    return false;
+                const id = idContent.slice(0, lastColonIdx);
+                const status = idContent.slice(lastColonIdx + 1);
+                return id === tokenId && status !== "invalid";
+            });
+            if (tokenUtxos.length === 0) {
+                return { error: "no-token-utxos-found" };
+            }
+            const selected = [];
+            let totalIn = 0n;
+            for (const utxo of tokenUtxos) {
+                if (totalIn >= amount)
+                    break;
+                const amtTag = utxo.tags?.find((t) => t.startsWith("amt:"));
+                if (!amtTag)
+                    continue;
+                const utxoAmount = BigInt(amtTag.slice(4));
+                if (ctx.services?.bsv21) {
+                    try {
+                        const [txid] = utxo.outpoint.split("_");
+                        const validation = await ctx.services.bsv21.getTokenByTxid(tokenId, txid);
+                        const outputData = validation.outputs.find((o) => `${validation.txid}_${o.vout}` === utxo.outpoint);
+                        if (!outputData)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                selected.push(utxo);
+                totalIn += utxoAmount;
+            }
+            if (totalIn < amount) {
+                return { error: "insufficient-validated-tokens" };
+            }
+            let recipientAddress;
+            if (counterparty) {
+                const { publicKey } = await ctx.wallet.getPublicKey({
+                    protocolID: BSV21_PROTOCOL,
+                    keyID: `${tokenId}-${Date.now()}`,
+                    counterparty,
+                    forSelf: false,
+                });
+                recipientAddress = PublicKey.fromString(publicKey).toAddress();
+            }
+            else if (paymail) {
+                return { error: "paymail-not-yet-implemented" };
+            }
+            else {
+                recipientAddress = address;
+            }
+            const outputs = [];
+            const p2pkh = new P2PKH();
+            const destinationLockingScript = p2pkh.lock(recipientAddress);
+            const transferScript = BSV21.transfer(tokenId, amount).lock(destinationLockingScript);
+            outputs.push({
+                lockingScript: transferScript.toHex(),
+                satoshis: 1,
+                outputDescription: `Send ${amount} tokens`,
+            });
+            const change = totalIn - amount;
+            if (change > 0n) {
+                const changeKeyID = `${tokenId}-${Date.now()}`;
+                const { publicKey } = await ctx.wallet.getPublicKey({
+                    protocolID: BSV21_PROTOCOL,
+                    keyID: changeKeyID,
+                    counterparty: "self",
+                    forSelf: true,
+                });
+                const changeAddress = PublicKey.fromString(publicKey).toAddress();
+                const changeLockingScript = p2pkh.lock(changeAddress);
+                const changeScript = BSV21.transfer(tokenId, change).lock(changeLockingScript);
+                outputs.push({
+                    lockingScript: changeScript.toHex(),
+                    satoshis: 1,
+                    outputDescription: "Token change",
+                    basket: BSV21_BASKET,
+                    tags: [`id:${tokenId}`, `amt:${change}`],
+                    customInstructions: JSON.stringify({
+                        protocolID: BSV21_PROTOCOL,
+                        keyID: changeKeyID,
+                    }),
+                });
+            }
+            const symTag = tokenUtxos[0]?.tags?.find((t) => t.startsWith("sym:"));
+            const symbol = symTag ? symTag.slice(4) : tokenId.slice(0, 8);
+            const createResult = await ctx.wallet.createAction({
+                description: `Send ${amount} ${symbol}`,
+                inputs: selected.map((o) => ({
+                    outpoint: o.outpoint,
+                    inputDescription: "Token input",
+                })),
+                outputs,
+                options: { signAndProcess: false },
+            });
+            if ("error" in createResult && createResult.error) {
+                return { error: String(createResult.error) };
+            }
+            if (!createResult.signableTransaction) {
+                return { error: "no-signable-transaction" };
+            }
+            const signResult = await ctx.wallet.signAction({
+                reference: createResult.signableTransaction.reference,
+                spends: {},
+            });
+            if ("error" in signResult) {
+                return { error: String(signResult.error) };
+            }
+            return {
+                txid: signResult.txid,
+                rawtx: signResult.tx ? Utils.toHex(signResult.tx) : undefined,
+            };
+        }
+        catch (error) {
+            return { error: error instanceof Error ? error.message : "unknown-error" };
+        }
+    },
+};
+/**
+ * Purchase BSV21 tokens from marketplace.
+ */
+export const purchaseBsv21 = {
+    meta: {
+        name: "purchaseBsv21",
+        description: "Purchase BSV21 tokens from the marketplace",
+        category: "tokens",
+        requiresServices: true,
+        inputSchema: {
+            type: "object",
+            properties: {
+                tokenId: { type: "string", description: "Token ID (txid_vout format)" },
+                outpoint: { type: "string", description: "Outpoint of the listed token UTXO" },
+                amount: { type: "string", description: "Amount of tokens in the listing (as string)" },
+                marketplaceAddress: { type: "string", description: "Marketplace fee address" },
+                marketplaceRate: { type: "number", description: "Marketplace fee rate (0-1)" },
+            },
+            required: ["tokenId", "outpoint", "amount"],
+        },
+    },
+    async execute(ctx, input) {
+        try {
+            const { tokenId, outpoint, amount: rawAmount, marketplaceAddress, marketplaceRate } = input;
+            const tokenAmount = typeof rawAmount === "string" ? BigInt(rawAmount) : rawAmount;
+            if (!ctx.services) {
+                return { error: "services-required-for-purchase" };
+            }
+            const parts = outpoint.split("_");
+            if (parts.length !== 2) {
+                return { error: "invalid-outpoint-format" };
+            }
+            const [txid, voutStr] = parts;
+            const vout = Number.parseInt(voutStr, 10);
+            try {
+                await ctx.services.bsv21.getTokenByTxid(tokenId, txid);
+            }
+            catch {
+                return { error: "listing-not-found-in-overlay" };
+            }
+            const beef = await ctx.services.getBeefForTxid(txid);
+            const listingBeefTx = beef.findTxid(txid);
+            if (!listingBeefTx?.tx) {
+                return { error: "listing-transaction-not-found" };
+            }
+            const listingOutput = listingBeefTx.tx.outputs[vout];
+            if (!listingOutput) {
+                return { error: "listing-output-not-found" };
+            }
+            const ordLockData = OrdLock.decode(listingOutput.lockingScript);
+            if (!ordLockData) {
+                return { error: "not-an-ordlock-listing" };
+            }
+            const bsv21KeyID = `${tokenId}-${outpoint}`;
+            const { publicKey } = await ctx.wallet.getPublicKey({
+                protocolID: BSV21_PROTOCOL,
+                keyID: bsv21KeyID,
+                counterparty: "self",
+                forSelf: true,
+            });
+            const ourTokenAddress = PublicKey.fromString(publicKey).toAddress();
+            const outputs = [];
+            const p2pkh = new P2PKH();
+            const buyerLockingScript = p2pkh.lock(ourTokenAddress);
+            const transferScript = BSV21.transfer(tokenId, tokenAmount).lock(buyerLockingScript);
+            outputs.push({
+                lockingScript: transferScript.toHex(),
+                satoshis: 1,
+                outputDescription: "Purchased tokens",
+                basket: BSV21_BASKET,
+                tags: [`id:${tokenId}`, `amt:${tokenAmount}`],
+                customInstructions: JSON.stringify({
+                    protocolID: BSV21_PROTOCOL,
+                    keyID: bsv21KeyID,
+                }),
+            });
+            const payoutReader = new Utils.Reader(ordLockData.payout);
+            const payoutSatoshis = payoutReader.readUInt64LEBn().toNumber();
+            const payoutScriptLen = payoutReader.readVarIntNum();
+            const payoutScriptBin = payoutReader.read(payoutScriptLen);
+            const payoutLockingScript = LockingScript.fromBinary(payoutScriptBin);
+            outputs.push({
+                lockingScript: payoutLockingScript.toHex(),
+                satoshis: payoutSatoshis,
+                outputDescription: "Payment to seller",
+            });
+            if (marketplaceAddress && marketplaceRate && marketplaceRate > 0) {
+                const marketFee = Math.ceil(payoutSatoshis * marketplaceRate);
+                if (marketFee > 0) {
+                    outputs.push({
+                        lockingScript: p2pkh.lock(marketplaceAddress).toHex(),
+                        satoshis: marketFee,
+                        outputDescription: "Marketplace fee",
+                    });
+                }
+            }
+            const createResult = await ctx.wallet.createAction({
+                description: `Purchase ${tokenAmount} tokens for ${payoutSatoshis} sats`,
+                inputBEEF: beef.toBinary(),
+                inputs: [
+                    {
+                        outpoint,
+                        inputDescription: "Listed token",
+                        unlockingScriptLength: 500,
+                    },
+                ],
+                outputs,
+                options: { signAndProcess: false },
+            });
+            if ("error" in createResult && createResult.error) {
+                return { error: String(createResult.error) };
+            }
+            if (!createResult.signableTransaction) {
+                return { error: "no-signable-transaction" };
+            }
+            const tx = Transaction.fromBEEF(createResult.signableTransaction.tx);
+            const unlockingScript = await buildPurchaseUnlockingScript(tx, 0, listingOutput.satoshis ?? 1, listingOutput.lockingScript);
+            const signResult = await ctx.wallet.signAction({
+                reference: createResult.signableTransaction.reference,
+                spends: {
+                    0: { unlockingScript: unlockingScript.toHex() },
+                },
+            });
+            if ("error" in signResult) {
+                return { error: String(signResult.error) };
+            }
+            return {
+                txid: signResult.txid,
+                rawtx: signResult.tx ? Utils.toHex(signResult.tx) : undefined,
+            };
+        }
+        catch (error) {
+            return { error: error instanceof Error ? error.message : "unknown-error" };
+        }
+    },
+};
+// ============================================================================
+// Module exports
+// ============================================================================
+/** All token skills for registry */
+export const tokensSkills = [listTokens, getBsv21Balances, sendBsv21, purchaseBsv21];

package/dist/cwi/chrome.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CWI Chrome Transport - For extension popup/options pages
+ * Uses chrome.runtime.sendMessage directly to service worker
+ */
+import type { WalletInterface } from '@bsv/sdk';
+/**
+ * Create a CWI for extension context (popup, options page).
+ * Uses chrome.runtime.sendMessage directly to communicate with service worker.
+ */
+export declare const createChromeCWI: () => WalletInterface;
+export declare const ChromeCWI: WalletInterface;

package/dist/cwi/chrome.js

@@ -0,0 +1,39 @@
+/**
+ * CWI Chrome Transport - For extension popup/options pages
+ * Uses chrome.runtime.sendMessage directly to service worker
+ */
+import { createCWI } from './factory.js';
+/**
+ * chrome.runtime.sendMessage-based transport for extension context.
+ * Communicates directly with service worker without content script intermediary.
+ */
+const chromeTransport = (action, params) => {
+    return new Promise((resolve, reject) => {
+        // Use originator at message level (BRC-100 standard)
+        // Format as chrome-extension://<id> to match the admin originator in initWallet.ts
+        const originator = `chrome-extension://${chrome.runtime?.id}`;
+        console.log('[ChromeCWI] Sending message:', { action, originator, paramsType: typeof params });
+        chrome.runtime.sendMessage({ action, params, originator }, (response) => {
+            if (chrome.runtime.lastError) {
+                console.error('[ChromeCWI] Runtime error:', chrome.runtime.lastError.message);
+                reject(new Error(chrome.runtime.lastError.message));
+                return;
+            }
+            if (response.success) {
+                console.log('[ChromeCWI] Success:', action);
+                resolve(response.data);
+            }
+            else {
+                console.error('[ChromeCWI] Failed:', action, response.error);
+                reject(new Error(response.error || 'Unknown error'));
+            }
+        });
+    });
+};
+/**
+ * Create a CWI for extension context (popup, options page).
+ * Uses chrome.runtime.sendMessage directly to communicate with service worker.
+ */
+export const createChromeCWI = () => createCWI(chromeTransport);
+// Default instance for convenience
+export const ChromeCWI = createChromeCWI();

package/dist/cwi/event.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CWI Event Transport - For browser pages
+ * Uses CustomEvent pattern, forwarded by content script to service worker
+ */
+import type { WalletInterface } from '@bsv/sdk';
+/**
+ * Create a CWI for browser page context.
+ * Uses CustomEvent pattern - requires content script to forward to service worker.
+ */
+export declare const createEventCWI: () => WalletInterface;
+export declare const CWI: WalletInterface;

package/dist/cwi/event.js

@@ -0,0 +1,38 @@
+/**
+ * CWI Event Transport - For browser pages
+ * Uses CustomEvent pattern, forwarded by content script to service worker
+ */
+import { createCWI } from './factory.js';
+// Event name for requests (listened by content script)
+const YOURS_REQUEST = 'YoursRequest';
+/**
+ * CustomEvent-based transport for browser page context.
+ * Content script listens for these events and forwards to service worker.
+ */
+const eventTransport = (action, params) => {
+    return new Promise((resolve, reject) => {
+        const messageId = `${action}-${Date.now()}-${Math.random()}`;
+        const requestEvent = new CustomEvent(YOURS_REQUEST, {
+            detail: { messageId, type: action, params },
+        });
+        function onResponse(e) {
+            const responseEvent = e;
+            const { detail } = responseEvent;
+            if (detail.success) {
+                resolve(detail.data);
+            }
+            else {
+                reject(new Error(detail.error || 'Unknown error'));
+            }
+        }
+        self.addEventListener(messageId, onResponse, { once: true });
+        self.dispatchEvent(requestEvent);
+    });
+};
+/**
+ * Create a CWI for browser page context.
+ * Uses CustomEvent pattern - requires content script to forward to service worker.
+ */
+export const createEventCWI = () => createCWI(eventTransport);
+// Default instance for convenience
+export const CWI = createEventCWI();

package/dist/cwi/factory.d.ts

@@ -0,0 +1,14 @@
+/**
+ * CWI Factory - Creates WalletInterface implementations with pluggable transport
+ */
+import type { WalletInterface } from '@bsv/sdk';
+import { CWIEventName } from './types.js';
+/**
+ * Transport function signature - sends a message and returns response
+ */
+export type CWITransport = <TResult>(action: CWIEventName, params: unknown) => Promise<TResult>;
+/**
+ * Create a WalletInterface implementation using the provided transport.
+ * The transport handles the actual message passing (CustomEvent, chrome.runtime, etc.)
+ */
+export declare const createCWI: (transport: CWITransport) => WalletInterface;

package/dist/cwi/factory.js

@@ -0,0 +1,44 @@
+/**
+ * CWI Factory - Creates WalletInterface implementations with pluggable transport
+ */
+import { CWIEventName } from './types.js';
+/**
+ * Create a WalletInterface implementation using the provided transport.
+ * The transport handles the actual message passing (CustomEvent, chrome.runtime, etc.)
+ */
+export const createCWI = (transport) => ({
+    // Output Management
+    listOutputs: (args) => transport(CWIEventName.LIST_OUTPUTS, args),
+    relinquishOutput: (args) => transport(CWIEventName.RELINQUISH_OUTPUT, args),
+    // Action Management
+    createAction: (args) => transport(CWIEventName.CREATE_ACTION, args),
+    signAction: (args) => transport(CWIEventName.SIGN_ACTION, args),
+    abortAction: (args) => transport(CWIEventName.ABORT_ACTION, args),
+    listActions: (args) => transport(CWIEventName.LIST_ACTIONS, args),
+    internalizeAction: (args) => transport(CWIEventName.INTERNALIZE_ACTION, args),
+    // Key Operations
+    getPublicKey: (args) => transport(CWIEventName.GET_PUBLIC_KEY, args),
+    revealCounterpartyKeyLinkage: (args) => transport(CWIEventName.REVEAL_COUNTERPARTY_KEY_LINKAGE, args),
+    revealSpecificKeyLinkage: (args) => transport(CWIEventName.REVEAL_SPECIFIC_KEY_LINKAGE, args),
+    // Cryptographic Operations
+    encrypt: (args) => transport(CWIEventName.ENCRYPT, args),
+    decrypt: (args) => transport(CWIEventName.DECRYPT, args),
+    createHmac: (args) => transport(CWIEventName.CREATE_HMAC, args),
+    verifyHmac: (args) => transport(CWIEventName.VERIFY_HMAC, args),
+    createSignature: (args) => transport(CWIEventName.CREATE_SIGNATURE, args),
+    verifySignature: (args) => transport(CWIEventName.VERIFY_SIGNATURE, args),
+    // Certificate Operations
+    acquireCertificate: (args) => transport(CWIEventName.ACQUIRE_CERTIFICATE, args),
+    listCertificates: (args) => transport(CWIEventName.LIST_CERTIFICATES, args),
+    proveCertificate: (args) => transport(CWIEventName.PROVE_CERTIFICATE, args),
+    relinquishCertificate: (args) => transport(CWIEventName.RELINQUISH_CERTIFICATE, args),
+    discoverByIdentityKey: (args) => transport(CWIEventName.DISCOVER_BY_IDENTITY_KEY, args),
+    discoverByAttributes: (args) => transport(CWIEventName.DISCOVER_BY_ATTRIBUTES, args),
+    // Status & Info
+    isAuthenticated: (args) => transport(CWIEventName.IS_AUTHENTICATED, args),
+    waitForAuthentication: (args) => transport(CWIEventName.WAIT_FOR_AUTHENTICATION, args),
+    getHeight: (args) => transport(CWIEventName.GET_HEIGHT, args),
+    getHeaderForHeight: (args) => transport(CWIEventName.GET_HEADER_FOR_HEIGHT, args),
+    getNetwork: (args) => transport(CWIEventName.GET_NETWORK, args),
+    getVersion: (args) => transport(CWIEventName.GET_VERSION, args),
+});

package/dist/cwi/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * CWI (Chrome Wallet Interface) - BRC-100 WalletInterface implementations
+ *
+ * Two implementations for different contexts:
+ * - event.ts: For browser pages (uses CustomEvent, forwarded by content script)
+ * - chrome.ts: For extension popup/options (uses chrome.runtime.sendMessage directly)
+ */
+export { CWIEventName, type CWIResponseDetail } from './types.js';
+export { createCWI, type CWITransport } from './factory.js';
+export { createEventCWI, CWI as EventCWI } from './event.js';
+export { createChromeCWI, ChromeCWI } from './chrome.js';

package/dist/cwi/index.js

@@ -0,0 +1,11 @@
+/**
+ * CWI (Chrome Wallet Interface) - BRC-100 WalletInterface implementations
+ *
+ * Two implementations for different contexts:
+ * - event.ts: For browser pages (uses CustomEvent, forwarded by content script)
+ * - chrome.ts: For extension popup/options (uses chrome.runtime.sendMessage directly)
+ */
+export { CWIEventName } from './types.js';
+export { createCWI } from './factory.js';
+export { createEventCWI, CWI as EventCWI } from './event.js';
+export { createChromeCWI, ChromeCWI } from './chrome.js';