@reown/appkit-adapter-bitcoin 1.6.1-rc.0

package/dist/types/exports/index.d.ts

@@ -0,0 +1 @@
+export * from '../src/index.js';

package/dist/types/src/adapter.d.ts

@@ -0,0 +1,36 @@
+import { type AppKit, type AppKitOptions } from '@reown/appkit';
+import { AdapterBlueprint } from '@reown/appkit/adapters';
+import type { BitcoinConnector } from './utils/BitcoinConnector.js';
+import { BitcoinApi } from './utils/BitcoinApi.js';
+export declare class BitcoinAdapter extends AdapterBlueprint<BitcoinConnector> {
+    private eventsToUnbind;
+    private api;
+    constructor({ api, ...params }?: BitcoinAdapter.ConstructorParams);
+    connectWalletConnect(onUri: (uri: string) => void): Promise<void>;
+    connect(params: AdapterBlueprint.ConnectParams): Promise<AdapterBlueprint.ConnectResult>;
+    getAccounts(_params: AdapterBlueprint.GetAccountsParams): Promise<AdapterBlueprint.GetAccountsResult>;
+    syncConnectors(_options?: AppKitOptions, appKit?: AppKit): void;
+    syncConnection(params: AdapterBlueprint.SyncConnectionParams): Promise<AdapterBlueprint.ConnectResult>;
+    signMessage(params: AdapterBlueprint.SignMessageParams): Promise<AdapterBlueprint.SignMessageResult>;
+    getWalletConnectProvider(params: AdapterBlueprint.GetWalletConnectProviderParams): AdapterBlueprint.GetWalletConnectProviderResult;
+    switchNetwork(_params: AdapterBlueprint.SwitchNetworkParams): Promise<void>;
+    disconnect(params: AdapterBlueprint.DisconnectParams): Promise<void>;
+    getBalance(params: AdapterBlueprint.GetBalanceParams): Promise<AdapterBlueprint.GetBalanceResult>;
+    getProfile(_params: AdapterBlueprint.GetProfileParams): Promise<AdapterBlueprint.GetProfileResult>;
+    estimateGas(_params: AdapterBlueprint.EstimateGasTransactionArgs): Promise<AdapterBlueprint.EstimateGasTransactionResult>;
+    sendTransaction(_params: AdapterBlueprint.SendTransactionParams): Promise<AdapterBlueprint.SendTransactionResult>;
+    writeContract(_params: AdapterBlueprint.WriteContractParams): Promise<AdapterBlueprint.WriteContractResult>;
+    getEnsAddress(_params: AdapterBlueprint.GetEnsAddressParams): Promise<AdapterBlueprint.GetEnsAddressResult>;
+    parseUnits(_params: AdapterBlueprint.ParseUnitsParams): bigint;
+    formatUnits(_params: AdapterBlueprint.FormatUnitsParams): string;
+    grantPermissions(_params: AdapterBlueprint.GrantPermissionsParams): Promise<unknown>;
+    getCapabilities(_params: AdapterBlueprint.GetCapabilitiesParams): Promise<unknown>;
+    revokePermissions(_params: AdapterBlueprint.RevokePermissionsParams): Promise<`0x${string}`>;
+    private bindEvents;
+    private unbindEvents;
+}
+export declare namespace BitcoinAdapter {
+    type ConstructorParams = Omit<AdapterBlueprint.Params, 'namespace'> & {
+        api?: Partial<BitcoinApi.Interface>;
+    };
+}

package/dist/types/src/connectors/LeatherConnector.d.ts

@@ -0,0 +1,23 @@
+import type { BitcoinConnector } from '../index.js';
+import { SatsConnectConnector } from './SatsConnectConnector.js';
+import type { SendTransferRequestParams, SendTransferResponseBody, SignPsbtRequestParams, SignPsbtResponseBody } from '@leather.io/rpc';
+export declare class LeatherConnector extends SatsConnectConnector {
+    static readonly ProviderId = "LeatherProvider";
+    private connectedAccounts?;
+    constructor({ connector }: LeatherConnector.ConstructorParams);
+    getAccountAddresses(): Promise<BitcoinConnector.AccountAddress[]>;
+    disconnect(): Promise<void>;
+    sendTransfer({ amount, recipient }: BitcoinConnector.SendTransferParams): Promise<string>;
+    signPSBT({ psbt, broadcast }: BitcoinConnector.SignPSBTParams): Promise<BitcoinConnector.SignPSBTResponse>;
+    private getNetwork;
+}
+export declare namespace LeatherConnector {
+    type ConstructorParams = {
+        connector: SatsConnectConnector;
+    };
+    type Network = 'mainnet' | 'testnet' | 'signet' | 'sbtcDevenv' | 'devnet';
+    type SendTransferParams = SendTransferRequestParams;
+    type SendTransferResponse = SendTransferResponseBody;
+    type SignPSBTParams = SignPsbtRequestParams;
+    type SignPSBTResponse = SignPsbtResponseBody;
+}

package/dist/types/src/connectors/OKXConnector.d.ts

@@ -0,0 +1,59 @@
+import type { CaipNetwork } from '@reown/appkit-common';
+import type { BitcoinConnector } from '../utils/BitcoinConnector.js';
+import { ProviderEventEmitter } from '../utils/ProviderEventEmitter.js';
+import type { RequestArguments } from '@reown/appkit-core';
+export declare class OKXConnector extends ProviderEventEmitter implements BitcoinConnector {
+    readonly id = "OKX";
+    readonly name = "OKX Wallet";
+    readonly chain = "bip122";
+    readonly type = "ANNOUNCED";
+    readonly imageUrl: string;
+    readonly provider: this;
+    private readonly wallet;
+    private readonly requestedChains;
+    private readonly getActiveNetwork;
+    constructor({ wallet, requestedChains, getActiveNetwork, imageUrl }: OKXConnector.ConstructorParams);
+    get chains(): CaipNetwork[];
+    connect(): Promise<string>;
+    disconnect(): Promise<void>;
+    getAccountAddresses(): Promise<BitcoinConnector.AccountAddress[]>;
+    signMessage(params: BitcoinConnector.SignMessageParams): Promise<string>;
+    sendTransfer(params: BitcoinConnector.SendTransferParams): Promise<string>;
+    signPSBT(params: BitcoinConnector.SignPSBTParams): Promise<BitcoinConnector.SignPSBTResponse>;
+    request<T>(_args: RequestArguments): Promise<T>;
+    private bindEvents;
+    private unbindEvents;
+    static getWallet(params: OKXConnector.GetWalletParams): OKXConnector | undefined;
+}
+export declare namespace OKXConnector {
+    type ConstructorParams = {
+        wallet: Wallet;
+        requestedChains: CaipNetwork[];
+        getActiveNetwork: () => CaipNetwork | undefined;
+        imageUrl: string;
+    };
+    type Wallet = {
+        connect(): Promise<{
+            address: string;
+            publicKey: string;
+        }>;
+        disconnect(): Promise<void>;
+        getAccounts(): Promise<string[]>;
+        signMessage(signStr: string, type?: 'ecdsa' | 'bip322-simple'): Promise<string>;
+        signPsbt(psbtHex: string): Promise<string>;
+        pushPsbt(psbtHex: string): Promise<string>;
+        send(params: {
+            from: string;
+            to: string;
+            value: string;
+            satBytes?: string;
+            memo?: string;
+            memoPos?: number;
+        }): Promise<{
+            txhash: string;
+        }>;
+        on(event: string, listener: (param?: unknown) => void): void;
+        removeAllListeners(): void;
+    };
+    type GetWalletParams = Omit<ConstructorParams, 'wallet' | 'imageUrl'>;
+}

package/dist/types/src/connectors/SatsConnectConnector.d.ts

@@ -0,0 +1,42 @@
+import type { BitcoinConnector } from '../utils/BitcoinConnector.js';
+import type { CaipNetwork } from '@reown/appkit-common';
+import { type Params, type Provider as SatsConnectProvider, type BitcoinProvider, type Requests as SatsConnectRequests, type RpcSuccessResponse } from 'sats-connect';
+import type { RequestArguments } from '@reown/appkit-core';
+import { ProviderEventEmitter } from '../utils/ProviderEventEmitter.js';
+export declare class SatsConnectConnector extends ProviderEventEmitter implements BitcoinConnector {
+    readonly chain = "bip122";
+    readonly type = "ANNOUNCED";
+    readonly wallet: SatsConnectProvider;
+    readonly provider: BitcoinConnector;
+    readonly requestedChains: CaipNetwork[];
+    readonly getActiveNetwork: () => CaipNetwork | undefined;
+    private walletUnsubscribes;
+    constructor({ provider, requestedChains, getActiveNetwork }: SatsConnectConnector.ConstructorParams);
+    get id(): string;
+    get name(): string;
+    get imageUrl(): string;
+    get chains(): CaipNetwork[];
+    request<T>(args: RequestArguments): Promise<T>;
+    connect(): Promise<string>;
+    disconnect(): Promise<void>;
+    getAccountAddresses(): Promise<BitcoinConnector.AccountAddress[]>;
+    static getWallets({ requestedChains, getActiveNetwork }: SatsConnectConnector.GetWalletsParams): SatsConnectConnector[];
+    signMessage(params: BitcoinConnector.SignMessageParams): Promise<string>;
+    signPSBT(params: BitcoinConnector.SignPSBTParams): Promise<BitcoinConnector.SignPSBTResponse>;
+    sendTransfer({ amount, recipient }: BitcoinConnector.SendTransferParams): Promise<string>;
+    protected getWalletProvider(): BitcoinProvider;
+    protected internalRequest<Method extends keyof SatsConnectRequests>(method: Method, options: Params<Method>): Promise<RpcSuccessResponse<Method>['result']>;
+    private bindEvents;
+    private unbindEvents;
+}
+export declare namespace SatsConnectConnector {
+    type ConstructorParams = {
+        provider: SatsConnectProvider;
+        requestedChains: CaipNetwork[];
+        getActiveNetwork: () => CaipNetwork | undefined;
+    };
+    type GetWalletsParams = {
+        requestedChains: CaipNetwork[];
+        getActiveNetwork: ConstructorParams['getActiveNetwork'];
+    };
+}

package/dist/types/src/connectors/WalletStandardConnector.d.ts

@@ -0,0 +1,39 @@
+import type { BitcoinConnector } from '../utils/BitcoinConnector.js';
+import type { Wallet } from '@wallet-standard/base';
+import type { CaipNetwork } from '@reown/appkit-common';
+import type { Provider, RequestArguments } from '@reown/appkit-core';
+import { ProviderEventEmitter } from '../utils/ProviderEventEmitter.js';
+export declare class WalletStandardConnector extends ProviderEventEmitter implements BitcoinConnector {
+    readonly chain = "bip122";
+    readonly type = "ANNOUNCED";
+    readonly provider: Provider;
+    readonly wallet: Wallet;
+    private requestedChains;
+    private walletUnsubscribes;
+    constructor({ wallet, requestedChains }: WalletStandardConnector.ConstructorParams);
+    get id(): string;
+    get name(): string;
+    get imageUrl(): string;
+    get chains(): CaipNetwork[];
+    connect(): Promise<string>;
+    getAccountAddresses(): Promise<BitcoinConnector.AccountAddress[]>;
+    signMessage(params: BitcoinConnector.SignMessageParams): Promise<string>;
+    signPSBT(params: BitcoinConnector.SignPSBTParams): Promise<BitcoinConnector.SignPSBTResponse>;
+    sendTransfer(_params: BitcoinConnector.SendTransferParams): Promise<string>;
+    disconnect(): Promise<void>;
+    request<T>(_args: RequestArguments): Promise<T>;
+    private getWalletFeature;
+    private bindEvents;
+    private unbindEvents;
+    static watchWallets({ callback, requestedChains }: WalletStandardConnector.WatchWalletsParams): () => void;
+}
+export declare namespace WalletStandardConnector {
+    type ConstructorParams = {
+        wallet: Wallet;
+        requestedChains: CaipNetwork[];
+    };
+    type WatchWalletsParams = {
+        callback: (...connectors: WalletStandardConnector[]) => void;
+        requestedChains: CaipNetwork[];
+    };
+}

package/dist/types/src/errors/MethodNotSupportedError.d.ts

@@ -0,0 +1,6 @@
+export declare class MethodNotSupportedError extends Error {
+    name: string;
+    readonly method: string;
+    readonly walletId: string;
+    constructor(walletId: string, method: string, log?: string);
+}

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

@@ -0,0 +1,2 @@
+export * from './adapter.js';
+export * from './utils/BitcoinConnector.js';

package/dist/types/src/utils/BitcoinApi.d.ts

@@ -0,0 +1,22 @@
+import type { CaipNetwork } from '@reown/appkit-common';
+export declare const BitcoinApi: BitcoinApi.Interface;
+export declare namespace BitcoinApi {
+    type Interface = {
+        getUTXOs: (params: GetUTXOsParams) => Promise<UTXO[]>;
+    };
+    type GetUTXOsParams = {
+        network: CaipNetwork;
+        address: string;
+    };
+    type UTXO = {
+        txid: string;
+        vout: number;
+        value: number;
+        status: {
+            confirmed: boolean;
+            block_height: number;
+            block_hash: string;
+            block_time: number;
+        };
+    };
+}

package/dist/types/src/utils/BitcoinConnector.d.ts

@@ -0,0 +1,85 @@
+import type { ChainAdapterConnector } from '../../../../appkit/dist/types/src/adapters/ChainAdapterConnector.js';
+import type { Provider } from '@reown/appkit-core';
+/**
+ * This is the interface for a Bitcoin connector.
+ */
+export interface BitcoinConnector extends ChainAdapterConnector, Provider {
+    getAccountAddresses(): Promise<BitcoinConnector.AccountAddress[]>;
+    signMessage(params: BitcoinConnector.SignMessageParams): Promise<string>;
+    sendTransfer(params: BitcoinConnector.SendTransferParams): Promise<string>;
+    signPSBT(params: BitcoinConnector.SignPSBTParams): Promise<BitcoinConnector.SignPSBTResponse>;
+}
+export declare namespace BitcoinConnector {
+    type AccountAddress = {
+        /**
+         * Public address belonging to the account.
+         */
+        address: string;
+        /**
+         * Public key for the derivation path in hex, without 0x prefix
+         */
+        publicKey?: string;
+        /**
+         * The derivation path of the address e.g. "m/84'/0'/0'/0/0"
+         */
+        path?: string;
+        /**
+         * The purpose of the address
+         */
+        purpose: 'payment' | 'ordinal' | 'stx';
+    };
+    type SignMessageParams = {
+        /**
+         * The message to be signed
+         */
+        message: string;
+        /**
+         * The address to sign the message with
+         */
+        address: string;
+    };
+    type SendTransferParams = {
+        /**
+         * The amount to be sent in satoshis
+         */
+        amount: string;
+        /**
+         * The address to send the transfer to
+         */
+        recipient: string;
+    };
+    type SignPSBTParams = {
+        /**
+         * The PSBT to be signed, string base64 encoded
+         */
+        psbt: string;
+        signInputs: {
+            /**
+             * The address whose private key to use for signing.
+             */
+            address: string;
+            /**
+             * Specifies which input to sign
+             */
+            index: number;
+            /**
+             * Specifies which part(s) of the transaction the signature commits to
+             */
+            sighashTypes: number[];
+        }[];
+        /**
+         * If `true`, the PSBT will be broadcasted after signing. Default is `false`.
+         */
+        broadcast?: boolean;
+    };
+    type SignPSBTResponse = {
+        /**
+         * The signed PSBT, string base64 encoded
+         */
+        psbt: string;
+        /**
+         * The `string` transaction id of the broadcasted transaction or `undefined` if not broadcasted
+         */
+        txid?: string;
+    };
+}

package/dist/types/src/utils/ProviderEventEmitter.d.ts

@@ -0,0 +1,11 @@
+import type { ProviderEventListener, Provider } from '@reown/appkit-core';
+type ProviderEventEmitterMethods = Pick<Provider, 'on' | 'removeListener' | 'emit'>;
+type Events = keyof ProviderEventListener;
+type Listener<Event extends Events> = ProviderEventListener[Event];
+export declare class ProviderEventEmitter implements ProviderEventEmitterMethods {
+    private listeners;
+    on<Event extends Events>(event: Event, listener: Listener<Event>): void;
+    removeListener<T>(event: string, listener: (data: T) => void): void;
+    emit(event: string, data?: unknown): void;
+}
+export {};

package/dist/types/src/utils/UnitsUtil.d.ts

@@ -0,0 +1,4 @@
+import type { CaipNetwork } from '@reown/appkit-common';
+export declare const UnitsUtil: {
+    parseSatoshis(amount: string, network: CaipNetwork): string;
+};

package/dist/types/src/utils/WalletConnectProvider.d.ts

@@ -0,0 +1,90 @@
+import UniversalProvider from '@walletconnect/universal-provider';
+import type { CaipNetwork } from '@reown/appkit-common';
+import { type RequestArguments } from '@reown/appkit';
+import type { BitcoinConnector } from './BitcoinConnector.js';
+import { ProviderEventEmitter } from './ProviderEventEmitter.js';
+export type WalletConnectProviderConfig = {
+    provider: UniversalProvider;
+    chains: CaipNetwork[];
+    getActiveChain: () => CaipNetwork | undefined;
+};
+export declare class WalletConnectProvider extends ProviderEventEmitter implements BitcoinConnector {
+    readonly id = "WalletConnect";
+    readonly name = "WalletConnect";
+    readonly type = "WALLET_CONNECT";
+    readonly chain = "bip122";
+    readonly icon = "https://imagedelivery.net/_aTEfDRm7z3tKgu9JhfeKA/05338e12-4f75-4982-4e8a-83c67b826b00/md";
+    provider: UniversalProvider;
+    private readonly requestedChains;
+    private readonly getActiveChain;
+    constructor({ provider, chains, getActiveChain }: WalletConnectProviderConfig);
+    get chains(): CaipNetwork[];
+    connect(): Promise<never>;
+    disconnect(): Promise<void>;
+    signMessage({ message, address }: BitcoinConnector.SignMessageParams): Promise<string>;
+    sendTransfer({ recipient, amount }: BitcoinConnector.SendTransferParams): Promise<string>;
+    getAccountAddresses(): Promise<BitcoinConnector.AccountAddress[]>;
+    signPSBT(params: BitcoinConnector.SignPSBTParams): Promise<BitcoinConnector.SignPSBTResponse>;
+    request<T>(args: RequestArguments): T;
+    private get sessionChains();
+    private getAccount;
+    private checkIfMethodIsSupported;
+    private internalRequest;
+}
+export declare namespace WalletConnectProvider {
+    type Request<Params, Result> = {
+        params: Params;
+        returns: Result;
+    };
+    type WCSignMessageParams = {
+        message: string;
+        account: string;
+        address: string;
+    };
+    type WCSignMessageResponse = {
+        signature: string;
+        address: string;
+        messageHash: string;
+    };
+    type WCSendTransferParams = {
+        account: string;
+        recipientAddress: string;
+        amount: string;
+        changeAddress?: string;
+        memo?: string;
+    };
+    type WCGetAccountAddressesResponse = {
+        address: string;
+        publicKey: Uint8Array;
+        path: string;
+        intention: 'payment' | 'ordinal';
+    }[];
+    type WCSendTransferResponse = {
+        txid: string;
+    };
+    type WCSignPSBTParams = {
+        account: string;
+        psbt: string;
+        signInputs: {
+            address: string;
+            index: number;
+            sighashTypes?: number[];
+        }[];
+        broadcast?: boolean;
+    };
+    type WCSignPSBTResponse = {
+        psbt: string;
+        txid?: string;
+    };
+    type RequestMethods = {
+        signMessage: Request<WCSignMessageParams, WCSignMessageResponse>;
+        sendTransfer: Request<WCSendTransferParams, WCSendTransferResponse>;
+        getAccountAddresses: Request<undefined, string[]>;
+        signPsbt: Request<WCSignPSBTParams, WCSignPSBTResponse>;
+    };
+    type RequestMethod = keyof RequestMethods;
+    type InternalRequestParams<Method extends RequestMethod> = {
+        method: Method;
+        params: RequestMethods[Method]['params'];
+    };
+}

package/dist/types/src/utils/wallet-standard/SignMessage.d.ts

@@ -0,0 +1,64 @@
+import type { WalletAccount } from '@wallet-standard/base';
+/**
+ * This should be in the package `@exodus/bitcoin-wallet-standard`, but as it is outdated we have it here.
+ * References to https://github.com/ExodusMovement/bitcoin-wallet-standard/blob/master/packages/core/features/src/signMessage.ts
+ */
+/** Name of the feature. */
+export declare const BitcoinSignMessage = "bitcoin:signMessage";
+/**
+ * `bitcoin:signMessage` is a {@link "@wallet-standard/base".Wallet.features | feature} that may be implemented by a
+ * {@link "@wallet-standard/base".Wallet} to allow the app to request to sign a message with the specified
+ * {@link "@wallet-standard/base".Wallet.accounts | account}.
+ *
+ * The wallet should prefix the message to be signed to avoid signing a valid transaction.
+ * For an example of the prefix (and hashing algorithm), see:
+ * https://github.com/bitcoinjs/bitcoinjs-message/blob/c43430f4c03c292c719e7801e425d887cbdf7464/index.js#L57.
+ *
+ * @group SignMessage
+ */
+export type BitcoinSignMessageFeature = {
+    /** Name of the feature. */
+    readonly [BitcoinSignMessage]: {
+        /** Version of the feature implemented by the Wallet. */
+        readonly version: BitcoinSignMessageVersion;
+        /** Method to call to use the feature. */
+        readonly signMessage: BitcoinSignMessageMethod;
+    };
+};
+/**
+ * Version of the {@link BitcoinSignMessageFeature} implemented by a {@link "@wallet-standard/base".Wallet}.
+ *
+ * @group SignMessage
+ */
+export type BitcoinSignMessageVersion = '1.0.0';
+/**
+ * Method to call to use the {@link BitcoinSignMessageFeature}.
+ *
+ * @group SignMessage
+ */
+export type BitcoinSignMessageMethod = (...inputs: readonly BitcoinSignMessageInput[]) => Promise<readonly BitcoinSignMessageOutput[]>;
+/**
+ * Input for the {@link BitcoinSignMessageMethod}.
+ *
+ * @group SignMessage
+ */
+export interface BitcoinSignMessageInput {
+    /** Account to use. */
+    readonly account: WalletAccount;
+    /** Message to sign, as raw bytes. */
+    readonly message: Uint8Array;
+}
+/**
+ * Output of the {@link BitcoinSignMessageMethod}.
+ *
+ * @group SignMessage
+ */
+export interface BitcoinSignMessageOutput {
+    /**
+     * Message bytes that were signed.
+     * The wallet may prefix or otherwise modify the message before signing it.
+     */
+    readonly signedMessage: Uint8Array;
+    /** Message signature produced. */
+    readonly signature: Uint8Array;
+}

package/dist/types/src/utils/wallet-standard/SignTransaction.d.ts

@@ -0,0 +1,72 @@
+import type { IdentifierString, WalletAccount } from '@wallet-standard/base';
+/**
+ * This should be in the package `@exodus/bitcoin-wallet-standard`, but as it is outdated we have it here.
+ * References to https://github.com/ExodusMovement/bitcoin-wallet-standard/blob/master/packages/core/features/src/signTransaction.ts
+ */
+/** Name of the feature. */
+export declare const BitcoinSignTransaction = "bitcoin:signTransaction";
+/**
+ * `bitcoin:signTransaction` is a {@link "@wallet-standard/base".Wallet.features | feature} that may be implemented by a
+ * {@link "@wallet-standard/base".Wallet} to allow the app to request to sign transactions with the specified
+ * {@link "@wallet-standard/base".Wallet.accounts}.
+ *
+ * @group SignTransaction
+ */
+export type BitcoinSignTransactionFeature = {
+    /** Name of the feature. */
+    readonly [BitcoinSignTransaction]: {
+        /** Version of the feature implemented by the Wallet. */
+        readonly version: BitcoinSignTransactionVersion;
+        /** Method to call to use the feature. */
+        readonly signTransaction: BitcoinSignTransactionMethod;
+    };
+};
+/**
+ * Version of the {@link BitcoinSignTransactionFeature} implemented by a {@link "@wallet-standard/base".Wallet}.
+ *
+ * @group SignTransaction
+ */
+export type BitcoinSignTransactionVersion = '1.0.0';
+/**
+ * Method to call to use the {@link BitcoinSignTransactionFeature}.
+ *
+ * @group SignTransaction
+ */
+export type BitcoinSignTransactionMethod = (...inputs: readonly BitcoinSignTransactionInput[]) => Promise<readonly BitcoinSignTransactionOutput[]>;
+/**
+ * Input for the {@link BitcoinSignTransactionMethod}.
+ *
+ * @group SignTransaction
+ */
+export interface BitcoinSignTransactionInput {
+    /** Partially Signed Bitcoin Transaction (PSBT), as raw bytes. */
+    readonly psbt: Uint8Array;
+    /** Transaction inputs to sign. */
+    readonly inputsToSign: InputToSign[];
+    /** Chain to use. */
+    readonly chain?: IdentifierString;
+}
+/**
+ * Transaction input to be signed with the specified {@link "@wallet-standard/base".WalletAccount | account}.
+ *
+ * @group SignTransaction
+ */
+export interface InputToSign {
+    /** Account to use. */
+    readonly account: WalletAccount;
+    /** List of input indexes that should be signed by the account. */
+    readonly signingIndexes: number[];
+    /** A SIGHASH flag. */
+    readonly sigHash?: BitcoinSigHashFlag;
+}
+/**
+ * Output of the {@link BitcoinSignTransactionMethod}.
+ *
+ * @group SignTransaction
+ */
+export interface BitcoinSignTransactionOutput {
+    /** Signed Partially Signed Bitcoin Transaction (PSBT), as raw bytes. */
+    readonly signedPsbt: Uint8Array;
+}
+/** SIGHASH flag. */
+export type BitcoinSigHashFlag = 'ALL' | 'NONE' | 'SINGLE' | 'ALL|ANYONECANPAY' | 'NONE|ANYONECANPAY' | 'SINGLE|ANYONECANPAY';

package/dist/types/src/utils/wallet-standard/WalletFeatures.d.ts

@@ -0,0 +1,9 @@
+import type { WalletWithFeatures } from '@wallet-standard/base';
+import type { BitcoinConnectFeature } from '@exodus/bitcoin-wallet-standard';
+import type { BitcoinSignTransactionFeature } from './SignTransaction.js';
+import type { BitcoinSignMessageFeature } from './SignMessage.js';
+import type { StandardEventsFeature } from '@wallet-standard/features';
+/** Type of all Bitcoin features. */
+export type BitcoinFeatures = BitcoinConnectFeature & BitcoinSignTransactionFeature & BitcoinSignMessageFeature & StandardEventsFeature;
+/** Wallet with Bitcoin features. */
+export type WalletWithBitcoinFeatures = WalletWithFeatures<BitcoinFeatures>;

package/dist/types/tests/BitcoinAdapter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/connectors/LeatherConnector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/connectors/OKXConnector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/connectors/SatsConnectConnector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/connectors/WalletStandardConnector.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/mocks/mockSatsConnect.d.ts

@@ -0,0 +1,22 @@
+import type { Provider as SatsConnectProvider, BitcoinProvider, RpcError } from 'sats-connect';
+export declare function mockSatsConnectProvider(replaces?: Partial<SatsConnectProvider>): {
+    provider: SatsConnectProvider;
+    wallet: BitcoinProvider;
+};
+export declare namespace mockSatsConnectProvider {
+    var mockRequestResolve: <T>(result: T) => {
+        id: string;
+        jsonrpc: "2.0";
+        result: T;
+    };
+    var mockRequestReject: (error?: Partial<RpcError>) => {
+        id: string;
+        jsonrpc: "2.0";
+        error: {
+            code: number;
+            message: string;
+            data?: any;
+        };
+    };
+}
+export declare function mockSatsConnectWindowProvider(id: string): BitcoinProvider;

package/dist/types/tests/mocks/mockUTXO.d.ts

@@ -0,0 +1,2 @@
+import type { BitcoinApi } from '../../src/utils/BitcoinApi.js';
+export declare function mockUTXO(replaces?: Partial<BitcoinApi.UTXO>): BitcoinApi.UTXO;

package/dist/types/tests/mocks/mockUniversalProvider.d.ts

@@ -0,0 +1,6 @@
+import type UniversalProvider from '@walletconnect/universal-provider';
+import type { SessionTypes } from '@walletconnect/types';
+export declare function mockUniversalProvider(replaces?: Partial<UniversalProvider>): UniversalProvider;
+export declare namespace mockUniversalProvider {
+    var mockSession: (replaces?: Partial<SessionTypes.Struct>) => SessionTypes.Struct;
+}

package/dist/types/tests/mocks/mockWalletStandard.d.ts

@@ -0,0 +1,7 @@
+import type { Wallet, WalletAccount } from '@wallet-standard/base';
+import type { BitcoinFeatures } from '../../src/utils/wallet-standard/WalletFeatures.js';
+export declare function mockWalletStandardProvider(replaces?: Partial<Wallet>): Wallet;
+export declare namespace mockWalletStandardProvider {
+    var mockFeatures: (replaces?: Partial<BitcoinFeatures>) => BitcoinFeatures;
+    var mockAccount: (replaces?: Partial<WalletAccount>) => WalletAccount;
+}

package/dist/types/tests/utils/BitcoinApi.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/utils/UnitsUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/tests/utils/WalletConnectProvider.test.d.ts

@@ -0,0 +1 @@
+export {};