@dynamic-labs/embedded-wallet-bitcoin 4.18.7

package/src/lib/TurnkeyBitcoinWalletConnector/TurnkeyBitcoinWalletConnector.js

@@ -0,0 +1,352 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import ecc from '@bitcoinerlab/secp256k1';
+import { ECPairFactory } from 'ecpair';
+import { initEccLib, networks, Psbt, payments, address } from 'bitcoinjs-lib';
+import { BitcoinWallet, getMempoolApiUrl, satoshisToBtc } from '@dynamic-labs/bitcoin';
+import { isSameAddress } from '@dynamic-labs/wallet-connector-core';
+import { DynamicError } from '@dynamic-labs/utils';
+import { TurnkeyWalletConnectorBase, findTurnkeyVerifiedCredentials, logger } from '@dynamic-labs/embedded-wallet';
+import { estimateFees } from './fees.js';
+import { TurnkeySigner } from './signer.js';
+
+initEccLib(ecc);
+class TurnkeyBitcoinWalletConnector extends TurnkeyWalletConnectorBase {
+    constructor(nameAndKey, props) {
+        super(nameAndKey, props);
+        this.ChainWallet = BitcoinWallet;
+        this.connectedChain = 'BTC';
+        this.supportedChains = ['BTC'];
+        this.canFetchConnectedAccounts = false;
+        this.isHardwareWalletEnabled = false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    isLedgerAddress(_address) {
+        return false;
+    }
+    clearConnectedAccounts() {
+        return Promise.resolve();
+    }
+    setVerifiedCredentials(verifiedCredentials) {
+        const turnkeyVerifiedCredentials = findTurnkeyVerifiedCredentials(verifiedCredentials, 'bip122');
+        const [turnkeyVerifiedCredential] = turnkeyVerifiedCredentials;
+        const didTurnkeyVerifiedCredentialsChanged = JSON.stringify(this.verifiedCredentials) !==
+            JSON.stringify(turnkeyVerifiedCredentials);
+        if (!didTurnkeyVerifiedCredentialsChanged) {
+            return;
+        }
+        this.verifiedCredential = turnkeyVerifiedCredential;
+        this.verifiedCredentials = turnkeyVerifiedCredentials;
+        this.refreshTurnkeyAccount();
+    }
+    validateActiveWallet(expectedAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const activeAddress = ((_a = this.verifiedCredential) === null || _a === void 0 ? void 0 : _a.address) || '';
+            const isWalletActive = isSameAddress(activeAddress, expectedAddress, this.connectedChain);
+            if (!isWalletActive) {
+                const targetActiveAccount = (_b = this.verifiedCredentials) === null || _b === void 0 ? void 0 : _b.find((vc) => (vc === null || vc === void 0 ? void 0 : vc.address) === expectedAddress);
+                if (!targetActiveAccount) {
+                    throw new DynamicError('Account not found');
+                }
+                this.verifiedCredential = targetActiveAccount;
+                this.refreshTurnkeyAccount();
+            }
+        });
+    }
+    refreshTurnkeyAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            this._turnkeyAccount = undefined;
+            return this.getTurnkeyAccount();
+        });
+    }
+    createTurnkeyAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const turnkeyClient = yield this.getTurnkeyClient();
+            const account = turnkeyClient;
+            return account;
+        });
+    }
+    getTurnkeyAccount() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const { turnkeySubOrganizationId } = (_a = this.walletProperties) !== null && _a !== void 0 ? _a : {};
+            const { address } = (_b = this.verifiedCredential) !== null && _b !== void 0 ? _b : {};
+            if (!turnkeySubOrganizationId || !address) {
+                return;
+            }
+            this._turnkeyAccount = yield this.createTurnkeyAccount();
+            this.setLoggerMetadata();
+            return this._turnkeyAccount;
+        });
+    }
+    getUTXOs(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const url = getMempoolApiUrl(address);
+                const response = yield fetch(`${url}/address/${address}/utxo`);
+                return yield response.json();
+            }
+            catch (error) {
+                logger.error('Error fetching UTXOs:', error);
+                throw error;
+            }
+        });
+    }
+    getBitcoinNetwork(accountAddress) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return accountAddress.startsWith('t') ? networks.testnet : networks.bitcoin;
+        });
+    }
+    sendRawTransaction(rawTransaction) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!rawTransaction) {
+                throw new DynamicError('No transaction specified!');
+            }
+            const accountAddress = this.getAccount();
+            if (!accountAddress) {
+                throw new DynamicError('No account address found!');
+            }
+            const API_URL = getMempoolApiUrl(accountAddress);
+            const response = yield fetch(`${API_URL}/tx`, {
+                body: rawTransaction,
+                headers: {
+                    'Content-Type': 'application/x-www-form-urlencoded',
+                },
+                method: 'POST',
+            });
+            if (!response.ok) {
+                if (response.status === 429) {
+                    throw new DynamicError('sendRawTransaction - mempool api rate limit exceeded');
+                }
+                const error = yield response.text();
+                logger.debug(`sendRawTransaction - response not ok: ${JSON.stringify(error)}`);
+                throw new DynamicError('sendRawTransaction - failed to send transaction');
+            }
+            // this endpoint returns the transaction ID
+            return response.text();
+        });
+    }
+    sendBitcoin(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ recipientAddress, amount, }) {
+            var _b, _c;
+            yield this.createOrRestoreSession();
+            const accountAddress = this.getAccount();
+            const { walletAdditionalAddresses } = (_b = this.verifiedCredential) !== null && _b !== void 0 ? _b : {};
+            if (!accountAddress || !walletAdditionalAddresses) {
+                throw new Error('Failed to get address or wallet additional addresses');
+            }
+            const additionalAddress = walletAdditionalAddresses.find((additionalAddress) => additionalAddress.address === accountAddress);
+            const publicKeyCompressed = additionalAddress === null || additionalAddress === void 0 ? void 0 : additionalAddress.publicKey;
+            if (!publicKeyCompressed) {
+                throw new Error('Failed to get public key');
+            }
+            const ECPair = ECPairFactory(ecc);
+            const pair = ECPair.fromPublicKey(Buffer.from(publicKeyCompressed, 'hex'));
+            const network = yield this.getBitcoinNetwork(accountAddress);
+            const psbt = new Psbt({ network });
+            const utxos = yield this.getUTXOs(accountAddress);
+            const feeEstimate = yield estimateFees({
+                network,
+                numInputs: utxos.length,
+                numOutputs: 2,
+            });
+            const totalToSpend = utxos.reduce((total, utxo) => total + utxo.value, 0);
+            const maxToSpend = totalToSpend - feeEstimate;
+            const changeAmount = BigInt(maxToSpend) - BigInt(amount);
+            for (const utxo of utxos) {
+                if (accountAddress.startsWith('tb1p') ||
+                    accountAddress.startsWith('bc1p')) {
+                    const xOnlyPublicKey = pair.publicKey.slice(1, 33);
+                    const outputScript = payments.p2tr({
+                        internalPubkey: xOnlyPublicKey,
+                        network: network,
+                    }).output;
+                    if (!outputScript) {
+                        throw new Error('Failed to create output script');
+                    }
+                    psbt.addInput({
+                        hash: utxo.txid,
+                        index: utxo.vout,
+                        tapInternalKey: xOnlyPublicKey,
+                        witnessUtxo: {
+                            script: outputScript,
+                            value: utxo.value,
+                        },
+                    });
+                }
+                else {
+                    // P2WPKH (SegWit)
+                    const witnessUtxo = payments.p2wpkh({
+                        network,
+                        pubkey: pair.publicKey,
+                    }).output;
+                    if (!witnessUtxo) {
+                        throw new Error('Failed to create witness utxo');
+                    }
+                    psbt.addInput({
+                        hash: utxo.txid,
+                        index: utxo.vout,
+                        witnessUtxo: {
+                            script: witnessUtxo,
+                            value: utxo.value,
+                        },
+                    });
+                }
+            }
+            const DUST_LIMIT = 546; // Bitcoin's dust limit in satoshis
+            if (Number(amount) < DUST_LIMIT) {
+                throw new Error('Amount is below dust limit of 546 satoshis');
+            }
+            psbt.addOutput({
+                script: address.toOutputScript(recipientAddress, network),
+                value: Number(amount),
+            });
+            if (changeAmount > 0) {
+                psbt.addOutput({
+                    script: address.toOutputScript(accountAddress, network),
+                    value: Number(changeAmount),
+                });
+            }
+            const turnkeyClient = yield this.getTurnkeyAccount();
+            if (!turnkeyClient) {
+                throw new Error('Failed to get turnkey client');
+            }
+            const signer = new TurnkeySigner({
+                address: accountAddress,
+                client: turnkeyClient,
+                organizationId: (_c = this.walletProperties) === null || _c === void 0 ? void 0 : _c.turnkeySubOrganizationId,
+                publicKey: address.fromBech32(accountAddress).data,
+            });
+            yield Promise.all(utxos.map((_utxo, i) => __awaiter(this, void 0, void 0, function* () {
+                yield psbt.signInputAsync(i, signer);
+            })));
+            psbt.finalizeAllInputs();
+            const txHex = psbt.extractTransaction().toHex();
+            return this.sendRawTransaction(txHex);
+        });
+    }
+    signPsbt(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ allowedSighash, unsignedPsbtBase64, signature, }) {
+            var _b, _c, _d;
+            yield this.createOrRestoreSession();
+            const accountAddress = this.getAccount();
+            if (!accountAddress) {
+                throw new Error('Failed to get address');
+            }
+            const psbt = Psbt.fromBase64(unsignedPsbtBase64);
+            const turnkeyClient = yield this.getTurnkeyAccount();
+            if (!turnkeyClient) {
+                throw new Error('Failed to get turnkey client');
+            }
+            const signer = new TurnkeySigner({
+                address: accountAddress,
+                client: turnkeyClient,
+                organizationId: (_b = this.walletProperties) === null || _b === void 0 ? void 0 : _b.turnkeySubOrganizationId,
+                publicKey: address.fromBech32(accountAddress).data,
+            });
+            if (signature) {
+                for (let i = 0; i < signature.length; i++) {
+                    const sigIdx = (_d = (_c = signature[i]) === null || _c === void 0 ? void 0 : _c.signingIndexes) === null || _d === void 0 ? void 0 : _d[0];
+                    if (sigIdx !== undefined) {
+                        yield psbt.signInputAsync(sigIdx, signer, allowedSighash);
+                    }
+                }
+            }
+            else {
+                yield psbt.signAllInputsAsync(signer, allowedSighash);
+            }
+            psbt.finalizeAllInputs();
+            return {
+                signedPsbt: psbt.toBase64(),
+            };
+        });
+    }
+    signPsbts(requests) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const signedPsbts = yield Promise.all(requests.map((request) => this.signPsbt(request)));
+            return signedPsbts.map((response) => response.signedPsbt || '');
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    createUiTransaction(from) {
+        throw new Error('Method not implemented.');
+    }
+    canConnectWithHardwareWallet() {
+        return false;
+    }
+    isInstalledOnBrowser() {
+        return false;
+    }
+    apiGetBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const API_URL = getMempoolApiUrl(address);
+            const response = yield fetch(`${API_URL}/address/${address}`);
+            if (!response.ok) {
+                // if the request fails due to rate limits, return cached value
+                if (response.status === 429) {
+                    return '0';
+                }
+                // new accounts not yet indexed will return a 404
+                if (response.status === 404) {
+                    return '0';
+                }
+                return undefined;
+            }
+            const addressInfo = yield response.json();
+            if (!(addressInfo === null || addressInfo === void 0 ? void 0 : addressInfo.chain_stats) || !(addressInfo === null || addressInfo === void 0 ? void 0 : addressInfo.mempool_stats)) {
+                return undefined;
+            }
+            const confirmedBalanceInSats = Number(addressInfo.chain_stats.funded_txo_sum) -
+                Number(addressInfo.chain_stats.spent_txo_sum);
+            const unconfirmedBalanceInSats = Number(addressInfo.mempool_stats.funded_txo_sum) -
+                Number(addressInfo.mempool_stats.spent_txo_sum);
+            const balance = satoshisToBtc(confirmedBalanceInSats + unconfirmedBalanceInSats);
+            return balance.toString();
+        });
+    }
+    getBalance(address) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.apiGetBalance(address);
+        });
+    }
+    getAccount() {
+        return this.turnkeyAddress;
+    }
+    signMessage(messageToSign, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            yield this.createOrRestoreSession();
+            const turnkeyAccount = yield this.getTurnkeyAccount();
+            const accountAddress = this.getAccount();
+            if (!turnkeyAccount || !accountAddress) {
+                return;
+            }
+            const msgBuffer = new TextEncoder().encode(messageToSign);
+            const hashBuffer = yield crypto.subtle.digest('SHA-256', msgBuffer);
+            const hashArray = Array.from(new Uint8Array(hashBuffer));
+            const payload = hashArray
+                .map((b) => b.toString(16).padStart(2, '0'))
+                .join('');
+            const response = yield (turnkeyAccount === null || turnkeyAccount === void 0 ? void 0 : turnkeyAccount.signRawPayload({
+                organizationId: (_a = this.walletProperties) === null || _a === void 0 ? void 0 : _a.turnkeySubOrganizationId,
+                parameters: {
+                    encoding: 'PAYLOAD_ENCODING_HEXADECIMAL',
+                    hashFunction: 'HASH_FUNCTION_SHA256',
+                    payload,
+                    signWith: (_b = options === null || options === void 0 ? void 0 : options.address) !== null && _b !== void 0 ? _b : accountAddress, // default to ordinals address
+                },
+                timestampMs: new Date().getTime().toString(),
+                type: 'ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2',
+            }));
+            const result = response.activity.result.signRawPayloadResult;
+            if (!result) {
+                return;
+            }
+            const { r, s } = result;
+            return Buffer.from(r + s).toString('hex');
+        });
+    }
+}
+
+export { TurnkeyBitcoinWalletConnector };

package/src/lib/TurnkeyBitcoinWalletConnector/fees.cjs

@@ -0,0 +1,50 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+var embeddedWallet = require('@dynamic-labs/embedded-wallet');
+
+// These constants helps us estimate an upper bound for fees.
+// Source: https://x.com/murchandamus/status/1262062602298916865
+const INPUT_BYTE_SIZE_UPPER_BOUND = 90;
+const OUTPUT_BYTE_SIZE_UPPER_BOUND = 45;
+/**
+ * Estimate fees for a transaction with N inputs and M output. This function provides an UPPER BOUND.
+ * The "proper" approach to estimate fees tighter would be:
+ * - make a transaction "for real", sign it
+ * - finalize with `psbt.finalizeAllInputs()`
+ * - get the transaction byte size with `psbt.extractTransaction().toHex()`;
+ * - then modify the transaction (adjust fees/change) and re-sign
+ * Given this is a test-only script we're comfortable over-paying a bit. Miners, rejoice!
+ */
+const estimateFees = (feeParams) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    const { numInputs, numOutputs, network } = feeParams;
+    const feePerByteResponse = yield getFeePerByte(network);
+    const feePerByte = feePerByteResponse.hourFee;
+    const minRelayFee = 111;
+    const estimatedFee = feePerByte *
+        (INPUT_BYTE_SIZE_UPPER_BOUND * numInputs +
+            OUTPUT_BYTE_SIZE_UPPER_BOUND * numOutputs) +
+        minRelayFee;
+    return estimatedFee;
+});
+/**
+ * Fetch the right fee-per-byte for the passed in network.
+ */
+const getFeePerByte = (network) => _tslib.__awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const url = network.bech32 === 'bc'
+            ? 'https://mempool.space/api/v1/fees/recommended'
+            : 'https://mempool.space/testnet/api/v1/fees/recommended';
+        const response = yield fetch(url);
+        return yield response.json();
+    }
+    catch (error) {
+        embeddedWallet.logger.error('Error fetching fee estimate:', error);
+        throw error;
+    }
+});
+
+exports.estimateFees = estimateFees;

package/src/lib/TurnkeyBitcoinWalletConnector/fees.d.ts

@@ -0,0 +1,15 @@
+import type { Network } from 'bitcoinjs-lib';
+/**
+ * Estimate fees for a transaction with N inputs and M output. This function provides an UPPER BOUND.
+ * The "proper" approach to estimate fees tighter would be:
+ * - make a transaction "for real", sign it
+ * - finalize with `psbt.finalizeAllInputs()`
+ * - get the transaction byte size with `psbt.extractTransaction().toHex()`;
+ * - then modify the transaction (adjust fees/change) and re-sign
+ * Given this is a test-only script we're comfortable over-paying a bit. Miners, rejoice!
+ */
+export declare const estimateFees: (feeParams: {
+    numInputs: number;
+    numOutputs: number;
+    network: Network;
+}) => Promise<number>;

package/src/lib/TurnkeyBitcoinWalletConnector/fees.js

@@ -0,0 +1,46 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+import { logger } from '@dynamic-labs/embedded-wallet';
+
+// These constants helps us estimate an upper bound for fees.
+// Source: https://x.com/murchandamus/status/1262062602298916865
+const INPUT_BYTE_SIZE_UPPER_BOUND = 90;
+const OUTPUT_BYTE_SIZE_UPPER_BOUND = 45;
+/**
+ * Estimate fees for a transaction with N inputs and M output. This function provides an UPPER BOUND.
+ * The "proper" approach to estimate fees tighter would be:
+ * - make a transaction "for real", sign it
+ * - finalize with `psbt.finalizeAllInputs()`
+ * - get the transaction byte size with `psbt.extractTransaction().toHex()`;
+ * - then modify the transaction (adjust fees/change) and re-sign
+ * Given this is a test-only script we're comfortable over-paying a bit. Miners, rejoice!
+ */
+const estimateFees = (feeParams) => __awaiter(void 0, void 0, void 0, function* () {
+    const { numInputs, numOutputs, network } = feeParams;
+    const feePerByteResponse = yield getFeePerByte(network);
+    const feePerByte = feePerByteResponse.hourFee;
+    const minRelayFee = 111;
+    const estimatedFee = feePerByte *
+        (INPUT_BYTE_SIZE_UPPER_BOUND * numInputs +
+            OUTPUT_BYTE_SIZE_UPPER_BOUND * numOutputs) +
+        minRelayFee;
+    return estimatedFee;
+});
+/**
+ * Fetch the right fee-per-byte for the passed in network.
+ */
+const getFeePerByte = (network) => __awaiter(void 0, void 0, void 0, function* () {
+    try {
+        const url = network.bech32 === 'bc'
+            ? 'https://mempool.space/api/v1/fees/recommended'
+            : 'https://mempool.space/testnet/api/v1/fees/recommended';
+        const response = yield fetch(url);
+        return yield response.json();
+    }
+    catch (error) {
+        logger.error('Error fetching fee estimate:', error);
+        throw error;
+    }
+});
+
+export { estimateFees };

package/src/lib/TurnkeyBitcoinWalletConnector/index.d.ts

@@ -0,0 +1 @@
+export { TurnkeyBitcoinWalletConnector } from './TurnkeyBitcoinWalletConnector';

package/src/lib/TurnkeyBitcoinWalletConnector/signer.cjs

@@ -0,0 +1,51 @@
+'use client'
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _tslib = require('../../../_virtual/_tslib.cjs');
+
+class TurnkeySigner {
+    /**
+     * @param client The turnkey SDK client
+     * @param address The Turnkey-derived address in bech32 format
+     * @param publicKey public key buffer. To sign P2TR outputs it needs to be
+     *  the decoded address (`bitcoin.address.fromBech32(address).data`).
+     *  For P2WPKH it should be the key pair's underlying public key buffer, uncompressed.
+     */
+    constructor({ client, address, publicKey, organizationId, }) {
+        this.client = client;
+        this.address = address;
+        this.publicKey = publicKey;
+        this.organizationId = organizationId;
+    }
+    sign(hash) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.signRawPayload({
+                organizationId: this.organizationId,
+                parameters: {
+                    encoding: 'PAYLOAD_ENCODING_HEXADECIMAL',
+                    hashFunction: 'HASH_FUNCTION_NO_OP',
+                    payload: hash.toString('hex'),
+                    signWith: this.address,
+                },
+                timestampMs: new Date().getTime().toString(),
+                type: 'ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2',
+            });
+            const result = response.activity.result.signRawPayloadResult;
+            if (!result) {
+                throw new Error('Failed to sign raw payload');
+            }
+            const { r, s } = result;
+            return Buffer.from(r + s, 'hex');
+        });
+    }
+    signSchnorr(hash) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            // Use the same signing logic for Schnorr
+            return this.sign(hash);
+        });
+    }
+}
+
+exports.TurnkeySigner = TurnkeySigner;

package/src/lib/TurnkeyBitcoinWalletConnector/signer.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+import { TurnkeyClient } from '@turnkey/http';
+export declare class TurnkeySigner {
+    client: TurnkeyClient;
+    publicKey: Buffer;
+    address: string;
+    organizationId: string;
+    /**
+     * @param client The turnkey SDK client
+     * @param address The Turnkey-derived address in bech32 format
+     * @param publicKey public key buffer. To sign P2TR outputs it needs to be
+     *  the decoded address (`bitcoin.address.fromBech32(address).data`).
+     *  For P2WPKH it should be the key pair's underlying public key buffer, uncompressed.
+     */
+    constructor({ client, address, publicKey, organizationId, }: {
+        client: TurnkeyClient;
+        address: string;
+        publicKey: Buffer;
+        organizationId: string;
+    });
+    sign(hash: Buffer): Promise<Buffer>;
+    signSchnorr(hash: Buffer): Promise<Buffer>;
+}

package/src/lib/TurnkeyBitcoinWalletConnector/signer.js

@@ -0,0 +1,47 @@
+'use client'
+import { __awaiter } from '../../../_virtual/_tslib.js';
+
+class TurnkeySigner {
+    /**
+     * @param client The turnkey SDK client
+     * @param address The Turnkey-derived address in bech32 format
+     * @param publicKey public key buffer. To sign P2TR outputs it needs to be
+     *  the decoded address (`bitcoin.address.fromBech32(address).data`).
+     *  For P2WPKH it should be the key pair's underlying public key buffer, uncompressed.
+     */
+    constructor({ client, address, publicKey, organizationId, }) {
+        this.client = client;
+        this.address = address;
+        this.publicKey = publicKey;
+        this.organizationId = organizationId;
+    }
+    sign(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.client.signRawPayload({
+                organizationId: this.organizationId,
+                parameters: {
+                    encoding: 'PAYLOAD_ENCODING_HEXADECIMAL',
+                    hashFunction: 'HASH_FUNCTION_NO_OP',
+                    payload: hash.toString('hex'),
+                    signWith: this.address,
+                },
+                timestampMs: new Date().getTime().toString(),
+                type: 'ACTIVITY_TYPE_SIGN_RAW_PAYLOAD_V2',
+            });
+            const result = response.activity.result.signRawPayloadResult;
+            if (!result) {
+                throw new Error('Failed to sign raw payload');
+            }
+            const { r, s } = result;
+            return Buffer.from(r + s, 'hex');
+        });
+    }
+    signSchnorr(hash) {
+        return __awaiter(this, void 0, void 0, function* () {
+            // Use the same signing logic for Schnorr
+            return this.sign(hash);
+        });
+    }
+}
+
+export { TurnkeySigner };