@1sat/wallet-toolbox 0.0.8 → 0.0.9

package/dist/api/ordinals/index.js

@@ -0,0 +1,446 @@
+/**
+ * Ordinals Module
+ *
+ * Functions for managing ordinals/inscriptions.
+ * Returns WalletOutput[] directly from the SDK - no custom mapping needed.
+ */
+import { BigNumber, Hash, LockingScript, OP, P2PKH, PublicKey, Script, Transaction, TransactionSignature, UnlockingScript, Utils, } from "@bsv/sdk";
+import { OrdLock } from "@bopen-io/templates";
+import { ORDINALS_BASKET, ORDLOCK_PREFIX, ORDLOCK_SUFFIX } from "../constants";
+// Protocol for ordinal listing key derivation (security level 1 = low, self-only)
+const ORDINAL_LISTING_PROTOCOL = [1, "ordinal listing"];
+/**
+ * Check if address is a paymail.
+ */
+function isPaymail(address) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(address);
+}
+/**
+ * Derive a cancel address for an ordinal listing.
+ * Uses the outpoint as keyID with security level 1 (self-only).
+ */
+export async function deriveCancelAddress(cwi, outpoint) {
+    const result = await cwi.getPublicKey({
+        protocolID: ORDINAL_LISTING_PROTOCOL,
+        keyID: outpoint,
+        forSelf: true,
+    });
+    const publicKey = PublicKey.fromString(result.publicKey);
+    return publicKey.toAddress();
+}
+/**
+ * Build OrdLock script for listing an ordinal.
+ */
+function buildOrdLockScript(ordAddress, payAddress, price) {
+    const cancelPkh = Utils.fromBase58Check(ordAddress).data;
+    const payPkh = Utils.fromBase58Check(payAddress).data;
+    const payoutScript = new P2PKH().lock(payPkh).toBinary();
+    const writer = new Utils.Writer();
+    writer.writeUInt64LEBn(new BigNumber(price));
+    writer.writeVarIntNum(payoutScript.length);
+    writer.write(payoutScript);
+    const payoutOutput = writer.toArray();
+    return new Script()
+        .writeScript(Script.fromHex(ORDLOCK_PREFIX))
+        .writeBin(cancelPkh)
+        .writeBin(payoutOutput)
+        .writeScript(Script.fromHex(ORDLOCK_SUFFIX));
+}
+/**
+ * List ordinals from the 1sat basket.
+ * Returns WalletOutput[] directly - use tags for metadata (origin:, type:, name:, own:, list:).
+ */
+export async function listOrdinals(cwi, options = {}) {
+    const result = await cwi.listOutputs({
+        basket: ORDINALS_BASKET,
+        includeTags: true,
+        includeCustomInstructions: true,
+        limit: options.limit ?? 100,
+        offset: options.offset ?? 0,
+        ...options,
+    });
+    return result.outputs;
+}
+/**
+ * Build CreateActionArgs for transferring an ordinal.
+ * Does NOT execute - returns params for createAction.
+ */
+export async function buildTransferOrdinal(cwi, request) {
+    const { outpoint, destination } = request;
+    if (isPaymail(destination)) {
+        return { error: "paymail-not-yet-implemented" };
+    }
+    const result = await cwi.listOutputs({
+        basket: ORDINALS_BASKET,
+        include: "locking scripts",
+        limit: 10000,
+    });
+    if (!result.outputs.find((o) => o.outpoint === outpoint)) {
+        return { error: "ordinal-not-found" };
+    }
+    return {
+        description: "Transfer ordinal",
+        inputs: [{ outpoint, inputDescription: "Ordinal to transfer" }],
+        outputs: [{
+                lockingScript: new P2PKH().lock(destination).toHex(),
+                satoshis: 1,
+                outputDescription: "Ordinal transfer",
+            }],
+    };
+}
+/**
+ * Build CreateActionArgs for listing an ordinal for sale.
+ * Does NOT execute - returns params for createAction.
+ * If cancelAddress is not provided, it will be derived from the CWI.
+ */
+export async function buildListOrdinal(cwi, request) {
+    const { outpoint, price, payAddress } = request;
+    if (!payAddress)
+        return { error: "missing-pay-address" };
+    if (price <= 0)
+        return { error: "invalid-price" };
+    const result = await cwi.listOutputs({
+        basket: ORDINALS_BASKET,
+        include: "locking scripts",
+        limit: 10000,
+    });
+    if (!result.outputs.find((o) => o.outpoint === outpoint)) {
+        return { error: "ordinal-not-found" };
+    }
+    // Derive cancel address if not provided
+    const cancelAddress = request.cancelAddress ?? await deriveCancelAddress(cwi, outpoint);
+    const lockingScript = buildOrdLockScript(cancelAddress, payAddress, price);
+    return {
+        description: `List ordinal for ${price} sats`,
+        inputs: [{ outpoint, inputDescription: "Ordinal to list" }],
+        outputs: [{
+                lockingScript: lockingScript.toHex(),
+                satoshis: 1,
+                outputDescription: `List ordinal for ${price} sats`,
+                basket: ORDINALS_BASKET,
+                tags: [`origin:${outpoint}`, `price:${price}`],
+            }],
+    };
+}
+/**
+ * Transfer an ordinal to a new address.
+ */
+export async function transferOrdinal(cwi, request) {
+    try {
+        const params = await buildTransferOrdinal(cwi, request);
+        if ("error" in params) {
+            return params;
+        }
+        const result = await cwi.createAction(params);
+        if (!result.txid) {
+            return { error: "no-txid-returned" };
+        }
+        return { txid: result.txid, rawtx: result.tx ? Utils.toHex(result.tx) : undefined };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : "unknown-error" };
+    }
+}
+/**
+ * List an ordinal for sale on the global orderbook.
+ */
+export async function listOrdinal(cwi, request) {
+    try {
+        const params = await buildListOrdinal(cwi, request);
+        if ("error" in params) {
+            return params;
+        }
+        const result = await cwi.createAction(params);
+        if (!result.txid) {
+            return { error: "no-txid-returned" };
+        }
+        return { txid: result.txid, rawtx: result.tx ? Utils.toHex(result.tx) : undefined };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : "unknown-error" };
+    }
+}
+/**
+ * Cancel an ordinal listing.
+ * Uses the origin tag to recover the keyID for signing.
+ * Cancel unlock script: <sig> <pubkey> OP_1
+ */
+export async function cancelListing(cwi, outpoint) {
+    try {
+        // Find the listing in our wallet
+        const result = await cwi.listOutputs({
+            basket: ORDINALS_BASKET,
+            includeTags: true,
+            include: "locking scripts",
+            limit: 10000,
+        });
+        const listing = result.outputs.find((o) => o.outpoint === outpoint);
+        if (!listing) {
+            return { error: "listing-not-found" };
+        }
+        // Get the origin tag to recover the keyID
+        const originTag = listing.tags?.find((t) => t.startsWith("origin:"));
+        if (!originTag) {
+            return { error: "missing-origin-tag" };
+        }
+        const originOutpoint = originTag.slice(7); // Remove "origin:" prefix
+        // Derive the cancel address to get output destination
+        const cancelAddress = await deriveCancelAddress(cwi, originOutpoint);
+        // Create transaction with signAndProcess: false
+        const createResult = await cwi.createAction({
+            description: "Cancel ordinal listing",
+            inputs: [{
+                    outpoint,
+                    inputDescription: "Listed ordinal",
+                    unlockingScriptLength: 108, // sig (73) + pubkey (34) + OP_1 (1)
+                }],
+            outputs: [{
+                    lockingScript: new P2PKH().lock(cancelAddress).toHex(),
+                    satoshis: 1,
+                    outputDescription: "Cancelled listing",
+                    basket: ORDINALS_BASKET,
+                }],
+            options: { signAndProcess: false },
+        });
+        if ("error" in createResult && createResult.error) {
+            return { error: String(createResult.error) };
+        }
+        if (!createResult.signableTransaction) {
+            return { error: "no-signable-transaction" };
+        }
+        // Parse transaction for signing
+        const tx = Transaction.fromBEEF(createResult.signableTransaction.tx);
+        const input = tx.inputs[0];
+        const lockingScript = Script.fromHex(listing.lockingScript);
+        // Build preimage for signature
+        const sourceTXID = input.sourceTXID ?? input.sourceTransaction?.id("hex");
+        if (!sourceTXID) {
+            return { error: "missing-source-txid" };
+        }
+        const preimage = TransactionSignature.format({
+            sourceTXID,
+            sourceOutputIndex: input.sourceOutputIndex,
+            sourceSatoshis: listing.satoshis,
+            transactionVersion: tx.version,
+            otherInputs: [],
+            inputIndex: 0,
+            outputs: tx.outputs,
+            inputSequence: input.sequence ?? 0xffffffff,
+            subscript: lockingScript,
+            lockTime: tx.lockTime,
+            scope: TransactionSignature.SIGHASH_ALL |
+                TransactionSignature.SIGHASH_ANYONECANPAY |
+                TransactionSignature.SIGHASH_FORKID,
+        });
+        // Hash preimage for signing
+        const sighash = Hash.sha256(Hash.sha256(preimage));
+        // Get signature via createSignature using origin outpoint as keyID
+        const { signature } = await cwi.createSignature({
+            protocolID: ORDINAL_LISTING_PROTOCOL,
+            keyID: originOutpoint,
+            counterparty: "self",
+            hashToDirectlySign: Array.from(sighash),
+        });
+        // Get public key
+        const { publicKey } = await cwi.getPublicKey({
+            protocolID: ORDINAL_LISTING_PROTOCOL,
+            keyID: originOutpoint,
+            forSelf: true,
+        });
+        // Build cancel unlocking script: <sig> <pubkey> OP_1
+        const unlockingScript = new UnlockingScript()
+            .writeBin(signature)
+            .writeBin(Utils.toArray(publicKey, "hex"))
+            .writeOpCode(OP.OP_1);
+        // Sign and broadcast
+        const signResult = await cwi.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" };
+    }
+}
+/**
+ * Build serialized transaction output (satoshis + script) for OrdLock unlock.
+ */
+function buildSerializedOutput(satoshis, script) {
+    const writer = new Utils.Writer();
+    writer.writeUInt64LEBn(new BigNumber(satoshis));
+    writer.writeVarIntNum(script.length);
+    writer.write(script);
+    return writer.toArray();
+}
+/**
+ * Build OrdLock purchase unlocking script.
+ * The purchase path requires no signature - just preimage and output data.
+ */
+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);
+}
+/**
+ * Purchase an ordinal from the global orderbook.
+ *
+ * Flow:
+ * 1. Fetch listing BEEF to get the locking script
+ * 2. Decode OrdLock to get price and payout
+ * 3. Build P2PKH output for buyer
+ * 4. Build payment output for seller
+ * 5. Build custom OrdLock purchase unlock (preimage only, no signature)
+ */
+export async function purchaseOrdinal(cwi, request, services) {
+    try {
+        const { outpoint, marketplaceAddress, marketplaceRate } = request;
+        if (!services) {
+            return { error: "services-required-for-purchase" };
+        }
+        // Parse outpoint
+        const parts = outpoint.split("_");
+        if (parts.length !== 2) {
+            return { error: "invalid-outpoint-format" };
+        }
+        const [txid, voutStr] = parts;
+        const vout = parseInt(voutStr, 10);
+        // Fetch listing BEEF to get the locking script
+        const beef = await 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" };
+        }
+        // Decode OrdLock from listing script
+        const ordLockData = OrdLock.decode(listingOutput.lockingScript);
+        if (!ordLockData) {
+            return { error: "not-an-ordlock-listing" };
+        }
+        // Derive our ordinal receive address
+        const { publicKey } = await cwi.getPublicKey({
+            protocolID: [1, "ordinals"],
+            keyID: outpoint,
+            counterparty: "self",
+            forSelf: true,
+        });
+        const ourOrdAddress = PublicKey.fromString(publicKey).toAddress();
+        // Build outputs
+        const outputs = [];
+        // Output 0: Ordinal to buyer (P2PKH)
+        const p2pkh = new P2PKH();
+        outputs.push({
+            lockingScript: p2pkh.lock(ourOrdAddress).toHex(),
+            satoshis: 1,
+            outputDescription: "Purchased ordinal",
+            basket: ORDINALS_BASKET,
+        });
+        // Output 1: Payment to seller (from payout in OrdLock)
+        // Parse payout: 8-byte LE satoshis + varint script length + script
+        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",
+        });
+        // Output 2+ (optional): Marketplace fee
+        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",
+                });
+            }
+        }
+        // Create the transaction with signAndProcess: false
+        // The listing input needs custom unlocking script
+        const createResult = await cwi.createAction({
+            description: `Purchase ordinal for ${payoutSatoshis} sats`,
+            inputBEEF: beef.toBinary(),
+            inputs: [{
+                    outpoint,
+                    inputDescription: "Listed ordinal",
+                    unlockingScriptLength: 500, // Estimate for purchase unlock (preimage + outputs)
+                }],
+            outputs,
+            options: { signAndProcess: false },
+        });
+        if ("error" in createResult && createResult.error) {
+            return { error: String(createResult.error) };
+        }
+        if (!createResult.signableTransaction) {
+            return { error: "no-signable-transaction" };
+        }
+        // Parse the transaction to build purchase unlock
+        const tx = Transaction.fromBEEF(createResult.signableTransaction.tx);
+        // Build purchase unlocking script
+        const unlockingScript = await buildPurchaseUnlockingScript(tx, 0, listingOutput.satoshis ?? 1, listingOutput.lockingScript);
+        // Sign and broadcast
+        const signResult = await cwi.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" };
+    }
+}

package/dist/api/payments/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Payments Module
+ *
+ * Functions for sending BSV payments.
+ */
+import { type WalletInterface } from "@bsv/sdk";
+export interface SendBsvRequest {
+    /** Destination address (P2PKH) */
+    address?: string;
+    /** Destination paymail */
+    paymail?: string;
+    /** Amount in satoshis */
+    satoshis: number;
+    /** Custom locking script (hex) */
+    script?: string;
+    /** OP_RETURN data */
+    data?: string[];
+    /** Inscription data */
+    inscription?: {
+        base64Data: string;
+        mimeType: string;
+        map?: Record<string, string>;
+    };
+}
+export interface SendBsvResponse {
+    txid?: string;
+    rawtx?: string;
+    error?: string;
+}
+/**
+ * Send BSV to one or more destinations.
+ */
+export declare function sendBsv(cwi: WalletInterface, requests: SendBsvRequest[]): Promise<SendBsvResponse>;
+/**
+ * Send all BSV to a destination address.
+ */
+export declare function sendAllBsv(cwi: WalletInterface, destination: string): Promise<SendBsvResponse>;

package/dist/api/payments/index.js

@@ -0,0 +1,130 @@
+/**
+ * Payments Module
+ *
+ * Functions for sending BSV payments.
+ */
+import { P2PKH, Script, Utils, } from "@bsv/sdk";
+import { Inscription } from "@bopen-io/templates";
+import { FUNDING_BASKET } from "../constants";
+/**
+ * Check if address is a paymail.
+ */
+function isPaymail(address) {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(address);
+}
+/**
+ * Build an inscription locking script.
+ */
+function buildInscriptionScript(address, base64Data, mimeType) {
+    const content = Utils.toArray(base64Data, "base64");
+    const inscription = Inscription.create(new Uint8Array(content), mimeType);
+    const inscriptionScript = inscription.lock();
+    const p2pkhScript = new P2PKH().lock(address);
+    const combined = new Script();
+    for (const chunk of inscriptionScript.chunks)
+        combined.chunks.push(chunk);
+    for (const chunk of p2pkhScript.chunks)
+        combined.chunks.push(chunk);
+    return combined;
+}
+/**
+ * Send BSV to one or more destinations.
+ */
+export async function sendBsv(cwi, requests) {
+    try {
+        if (!requests || requests.length === 0) {
+            return { error: "no-requests" };
+        }
+        const outputs = [];
+        for (const req of requests) {
+            let lockingScript;
+            if (req.script) {
+                lockingScript = Script.fromHex(req.script);
+            }
+            else if (req.address) {
+                if (req.inscription) {
+                    lockingScript = buildInscriptionScript(req.address, req.inscription.base64Data, req.inscription.mimeType);
+                }
+                else {
+                    lockingScript = new P2PKH().lock(req.address);
+                }
+            }
+            else if (req.data && req.data.length > 0) {
+                try {
+                    lockingScript = Script.fromASM(`OP_0 OP_RETURN ${req.data.join(" ")}`);
+                }
+                catch {
+                    return { error: "invalid-data" };
+                }
+            }
+            else if (req.paymail) {
+                return { error: "paymail-not-yet-implemented" };
+            }
+            else {
+                return { error: "invalid-request" };
+            }
+            outputs.push({
+                lockingScript: lockingScript.toHex(),
+                satoshis: req.satoshis,
+                outputDescription: `Payment of ${req.satoshis} sats`,
+            });
+        }
+        const result = await cwi.createAction({
+            description: `Send ${requests.length} payment(s)`,
+            outputs,
+            options: { signAndProcess: true },
+        });
+        if (!result.txid) {
+            return { error: "no-txid-returned" };
+        }
+        return { txid: result.txid, rawtx: result.tx ? Utils.toHex(result.tx) : undefined };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : "unknown-error" };
+    }
+}
+/**
+ * Send all BSV to a destination address.
+ */
+export async function sendAllBsv(cwi, destination) {
+    try {
+        if (isPaymail(destination)) {
+            return { error: "paymail-not-yet-implemented" };
+        }
+        const listResult = await cwi.listOutputs({
+            basket: FUNDING_BASKET,
+            include: "locking scripts",
+            limit: 10000,
+        });
+        if (!listResult.outputs || listResult.outputs.length === 0) {
+            return { error: "no-funds" };
+        }
+        const totalSats = listResult.outputs.reduce((sum, o) => sum + o.satoshis, 0);
+        const estimatedFee = Math.ceil((listResult.outputs.length * 150 + 44) * 1);
+        const sendAmount = totalSats - estimatedFee;
+        if (sendAmount <= 0) {
+            return { error: "insufficient-funds-for-fee" };
+        }
+        const inputs = listResult.outputs.map((o) => ({
+            outpoint: o.outpoint,
+            inputDescription: "Sweep funds",
+        }));
+        const result = await cwi.createAction({
+            description: "Send all BSV",
+            inputs,
+            outputs: [{
+                    lockingScript: new P2PKH().lock(destination).toHex(),
+                    satoshis: sendAmount,
+                    outputDescription: "Sweep all funds",
+                }],
+            options: { signAndProcess: true },
+        });
+        if (!result.txid) {
+            return { error: "no-txid-returned" };
+        }
+        return { txid: result.txid, rawtx: result.tx ? Utils.toHex(result.tx) : undefined };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : "unknown-error" };
+    }
+}

package/dist/api/signing/index.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Signing Module
+ *
+ * Functions for message signing.
+ */
+import { type WalletInterface } from "@bsv/sdk";
+export interface SignMessageRequest {
+    /** Message to sign */
+    message: string;
+    /** Message encoding */
+    encoding?: "utf8" | "hex" | "base64";
+    /** Derivation tag for key selection */
+    tag?: {
+        label: string;
+        id: string;
+        domain: string;
+        meta: Record<string, string>;
+    };
+}
+export interface SignedMessage {
+    address: string;
+    pubKey: string;
+    message: string;
+    sig: string;
+    derivationTag?: SignMessageRequest["tag"];
+}
+/**
+ * Sign a message using BSM (Bitcoin Signed Message) format.
+ */
+export declare function signMessage(cwi: WalletInterface, request: SignMessageRequest): Promise<SignedMessage | {
+    error: string;
+}>;

package/dist/api/signing/index.js

@@ -0,0 +1,41 @@
+/**
+ * Signing Module
+ *
+ * Functions for message signing.
+ */
+import { BigNumber, BSM, PublicKey, Signature, Utils, } from "@bsv/sdk";
+import { MESSAGE_SIGNING_PROTOCOL } from "../constants";
+/**
+ * Sign a message using BSM (Bitcoin Signed Message) format.
+ */
+export async function signMessage(cwi, request) {
+    try {
+        const { message, encoding = "utf8", tag } = request;
+        const messageBytes = Utils.toArray(message, encoding);
+        const msgHash = BSM.magicHash(messageBytes);
+        const keyID = tag ? `${tag.label}:${tag.id}:${tag.domain}` : "identity";
+        const result = await cwi.createSignature({
+            protocolID: MESSAGE_SIGNING_PROTOCOL,
+            keyID,
+            hashToDirectlySign: Array.from(msgHash),
+        });
+        const pubKeyResult = await cwi.getPublicKey({
+            protocolID: MESSAGE_SIGNING_PROTOCOL,
+            keyID,
+            forSelf: true,
+        });
+        const publicKey = PublicKey.fromString(pubKeyResult.publicKey);
+        const signature = Signature.fromDER(result.signature);
+        const recovery = signature.CalculateRecoveryFactor(publicKey, new BigNumber(msgHash));
+        return {
+            address: publicKey.toAddress(),
+            pubKey: publicKey.toString(),
+            message,
+            sig: signature.toCompact(recovery, true, "base64"),
+            derivationTag: tag,
+        };
+    }
+    catch (error) {
+        return { error: error instanceof Error ? error.message : "unknown-error" };
+    }
+}