@rango-dev/provider-ctrl 0.62.1-next.2

package/dist/signers/utxo.d.ts

@@ -0,0 +1,17 @@
+import type { Provider } from '../types.js';
+import type { GenericSigner, Transfer } from 'rango-types';
+/**
+ * One signer for all of Ctrl's UTXO chains. BTC is signed via PSBT (`sign_psbt`);
+ * LTC/DOGE/BCH use the generic `transfer` request. It receives the whole provider
+ * map and resolves the right per-chain instance per transaction.
+ */
+export declare class CustomTransferSigner implements GenericSigner<Transfer> {
+    #private;
+    private provider;
+    constructor(provider: Provider);
+    signMessage(): Promise<string>;
+    signAndSendTx(tx: Transfer): Promise<{
+        hash: string;
+    }>;
+}
+//# sourceMappingURL=utxo.d.ts.map

package/dist/signers/utxo.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utxo.d.ts","sourceRoot":"","sources":["../../src/signers/utxo.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAkB,MAAM,aAAa,CAAC;AAE5D,OAAO,KAAK,EAAE,aAAa,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAC;AAqD3D;;;;GAIG;AACH,qBAAa,oBAAqB,YAAW,aAAa,CAAC,QAAQ,CAAC;;IAClE,OAAO,CAAC,QAAQ,CAAW;gBACf,QAAQ,EAAE,QAAQ;IAIxB,WAAW,IAAI,OAAO,CAAC,MAAM,CAAC;IAI9B,aAAa,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,CAAC;QAAE,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;CAgG7D"}

package/dist/types.d.ts

@@ -0,0 +1,14 @@
+import type { ProviderAPI as EvmProviderApi } from '@hub3js/evm';
+import type { ProviderAPI as SolanaProviderApi } from '@hub3js/solana';
+import type { LegacyNetworks } from '@rango-dev/wallets-core/legacy';
+import type { ProviderAPI as UtxoProviderApi } from '@rango-dev/wallets-core/namespaces/utxo';
+export type ProviderObject = {
+    [LegacyNetworks.ETHEREUM]: EvmProviderApi;
+    [LegacyNetworks.SOLANA]: SolanaProviderApi;
+    [LegacyNetworks.BTC]: UtxoProviderApi;
+    [LegacyNetworks.LTC]: UtxoProviderApi;
+    [LegacyNetworks.DOGE]: UtxoProviderApi;
+    [LegacyNetworks.BCH]: UtxoProviderApi;
+};
+export type Provider = Map<keyof ProviderObject, ProviderObject[keyof ProviderObject]>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,IAAI,cAAc,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,IAAI,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAC;AACrE,OAAO,KAAK,EAAE,WAAW,IAAI,eAAe,EAAE,MAAM,yCAAyC,CAAC;AAE9F,MAAM,MAAM,cAAc,GAAG;IAC3B,CAAC,cAAc,CAAC,QAAQ,CAAC,EAAE,cAAc,CAAC;IAC1C,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3C,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,eAAe,CAAC;IACtC,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,eAAe,CAAC;IACtC,CAAC,cAAc,CAAC,IAAI,CAAC,EAAE,eAAe,CAAC;IACvC,CAAC,cAAc,CAAC,GAAG,CAAC,EAAE,eAAe,CAAC;CACvC,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,GAAG,CACxB,MAAM,cAAc,EACpB,cAAc,CAAC,MAAM,cAAc,CAAC,CACrC,CAAC"}

package/dist/utils.d.ts

@@ -0,0 +1,25 @@
+import type { Provider } from './types.js';
+import type { ProviderAPI as EvmProviderApi } from '@hub3js/evm';
+import type { ProviderAPI as SolanaProviderApi } from '@hub3js/solana';
+import type { CaipAccount } from '@hub3js/std/types';
+export declare function ctrl(): Provider | null;
+export declare function getInstanceOrThrow(): Provider;
+export declare function evmCtrl(): EvmProviderApi;
+export declare function solanaCtrl(): SolanaProviderApi;
+/**
+ * The EVM instance, used as the trigger source for UTXO account changes.
+ *
+ * Ctrl switches the active account across every chain at once but only signals it
+ * reliably through the EVM provider's `accountsChanged` (the UTXO providers emit an
+ * empty `{}` payload, and re-fetching them while disconnected opens a wallet popup).
+ * Returns an empty object when EVM isn't injected so the subscriber attaches safely.
+ */
+export declare function evmEventSource(): EvmProviderApi;
+/**
+ * Fetch and CAIP-format accounts across every available UTXO chain, merged into a
+ * single array. Each account encodes its own chain via its CAIP reference, so
+ * BTC/LTC/DOGE/BCH addresses coexist in one UTXO namespace. Silent while the wallet
+ * is connected (only called on connect / switch, never on disconnect).
+ */
+export declare function getAllUtxoAccounts(): Promise<CaipAccount[]>;
+//# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,KAAK,EAAE,WAAW,IAAI,cAAc,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,WAAW,IAAI,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACvE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAQrD,wBAAgB,IAAI,IAAI,QAAQ,GAAG,IAAI,CAiCtC;AAED,wBAAgB,kBAAkB,IAAI,QAAQ,CAQ7C;AAED,wBAAgB,OAAO,IAAI,cAAc,CAWxC;AAED,wBAAgB,UAAU,IAAI,iBAAiB,CAW9C;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,IAAI,cAAc,CAE/C;AAoBD;;;;;GAKG;AACH,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,WAAW,EAAE,CAAC,CAsBjE"}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@rango-dev/provider-ctrl",
+  "version": "0.62.1-next.2",
+  "license": "MIT",
+  "type": "module",
+  "source": "./src/mod.ts",
+  "main": "./dist/mod.js",
+  "exports": {
+    ".": "./dist/mod.js"
+  },
+  "typings": "dist/mod.d.ts",
+  "files": [
+    "dist",
+    "src"
+  ],
+  "scripts": {
+    "build": "node ../../scripts/build/command.mjs --path wallets/provider-ctrl --inputs src/mod.ts",
+    "ts-check": "tsc --declaration --emitDeclarationOnly -p ./tsconfig.json",
+    "clean": "rimraf dist",
+    "format": "prettier --write '{.,src}/**/*.{ts,tsx}'",
+    "lint": "eslint \"**/*.{ts,tsx}\""
+  },
+  "dependencies": {
+    "@hub3js/core": "^0.60.1",
+    "@hub3js/evm": "^0.2.1",
+    "@hub3js/solana": "^0.2.1",
+    "@hub3js/std": "^0.1.1",
+    "@rango-dev/signer-evm": "^0.42.0",
+    "@rango-dev/signer-solana": "^0.48.0",
+    "@rango-dev/wallets-core": "^0.59.1-next.1",
+    "bs58": "^5.0.0",
+    "rango-types": "^0.5.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/readme.md

@@ -0,0 +1,80 @@
+# Ctrl (formerly XDEFI)
+
+Ctrl Wallet integration for hub.  
+[Homepage](https://ctrl.xyz/) | [Docs](https://developers.ctrl.xyz/)
+
+More about implementation status can be found [here](../readme.md).
+
+## Implementation notes/limitations
+
+### Group
+
+#### ✅ EVM
+
+Supports the full EVM set Rango exposes (`evmBlockchains`), plus arbitrary EVM
+chains via `wallet_addEthereumChain` / `wallet_switchEthereumChain`. Not limited to
+a fixed list.
+
+#### ⚠️ UTXO
+
+A single UTXO namespace grouping **Bitcoin, Litecoin, Dogecoin, and Bitcoin Cash**
+(this is the only multi-chain UTXO wallet in the hub). `connect` returns the
+addresses of every available UTXO chain at once, each CAIP-encoded with its own
+`bip122` chain id.
+
+Signing differs per chain:
+
+- **Bitcoin** is signed and broadcast by the wallet via `sign_psbt` (PSBT, `broadcast: true`).
+- **Litecoin / Dogecoin / Bitcoin Cash** use the wallet's `transfer` method.
+
+#### ✅ Solana
+
+Supported. Message signing uses a custom signer because Ctrl exposes
+`signMessage(bytes)` directly (rather than the `request({ method: 'signMessage' })`
+form), then base58-encodes the signature.
+
+
+### Feature
+
+#### ⚠️ Switch Account
+
+EVM and Solana use their providers' native `accountsChanged` events.
+
+UTXO is different: Ctrl's UTXO providers emit `accountsChanged` with an **empty
+`{}` payload**, so they can't report the new account themselves, and re-fetching
+them while disconnected opens a wallet popup. Because Ctrl switches the active
+account across **all** chains at once and signals it reliably on the **EVM
+provider**, the UTXO namespace is driven off the EVM `accountsChanged`: on a switch
+(non-empty array) it re-fetches all UTXO chains; on disconnect (empty array) it
+disconnects. This means UTXO switch/disconnect detection relies on EVM being
+connected alongside UTXO — always the case in practice, since Ctrl grants all chains
+together on connect.
+
+**Known issues — Ctrl-wallet behavior, not Rango logic, and currently not worked
+around here:**
+
+- **Live switching snaps back.** Ctrl pins the dApp to the account it connected with,
+  so switching the active account in the wallet (without disconnecting first) snaps
+  back to the connected one. To use a different account you must disconnect the dApp
+  (Ctrl → Connected dApps) → switch account → reconnect.
+- **Switching to a single-namespace (private-key-imported) account is unreliable,
+  because Ctrl's UTXO providers give no usable account info and the EVM `[]` signal is
+  ambiguous (full disconnect vs. switched-to-a-non-EVM account):**
+  - **→ EVM-only account:** the BTC/UTXO namespace may stay connected (stale) instead
+    of dropping.
+  - **→ BTC-only account:** the whole wallet may disconnect instead of keeping BTC
+    connected.
+
+#### ⚠️ Disconnect
+
+A wallet-initiated disconnect is detected through the EVM provider's empty
+`accountsChanged` (see Switch Account). The UTXO providers expose no usable
+disconnect signal on their own.
+
+#### ⚠️ Cross Browser
+
+Ctrl is supported **only on Chromium-based browsers** (e.g. Chrome, Brave).
+
+---
+
+More wallet information can be found in [readme.md](../readme.md).

package/src/actions/utxo.ts

@@ -0,0 +1,32 @@
+import type { Context, FunctionWithContext } from '@hub3js/core';
+
+import { type UtxoActions } from '@rango-dev/wallets-core/namespaces/utxo';
+
+import { getAllUtxoAccounts } from '../utils.js';
+
+/**
+ * Connect the UTXO namespace across all of Ctrl's UTXO chains at once.
+ *
+ * Ctrl exposes a separate provider per chain (BTC/LTC/DOGE/BCH), and a UTXO account
+ * holds an address on each simultaneously (they're concurrent, not mutually exclusive
+ * like EVM networks). So we fetch every available chain's account and return one merged
+ * array where each entry is CAIP-encoded with its own `bip122` chain id — letting the
+ * single UTXO namespace represent all four chains. Throws only if no chain returns an
+ * address.
+ */
+export function connect(): FunctionWithContext<
+  UtxoActions['connect'],
+  Context
+> {
+  return async () => {
+    const accounts = await getAllUtxoAccounts();
+
+    if (!accounts.length) {
+      throw new Error("Couldn't find any address!");
+    }
+
+    return accounts;
+  };
+}
+
+export const utxoActions = { connect };

package/src/builders/utxo.ts

@@ -0,0 +1,46 @@
+import type { ProviderAPI as EvmProviderApi } from '@hub3js/evm';
+
+import { ActionBuilder } from '@hub3js/core';
+import { ChangeAccountSubscriberBuilder } from '@hub3js/std/hooks';
+import { type UtxoActions } from '@rango-dev/wallets-core/namespaces/utxo';
+
+import { getAllUtxoAccounts } from '../utils.js';
+
+/**
+ * Ctrl switches the active account across all chains at once, but its UTXO providers
+ * emit an empty `accountsChanged` payload (`{}`) and re-fetching them while
+ * disconnected opens a wallet popup — so they can't drive the update themselves. The
+ * EVM provider, however, emits a proper `accountsChanged`: a non-empty array on
+ * switch and an empty array on disconnect. We therefore drive UTXO off the EVM
+ * signal: re-fetch all UTXO chains on a switch (silent while connected), and
+ * disconnect WITHOUT re-fetching (so no popup) when EVM reports empty.
+ */
+export const changeAccountSubscriber = (
+  getInstance: () => EvmProviderApi
+): ChangeAccountSubscriberBuilder<string[], EvmProviderApi, UtxoActions> =>
+  new ChangeAccountSubscriberBuilder<string[], EvmProviderApi, UtxoActions>()
+    .getInstance(getInstance)
+    .onSwitchAccount((event, context) => {
+      if (!event.payload?.length) {
+        context.action('disconnect');
+        event.preventDefault();
+      }
+    })
+    .format(async () => getAllUtxoAccounts())
+    .addEventListener((instance, callback) => {
+      instance.on?.('accountsChanged', callback);
+    })
+    .removeEventListener((instance, callback) => {
+      instance.removeListener?.('accountsChanged', callback);
+    });
+
+function canEagerConnect() {
+  return new ActionBuilder<UtxoActions, 'canEagerConnect'>(
+    'canEagerConnect'
+  ).action(async () => {
+    const accounts = await getAllUtxoAccounts().catch(() => []);
+    return accounts.length > 0;
+  });
+}
+
+export const utxoBuilders = { changeAccountSubscriber, canEagerConnect };

package/src/constants.ts

@@ -0,0 +1,84 @@
+import type { ProviderMetadata } from '@hub3js/core';
+
+import { LegacyNetworks } from '@rango-dev/wallets-core/legacy';
+import {
+  CAIP_BITCOIN_CHAIN_ID,
+  CAIP_BITCOINCASH_CHAIN_ID,
+  CAIP_DOGECOIN_CHAIN_ID,
+  CAIP_LITECOIN_CHAIN_ID,
+} from '@rango-dev/wallets-core/namespaces/utxo';
+import {
+  type BlockchainMeta,
+  evmBlockchains,
+  solanaBlockchain,
+  type TransferBlockchainMeta,
+} from 'rango-types';
+
+import getSigners from './signer.js';
+import { getInstanceOrThrow } from './utils.js';
+
+export const WALLET_ID = 'ctrl';
+
+/**
+ * The UTXO chains Ctrl exposes, grouped under the single UTXO namespace, each paired
+ * with its CAIP-2 (bip122) reference so accounts can be self-describing.
+ */
+export const UTXO_CHAINS = [
+  { network: LegacyNetworks.BTC, caip: CAIP_BITCOIN_CHAIN_ID },
+  { network: LegacyNetworks.LTC, caip: CAIP_LITECOIN_CHAIN_ID },
+  { network: LegacyNetworks.DOGE, caip: CAIP_DOGECOIN_CHAIN_ID },
+  { network: LegacyNetworks.BCH, caip: CAIP_BITCOINCASH_CHAIN_ID },
+] as const;
+
+export const SUPPORTED_UTXO_CHAINS: string[] = UTXO_CHAINS.map(
+  (chain) => chain.network
+);
+
+export const metadata: ProviderMetadata = {
+  name: 'Ctrl',
+  icon: 'https://raw.githubusercontent.com/rango-exchange/assets/main/wallets/xdefi/icon.svg',
+  extensions: {
+    chrome:
+      'https://chromewebstore.google.com/detail/ctrl-wallet/hmeobnfnfcmdkdcmlblgagmfpfboieaf',
+    brave:
+      'https://chromewebstore.google.com/detail/ctrl-wallet/hmeobnfnfcmdkdcmlblgagmfpfboieaf',
+    homepage: 'https://ctrl.xyz/',
+  },
+  properties: [
+    {
+      name: 'namespaces',
+      value: {
+        selection: 'multiple',
+        data: [
+          {
+            label: 'EVM',
+            value: 'EVM',
+            id: 'ETH',
+            getSupportedChains: (allBlockchains: BlockchainMeta[]) =>
+              evmBlockchains(allBlockchains),
+          },
+          {
+            label: 'UTXO',
+            value: 'UTXO',
+            id: 'BTC',
+            getSupportedChains: (allBlockchains: BlockchainMeta[]) =>
+              allBlockchains.filter((chain): chain is TransferBlockchainMeta =>
+                SUPPORTED_UTXO_CHAINS.includes(chain.name)
+              ),
+          },
+          {
+            label: 'Solana',
+            value: 'Solana',
+            id: 'SOLANA',
+            getSupportedChains: (allBlockchains: BlockchainMeta[]) =>
+              solanaBlockchain(allBlockchains),
+          },
+        ],
+      },
+    },
+    {
+      name: 'signers',
+      value: { getSigners: async () => getSigners(getInstanceOrThrow()) },
+    },
+  ],
+};

package/src/mod.ts

@@ -0,0 +1,8 @@
+import { defineVersions } from '@hub3js/core/utils';
+
+import { buildProvider } from './provider.js';
+
+const versions = () =>
+  defineVersions().version('1.0.0', buildProvider()).build();
+
+export { versions };

package/src/namespaces/evm.ts

@@ -0,0 +1,50 @@
+import type { EvmActions } from '@hub3js/evm';
+
+import { NamespaceBuilder } from '@hub3js/core';
+import { actions, builders, hooks } from '@hub3js/evm';
+import * as commonBuilders from '@hub3js/std/builders';
+import { standardizeAndThrowError } from '@hub3js/std/operators';
+
+import { WALLET_ID } from '../constants.js';
+import { evmCtrl } from '../utils.js';
+
+const [changeAccountSubscriber, changeAccountCleanup] =
+  hooks.changeAccountSubscriber(evmCtrl);
+
+const connect = builders
+  .connect()
+  .action(actions.connect(evmCtrl))
+  .before(changeAccountSubscriber)
+  .or(changeAccountCleanup)
+  .or(standardizeAndThrowError)
+  .build();
+
+const disconnect = commonBuilders
+  .disconnect<EvmActions>()
+  .after(changeAccountCleanup)
+  .build();
+
+const canSwitchNetwork = builders
+  .canSwitchNetwork()
+  .action(actions.canSwitchNetwork())
+  .build();
+
+const canEagerConnect = builders
+  .canEagerConnect()
+  .action(actions.canEagerConnect(evmCtrl))
+  .build();
+
+const getChainId = builders
+  .getChainId()
+  .action(actions.getChainId(evmCtrl))
+  .build();
+
+const evm = new NamespaceBuilder<EvmActions>('EVM', WALLET_ID)
+  .action(connect)
+  .action(disconnect)
+  .action(canEagerConnect)
+  .action(canSwitchNetwork)
+  .action(getChainId)
+  .build();
+
+export { evm };

package/src/namespaces/solana.ts

@@ -0,0 +1,39 @@
+import type { SolanaActions } from '@hub3js/solana';
+
+import { ActionBuilder, NamespaceBuilder } from '@hub3js/core';
+import { actions, builders, hooks } from '@hub3js/solana';
+import * as commonBuilders from '@hub3js/std/builders';
+import { standardizeAndThrowError } from '@hub3js/std/operators';
+
+import { WALLET_ID } from '../constants.js';
+import { solanaCtrl } from '../utils.js';
+
+const [changeAccountSubscriber, changeAccountCleanup] =
+  hooks.changeAccountSubscriber(solanaCtrl);
+
+const connect = builders
+  .connect()
+  .action(actions.connect(solanaCtrl))
+  .before(changeAccountSubscriber)
+  .or(changeAccountCleanup)
+  .or(standardizeAndThrowError)
+  .build();
+
+const disconnect = commonBuilders
+  .disconnect<SolanaActions>()
+  .after(changeAccountCleanup)
+  .build();
+
+const canEagerConnect = new ActionBuilder<SolanaActions, 'canEagerConnect'>(
+  'canEagerConnect'
+)
+  .action(actions.canEagerConnect(solanaCtrl))
+  .build();
+
+const solana = new NamespaceBuilder<SolanaActions>('Solana', WALLET_ID)
+  .action(connect)
+  .action(disconnect)
+  .action(canEagerConnect)
+  .build();
+
+export { solana };

package/src/namespaces/utxo.ts

@@ -0,0 +1,44 @@
+import type { UtxoActions } from '@rango-dev/wallets-core/namespaces/utxo';
+
+import { NamespaceBuilder } from '@hub3js/core';
+import * as commonBuilders from '@hub3js/std/builders';
+import { standardizeAndThrowError } from '@hub3js/std/operators';
+import { builders } from '@rango-dev/wallets-core/namespaces/utxo';
+
+import { utxoActions } from '../actions/utxo.js';
+import { utxoBuilders } from '../builders/utxo.js';
+import { WALLET_ID } from '../constants.js';
+import { evmEventSource } from '../utils.js';
+
+/*
+ * UTXO account changes are driven by the EVM provider's `accountsChanged` (see
+ * builders/utxo.ts) because Ctrl's UTXO providers emit no usable payload. One
+ * subscriber, listening on the EVM instance, re-fetches all UTXO chains on a switch
+ * and disconnects on empty.
+ */
+const [changeAccountSubscriber, changeAccountCleanup] = utxoBuilders
+  .changeAccountSubscriber(evmEventSource)
+  .build();
+
+const connect = builders
+  .connect()
+  .action(utxoActions.connect())
+  .before(changeAccountSubscriber)
+  .or(changeAccountCleanup)
+  .or(standardizeAndThrowError)
+  .build();
+
+const disconnect = commonBuilders
+  .disconnect<UtxoActions>()
+  .after(changeAccountCleanup)
+  .build();
+
+const canEagerConnect = utxoBuilders.canEagerConnect().build();
+
+const utxo = new NamespaceBuilder<UtxoActions>('UTXO', WALLET_ID)
+  .action(connect)
+  .action(disconnect)
+  .action(canEagerConnect)
+  .build();
+
+export { utxo };

package/src/provider.ts

@@ -0,0 +1,24 @@
+import { ProviderBuilder } from '@hub3js/core';
+
+import { metadata, WALLET_ID } from './constants.js';
+import { evm } from './namespaces/evm.js';
+import { solana } from './namespaces/solana.js';
+import { utxo } from './namespaces/utxo.js';
+import { ctrl as ctrlInstance } from './utils.js';
+
+const buildProvider = () =>
+  new ProviderBuilder(WALLET_ID)
+    .init(function (context) {
+      const [, setState] = context.state();
+      if (ctrlInstance()) {
+        setState('installed', true);
+        console.debug('[ctrl] instance detected.', context);
+      }
+    })
+    .config('metadata', metadata)
+    .add('evm', evm)
+    .add('utxo', utxo)
+    .add('solana', solana)
+    .build();
+
+export { buildProvider };

package/src/signer.ts

@@ -0,0 +1,28 @@
+import type { Provider } from './types.js';
+import type { ProviderAPI as EvmProviderApi } from '@hub3js/evm';
+import type { SolanaExternalProvider } from '@rango-dev/signer-solana';
+import type { SignerFactory } from 'rango-types';
+
+import { LegacyNetworks } from '@rango-dev/wallets-core/legacy';
+import { DefaultSignerFactory, TransactionType as TxType } from 'rango-types';
+
+import { CustomSolanaSigner } from './signers/solana.js';
+import { CustomTransferSigner } from './signers/utxo.js';
+
+export default async function getSigners(
+  provider: Provider
+): Promise<SignerFactory> {
+  const ethProvider = provider.get(LegacyNetworks.ETHEREUM) as EvmProviderApi;
+  const solProvider = provider.get(
+    LegacyNetworks.SOLANA
+  ) as SolanaExternalProvider;
+
+  const signers = new DefaultSignerFactory();
+  const { DefaultEvmSigner } = await import('@rango-dev/signer-evm');
+
+  signers.registerSigner(TxType.EVM, new DefaultEvmSigner(ethProvider));
+  signers.registerSigner(TxType.SOLANA, new CustomSolanaSigner(solProvider));
+  // the transfer signer comprises several UTXO chains, so it gets the whole map
+  signers.registerSigner(TxType.TRANSFER, new CustomTransferSigner(provider));
+  return signers;
+}

package/src/signers/solana.ts

@@ -0,0 +1,22 @@
+import type { SolanaExternalProvider } from '@rango-dev/signer-solana';
+
+import { DefaultSolanaSigner } from '@rango-dev/signer-solana';
+import base58 from 'bs58';
+
+/**
+ * Ctrl's Solana provider signs messages via a direct `signMessage(bytes)` call
+ * (the standard wallet-adapter shape). `DefaultSolanaSigner` signs through
+ * `request({ method: 'signMessage' })`, which Ctrl does not support, so we keep the
+ * direct call and inherit everything else (incl. base58 output and `signAndSendTx`).
+ */
+export class CustomSolanaSigner extends DefaultSolanaSigner {
+  constructor(provider: SolanaExternalProvider) {
+    super(provider);
+  }
+
+  async signMessage(msg: string): Promise<string> {
+    const encodedMessage = new TextEncoder().encode(msg);
+    const { signature } = await this.provider.signMessage(encodedMessage);
+    return base58.encode(signature);
+  }
+}