@rango-dev/provider-phantom 0.0.0-experimental-936229e8-20251208

package/src/provider.ts

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

package/src/signer.ts

@@ -0,0 +1,43 @@
+import type { Provider } from './utils.js';
+import type { SignerFactory } from 'rango-types';
+
+import { LegacyNetworks as Networks } from '@rango-dev/wallets-core/legacy';
+import { getInstance as getSuiInstance } from '@rango-dev/wallets-core/namespaces/sui';
+import {
+  dynamicImportWithRefinedError,
+  getNetworkInstance,
+} from '@rango-dev/wallets-shared';
+import { DefaultSignerFactory, TransactionType as TxType } from 'rango-types';
+
+import { WALLET_NAME_IN_WALLET_STANDARD } from './constants.js';
+
+export default async function getSigners(
+  provider: Provider
+): Promise<SignerFactory> {
+  const solProvider = getNetworkInstance(provider, Networks.SOLANA);
+  const evmProvider = getNetworkInstance(provider, Networks.ETHEREUM);
+  const bitcoinInstance = getNetworkInstance(provider, Networks.BTC);
+
+  const suiProvider = getSuiInstance(WALLET_NAME_IN_WALLET_STANDARD);
+
+  const { DefaultEvmSigner } = await dynamicImportWithRefinedError(
+    async () => await import('@rango-dev/signer-evm')
+  );
+  const { DefaultSolanaSigner } = await dynamicImportWithRefinedError(
+    async () => await import('@rango-dev/signer-solana')
+  );
+  const { BTCSigner } = await dynamicImportWithRefinedError(
+    async () => await import('./signers/utxoSigner.js')
+  );
+  const { DefaultSuiSigner } = await dynamicImportWithRefinedError(
+    async () => await import('@rango-dev/signer-sui')
+  );
+  const signers = new DefaultSignerFactory();
+  signers.registerSigner(TxType.SOLANA, new DefaultSolanaSigner(solProvider));
+  signers.registerSigner(TxType.EVM, new DefaultEvmSigner(evmProvider));
+  signers.registerSigner(TxType.TRANSFER, new BTCSigner(bitcoinInstance));
+  if (!!suiProvider) {
+    signers.registerSigner(TxType.SUI, new DefaultSuiSigner(suiProvider));
+  }
+  return signers;
+}

package/src/signers/utxoSigner.ts

@@ -0,0 +1,92 @@
+import type { GenericSigner, Transfer } from 'rango-types';
+
+import * as secp256k1 from '@bitcoinerlab/secp256k1';
+import { Networks } from '@rango-dev/wallets-shared';
+import * as bitcoin from 'bitcoinjs-lib';
+import { SignerError } from 'rango-types';
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type TransferExternalProvider = any;
+
+const BTC_RPC_URL = 'https://go.getblock.io/f37bad28a991436483c0a3679a3acbee';
+
+// TODO: use Uint8Array.fromBase64() static method and use this function as a polyfill after updating TypeScript DOM lib
+function base64ToUint8Array(base64String: string) {
+  const binaryString = atob(base64String);
+  const length = binaryString.length;
+  const uint8Array = new Uint8Array(length);
+
+  for (let i = 0; i < length; i++) {
+    uint8Array[i] = binaryString.charCodeAt(i);
+  }
+
+  return uint8Array;
+}
+
+export class BTCSigner implements GenericSigner<Transfer> {
+  private provider: TransferExternalProvider;
+  constructor(provider: TransferExternalProvider) {
+    this.provider = provider;
+  }
+
+  async signMessage(): Promise<string> {
+    throw SignerError.UnimplementedError('signMessage');
+  }
+
+  async signAndSendTx(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.'
+      );
+    }
+
+    if (asset.blockchain !== Networks.BTC) {
+      throw new Error(
+        `Signing ${asset.blockchain} transaction is not implemented by the signer.`
+      );
+    }
+    // Initialize ECC library
+    bitcoin.initEccLib(secp256k1);
+
+    const signedPSBTBytes = await this.provider.signPSBT(
+      base64ToUint8Array(psbt.unsignedPsbtBase64),
+      {
+        inputsToSign: psbt.inputsToSign,
+      }
+    );
+
+    // Finalize PSBT
+    const finalPsbt = bitcoin.Psbt.fromBuffer(Buffer.from(signedPSBTBytes));
+    finalPsbt.finalizeAllInputs();
+
+    const finalPsbtBaseHex = finalPsbt.extractTransaction().toHex();
+
+    // Broadcast PSBT to rpc node
+    const response = await fetch(BTC_RPC_URL, {
+      method: 'POST',
+      body: JSON.stringify({
+        method: 'sendrawtransaction',
+        params: [finalPsbtBaseHex],
+      }),
+    });
+
+    if (!response.ok) {
+      // Handle network and fetch errors
+      const errorText = await response.text();
+      throw new Error(`Error broadcasting transaction: ${errorText}`);
+    }
+
+    const data = await response.json();
+
+    if (!data.result) {
+      // Handle Bitcoin specific errors
+      throw new Error(
+        `Error broadcasting transaction. Error Code ${data.error.code}: ${data.error.message}`
+      );
+    }
+
+    return { hash: data.result };
+  }
+}

package/src/utils.ts

@@ -0,0 +1,98 @@
+import type { ProviderAPI as EvmProviderApi } from '@rango-dev/wallets-core/namespaces/evm';
+import type { ProviderAPI as SolanaProviderApi } from '@rango-dev/wallets-core/namespaces/solana';
+import type { ProviderAPI as SuiProviderApi } from '@rango-dev/wallets-core/namespaces/sui';
+
+import { LegacyNetworks } from '@rango-dev/wallets-core/legacy';
+
+export type Provider = Map<string, unknown>;
+
+export function phantom(): Provider | null {
+  const { phantom } = window;
+
+  if (!phantom) {
+    return null;
+  }
+
+  const { solana, ethereum, bitcoin, sui } = phantom;
+
+  const instances: Provider = new Map();
+
+  if (ethereum && ethereum.isPhantom) {
+    instances.set(LegacyNetworks.ETHEREUM, ethereum);
+  }
+
+  if (solana && solana.isPhantom) {
+    instances.set(LegacyNetworks.SOLANA, solana);
+  }
+
+  if (bitcoin && bitcoin.isPhantom) {
+    instances.set(LegacyNetworks.BTC, bitcoin);
+  }
+  if (sui && sui.isPhantom) {
+    instances.set(LegacyNetworks.SUI, sui);
+  }
+
+  return instances;
+}
+
+export function getInstanceOrThrow(): Provider {
+  const instances = phantom();
+
+  if (!instances) {
+    throw new Error('Phantom is not injected. Please check your wallet.');
+  }
+
+  return instances;
+}
+
+export function evmPhantom(): EvmProviderApi {
+  const instances = phantom();
+
+  const evmInstance = instances?.get(LegacyNetworks.ETHEREUM);
+
+  if (!evmInstance) {
+    throw new Error(
+      'Phantom not injected or EVM not enabled. Please check your wallet.'
+    );
+  }
+
+  return evmInstance as EvmProviderApi;
+}
+
+export function solanaPhantom(): SolanaProviderApi {
+  const instance = phantom();
+  const solanaInstance = instance?.get(LegacyNetworks.SOLANA);
+
+  if (!solanaInstance) {
+    throw new Error(
+      'Phantom not injected or Solana not enabled. Please check your wallet.'
+    );
+  }
+
+  return solanaInstance;
+}
+
+export function bitcoinPhantom(): SolanaProviderApi {
+  const instance = phantom();
+  const bitcoinInstance = instance?.get(LegacyNetworks.BTC);
+
+  if (!bitcoinInstance) {
+    throw new Error(
+      'Phantom not injected or Bitcoin not enabled. Please check your wallet.'
+    );
+  }
+
+  return bitcoinInstance;
+}
+export function suiPhantom(): SuiProviderApi {
+  const instance = phantom();
+  const suiInstance = instance?.get(LegacyNetworks.SUI);
+
+  if (!suiInstance) {
+    throw new Error(
+      'Phantom not injected or Sui not enabled. Please check your wallet.'
+    );
+  }
+
+  return suiInstance as SuiProviderApi;
+}