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

package/src/signers/utxo.ts

@@ -0,0 +1,167 @@
+import type { Provider, ProviderObject } from '../types.js';
+import type { ProviderAPI as UtxoProviderApi } from '@rango-dev/wallets-core/namespaces/utxo';
+import type { GenericSigner, Transfer } from 'rango-types';
+
+import { LegacyNetworks } from '@rango-dev/wallets-core/legacy';
+import { SignerError, SignerErrorCode } from 'rango-types';
+
+import { SUPPORTED_UTXO_CHAINS } from '../constants.js';
+
+interface CtrlTransferParams {
+  asset: { chain: string; symbol: string; ticker: string };
+  from: string;
+  amount: { amount: string; decimals: number };
+  memo?: string;
+  recipient?: string;
+}
+
+/** Callback-style transfer for non-PSBT UTXO chains (LTC/DOGE/BCH). */
+async function ctrlTransfer(
+  blockchain: string,
+  ticker: string,
+  from: string,
+  amount: string,
+  decimals: number,
+  recipientAddress: string | null,
+  provider: UtxoProviderApi,
+  method: string,
+  memo?: string
+): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const params: CtrlTransferParams = {
+      asset: { chain: blockchain, symbol: ticker, ticker },
+      from,
+      amount: { amount, decimals },
+      memo,
+    };
+    if (recipientAddress) {
+      params.recipient = recipientAddress;
+    }
+
+    provider.request(
+      { method, params: [params] },
+      (error: unknown, result: unknown) => {
+        if (error) {
+          reject(
+            new SignerError(SignerErrorCode.SEND_TX_ERROR, undefined, error)
+          );
+        } else {
+          resolve(result as string);
+        }
+      }
+    );
+  });
+}
+
+/**
+ * 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 class CustomTransferSigner implements GenericSigner<Transfer> {
+  private provider: Provider;
+  constructor(provider: Provider) {
+    this.provider = provider;
+  }
+
+  async signMessage(): Promise<string> {
+    throw SignerError.UnimplementedError('signMessage');
+  }
+
+  async signAndSendTx(tx: Transfer): Promise<{ hash: string }> {
+    const { blockchain } = tx.asset;
+
+    if (!SUPPORTED_UTXO_CHAINS.includes(blockchain)) {
+      throw new Error(
+        `blockchain: ${blockchain} transfer not implemented yet.`
+      );
+    }
+
+    if (blockchain === LegacyNetworks.BTC) {
+      return this.#signPsbt(tx);
+    }
+
+    return this.#signTransferObject(tx);
+  }
+
+  // https://developers.ctrl.xyz/developers/extension-bitcoin#sign-psbt-partially-signed-bitcoin-transaction
+  async #signPsbt(tx: Transfer): Promise<{ hash: string }> {
+    const { asset, psbt } = tx;
+
+    if (!psbt) {
+      throw new Error(
+        'No PSBT found to sign. Ensure a valid PSBT is provided.'
+      );
+    }
+
+    const provider = this.provider.get(
+      asset.blockchain as keyof ProviderObject
+    ) as UtxoProviderApi;
+
+    const signInputs: { [key: string]: number[] } = {};
+    psbt.inputsToSign.forEach((input) => {
+      signInputs[input.address] = input.signingIndexes;
+    });
+
+    const response = await provider
+      .request({
+        method: 'sign_psbt',
+        /*
+         * Ctrl expects `params` as an array (same as its other RPCs); passing a bare
+         * object makes the extension read `psbt` off `undefined`. The docs showing a
+         * plain object are wrong.
+         */
+        params: [
+          {
+            psbt: psbt.unsignedPsbtBase64,
+            signInputs,
+            allowedSignHash: 1,
+            broadcast: true,
+          },
+        ],
+      })
+      .catch((error: unknown) => {
+        throw new SignerError(SignerErrorCode.SEND_TX_ERROR, undefined, error);
+      });
+
+    if (response.status === 'success') {
+      return { hash: response.result.txId };
+    }
+
+    throw new Error(
+      'The operation (sign and broadcast) failed on your wallet.',
+      { cause: response }
+    );
+  }
+
+  async #signTransferObject(tx: Transfer): Promise<{ hash: string }> {
+    const { blockchain } = tx.asset;
+
+    const transferProvider = this.provider.get(
+      blockchain as keyof ProviderObject
+    ) as UtxoProviderApi;
+
+    const {
+      method,
+      memo,
+      recipientAddress,
+      decimals,
+      amount,
+      fromWalletAddress: from,
+      asset,
+    } = tx;
+
+    const hash = await ctrlTransfer(
+      blockchain,
+      asset.ticker,
+      from,
+      amount,
+      decimals,
+      recipientAddress,
+      transferProvider,
+      method,
+      memo ?? undefined
+    );
+    return { hash };
+  }
+}

package/src/types.ts

@@ -0,0 +1,18 @@
+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]
+>;

package/src/utils.ts

@@ -0,0 +1,141 @@
+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';
+import type { ProviderAPI as UtxoProviderApi } from '@rango-dev/wallets-core/namespaces/utxo';
+
+import { LegacyNetworks } from '@rango-dev/wallets-core/legacy';
+import { utils } from '@rango-dev/wallets-core/namespaces/utxo';
+
+import { UTXO_CHAINS } from './constants.js';
+
+export function ctrl(): Provider | null {
+  const { ctrl } = window;
+
+  if (!ctrl) {
+    return null;
+  }
+
+  const instances: Provider = new Map();
+
+  if (ctrl.ethereum) {
+    instances.set(LegacyNetworks.ETHEREUM, ctrl.ethereum);
+  }
+  if (ctrl.bitcoin) {
+    instances.set(LegacyNetworks.BTC, ctrl.bitcoin);
+  }
+  if (ctrl.litecoin) {
+    instances.set(LegacyNetworks.LTC, ctrl.litecoin);
+  }
+  if (ctrl.dogecoin) {
+    instances.set(LegacyNetworks.DOGE, ctrl.dogecoin);
+  }
+  if (ctrl.bitcoincash) {
+    instances.set(LegacyNetworks.BCH, ctrl.bitcoincash);
+  }
+  if (ctrl.solana) {
+    instances.set(LegacyNetworks.SOLANA, ctrl.solana);
+  }
+
+  if (instances.size === 0) {
+    return null;
+  }
+
+  return instances;
+}
+
+export function getInstanceOrThrow(): Provider {
+  const instances = ctrl();
+
+  if (!instances) {
+    throw new Error('Ctrl is not injected. Please check your wallet.');
+  }
+
+  return instances;
+}
+
+export function evmCtrl(): EvmProviderApi {
+  const instances = ctrl();
+  const evmInstance = instances?.get(LegacyNetworks.ETHEREUM);
+
+  if (!evmInstance) {
+    throw new Error(
+      'Ctrl not injected or EVM not enabled. Please check your wallet.'
+    );
+  }
+
+  return evmInstance as EvmProviderApi;
+}
+
+export function solanaCtrl(): SolanaProviderApi {
+  const instances = ctrl();
+  const solanaInstance = instances?.get(LegacyNetworks.SOLANA);
+
+  if (!solanaInstance) {
+    throw new Error(
+      'Ctrl not injected or Solana not enabled. Please check your wallet.'
+    );
+  }
+
+  return solanaInstance;
+}
+
+/**
+ * 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 function evmEventSource(): EvmProviderApi {
+  return (ctrl()?.get(LegacyNetworks.ETHEREUM) ?? {}) as EvmProviderApi;
+}
+
+/** Promisified `request_accounts` for a callback-style ctrl UTXO instance. */
+async function requestUtxoAccounts(
+  instance: UtxoProviderApi
+): Promise<string[]> {
+  return new Promise((resolve, reject) => {
+    instance.request(
+      { method: 'request_accounts', params: [] },
+      (error: unknown, accounts: unknown) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve((accounts as string[]) ?? []);
+      }
+    );
+  });
+}
+
+/**
+ * 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 async function getAllUtxoAccounts(): Promise<CaipAccount[]> {
+  const instances = ctrl();
+  if (!instances) {
+    return [];
+  }
+
+  /*
+   * `Promise.all` rejects as soon as any chain's `request_accounts` fails, discarding
+   * the rest and propagating that error — we don't want to silently return a partial
+   * account set if one chain errors.
+   */
+  const perChain = await Promise.all(
+    UTXO_CHAINS.filter(({ network }) => instances.get(network)).map(
+      async ({ network, caip }) => {
+        const instance = instances.get(network) as UtxoProviderApi;
+        const accounts = await requestUtxoAccounts(instance);
+        return utils.formatAccountsToCAIP(accounts, caip);
+      }
+    )
+  );
+
+  return perChain.flat();
+}