Feature/add firo network

.gitignore

@@ -119,3 +119,4 @@ dist
 
 # IDE
 .history
+.idea

README.md

@@ -121,6 +121,7 @@ Enkrypt is a web3 wallet built from the ground up to support the multi-chain fut
 - Unit Zero Testnet
 - Nibiru
 - Nibiru Testnet
+- Firo
 - More coming soon!
 
 Looking to add your project? [Contact us!](https://mewwallet.typeform.com/enkrypt-inquiry?typeform-source=www.enkrypt.com)

package.json

@@ -48,5 +48,8 @@
     "@ledgerhq/speculos-transport": "https://registry.yarnpkg.com/@favware/skip-dependency/-/skip-dependency-1.2.1.tgz",
     "@ledgerhq/ledger-key-ring-protocol": "https://registry.yarnpkg.com/@favware/skip-dependency/-/skip-dependency-1.2.1.tgz",
     "@amplitude/plugin-autocapture-browser@^1.0.2": "patch:@amplitude/plugin-autocapture-browser@npm%3A1.0.3#./.yarn/patches/@amplitude-plugin-autocapture-browser-npm-1.0.3-edb25bef55.patch"
+  },
+  "dependencies": {
+    "ecpair": "3.0.0-rc.0"
   }
 }

packages/extension/.prettierignore

@@ -0,0 +1,2 @@
+**/*.js
+**/*.d.ts

packages/extension/package.json

@@ -24,6 +24,7 @@
   },
   "dependencies": {
     "@amplitude/analytics-browser": "^2.32.0",
+    "@bitcoinerlab/secp256k1": "^1.2.0",
     "@enkryptcom/extension-bridge": "workspace:^",
     "@enkryptcom/hw-wallets": "workspace:^",
     "@enkryptcom/keyring": "workspace:^",
@@ -65,6 +66,8 @@
     "bs58": "^6.0.0",
     "concurrently": "^9.2.1",
     "echarts": "^6.0.0",
+    "ecpair": "^3.0.0",
+    "electrum-client-browser": "1.2.5",
     "ethereum-cryptography": "^2.2.1",
     "ethereumjs-abi": "^0.6.8",
     "eventemitter3": "^5.0.1",

packages/extension/src/libs/background/index.ts

@@ -1,25 +1,25 @@
+import DomainState from '@/libs/domain-state';
+import { sendToWindow } from '@/libs/messenger/extension';
+import PersistentEvents from '@/libs/persistent-events';
+import TabInfo from '@/libs/utils/tab-info';
+import Providers from '@/providers';
+import { BaseFiroWallet } from '@/providers/bitcoin/libs/firo-wallet/base-firo-wallet';
 import {
   InternalMethods,
   InternalOnMessageResponse,
   Message,
 } from '@/types/messenger';
-import { RPCRequestType, OnMessageResponse } from '@enkryptcom/types';
+import { ProviderName } from '@/types/provider';
+import { OnMessageResponse, RPCRequestType } from '@enkryptcom/types';
 import { v4 as randomUUID } from 'uuid';
+import Browser from 'webextension-polyfill';
 import { getCustomError } from '../error';
 import KeyRingBase from '../keyring/keyring';
-import { sendToWindow } from '@/libs/messenger/extension';
-import { ProviderName } from '@/types/provider';
-import Providers from '@/providers';
-import Browser from 'webextension-polyfill';
-import TabInfo from '@/libs/utils/tab-info';
-import PersistentEvents from '@/libs/persistent-events';
-import DomainState from '@/libs/domain-state';
-import { TabProviderType, ProviderType, ExternalMessageOptions } from './types';
 import { getProviderNetworkByName } from '../utils/networks';
 import {
-  sign,
-  getEthereumPubKey,
   ethereumDecrypt,
+  getEthereumPubKey,
+  sign,
   unlock,
   changeNetwork,
   sendToTab,
@@ -29,9 +29,11 @@ import {
 import { handlePersistentEvents } from './external';
 import SettingsState from '../settings-state';
 import { isGeoRestricted } from '../utils/screening';
+import { ExternalMessageOptions, ProviderType, TabProviderType } from './types';
 
 class BackgroundHandler {
   #keyring: KeyRingBase;
+  #wallet: BaseFiroWallet;
   #tabProviders: TabProviderType;
   #providers: ProviderType;
   #persistentEvents: PersistentEvents;
@@ -41,6 +43,7 @@ class BackgroundHandler {
 
   constructor() {
     this.#keyring = new KeyRingBase();
+    this.#wallet = new BaseFiroWallet();
     this.#persistentEvents = new PersistentEvents();
     this.#domainState = new DomainState();
     this.#settingsState = new SettingsState();
@@ -162,7 +165,7 @@ class BackgroundHandler {
         return response;
       });
   }
-  internalHandler(msg: Message): Promise<InternalOnMessageResponse> {
+  async internalHandler(msg: Message): Promise<InternalOnMessageResponse> {
     const message = JSON.parse(msg.message) as RPCRequestType;
     switch (message.method) {
       case InternalMethods.sign:
@@ -172,6 +175,9 @@ class BackgroundHandler {
       case InternalMethods.ethereumDecrypt:
         return ethereumDecrypt(this.#keyring, message);
       case InternalMethods.unlock:
+        const password = message?.params?.[0] as string;
+        const mnemonic = await this.#keyring.getSavedMnemonic(password);
+        this.#wallet.setSecret(mnemonic);
         return unlock(this.#keyring, message);
       case InternalMethods.lock:
         return lock(this.#keyring);

packages/extension/src/libs/keyring/keyring.ts

@@ -1,6 +1,5 @@
-import KeyRing from '@enkryptcom/keyring';
 import { InternalStorageNamespace } from '@/types/provider';
-import BrowserStorage from '../common/browser-storage';
+import KeyRing from '@enkryptcom/keyring';
 import {
   EnkryptAccount,
   HWWalletAdd,
@@ -11,6 +10,7 @@ import {
   SignOptions,
   WalletType,
 } from '@enkryptcom/types';
+import BrowserStorage from '../common/browser-storage';
 export class KeyRingBase {
   #keyring: KeyRing;
   constructor() {
@@ -70,6 +70,12 @@ export class KeyRingBase {
   getKeysObject(): Promise<{ [key: string]: EnkryptAccount }> {
     return this.#keyring.getKeysObject();
   }
+  getPrivateKey(seed: Buffer) {
+    return this.#keyring.getPrivateKey(seed);
+  }
+  getSavedMnemonic(password: string) {
+    return this.#keyring.getSavedMnemonic(password);
+  }
   addHWAccount(account: HWWalletAdd): Promise<EnkryptAccount> {
     return this.#keyring.addHWAccount(account);
   }

packages/extension/src/libs/keyring/public-keyring.ts

@@ -1,8 +1,9 @@
 import {
-  SignerType,
+  EnkryptAccount,
   Errors,
+  SignerType,
+  SignOptions,
   WalletType,
-  EnkryptAccount,
 } from '@enkryptcom/types';
 import { KeyRingBase } from './keyring';
 
@@ -145,5 +146,13 @@ class PublicKeyRing {
 
     return alreadyExists;
   }
+
+  async getPrivateKey(seed: Buffer) {
+    return this.#keyring.getPrivateKey(seed);
+  }
+
+  getSavedMnemonic(password: string) {
+    return this.#keyring.getSavedMnemonic(password);
+  }
 }
 export default PublicKeyRing;

packages/extension/src/libs/spark-handler/constants.ts

@@ -0,0 +1,3 @@
+export const SPARK_TX_TYPE = 9;
+
+export const LOCK_TIME = 999999;

packages/extension/src/libs/spark-handler/createTempFromSparkTx.ts

@@ -0,0 +1,39 @@
+import * as bitcoin from 'bitcoinjs-lib';
+import { LOCK_TIME, SPARK_TX_TYPE } from '@/libs/spark-handler/constants';
+import { isSparkAddress } from '@/providers/bitcoin/libs/utils';
+
+interface CreateTempFromSparkTxArgs {
+  network: bitcoin.networks.Network;
+  to: string;
+  amount: string;
+}
+
+// TODO: please check do we need all this temTx stuff if we only using **txHashSig**
+
+export const createTempFromSparkTx = async ({
+  network,
+  amount,
+  to,
+}: CreateTempFromSparkTxArgs): Promise<string> => {
+  const isSparkTransaction = await isSparkAddress(to);
+
+  const tempTx = new bitcoin.Psbt({ network });
+  tempTx.setVersion(3 | (SPARK_TX_TYPE << 16)); // version 3 and tx type in high bits (3 | (SPARK_TX_TYPE << 16));
+  tempTx.setLocktime(LOCK_TIME); // new Date().getTime() / 1000
+
+  tempTx.addInput({
+    hash: '0000000000000000000000000000000000000000000000000000000000000000',
+    index: 4294967295,
+    sequence: 4294967295,
+    finalScriptSig: Buffer.from('d3', 'hex'),
+  });
+
+  const tempTxBuffer = tempTx.extractTransaction(true).toBuffer();
+  const extendedTempTxBuffer = Buffer.concat([
+    tempTxBuffer,
+    Buffer.from([0x00]),
+  ]);
+
+  const txHash = bitcoin.crypto.hash256(extendedTempTxBuffer);
+  return txHash.reverse().toString('hex');
+};

packages/extension/src/libs/spark-handler/createTempTx.ts

@@ -0,0 +1,79 @@
+import { validator } from '@/providers/bitcoin/libs/firo-wallet/firo-wallet';
+import BigNumber from 'bignumber.js';
+import * as bitcoin from 'bitcoinjs-lib';
+import { ECPairInterface } from 'ecpair';
+
+interface CreateTempTxArgs {
+  network: bitcoin.networks.Network;
+  changeAmount: BigNumber;
+  mintValueOutput: {
+    script: Buffer<ArrayBuffer>;
+    value: number;
+  }[];
+  inputs: {
+    hash: string;
+    index: number;
+    nonWitnessUtxo: Buffer<ArrayBuffer>;
+  }[];
+  spendableUtxos: {
+    keyPair: ECPairInterface;
+    address: string;
+    txid: string;
+    vout: number;
+    scriptPubKey: string;
+    amount: number;
+    satoshis: number;
+    confirmations: number;
+  }[];
+  addressKeyPairs: Record<string, any>;
+}
+
+export const createTempTx = ({
+  network,
+  inputs,
+  spendableUtxos,
+  addressKeyPairs,
+  mintValueOutput,
+  changeAmount,
+}: CreateTempTxArgs) => {
+  const tx = new bitcoin.Psbt({ network });
+  tx.setVersion(2);
+
+  inputs.forEach(input => {
+    tx.addInput(input);
+  });
+
+  mintValueOutput.forEach(mint => {
+    tx.addOutput({
+      script: mint.script,
+      value: mint.value,
+    });
+  });
+
+  if (changeAmount.gt(0)) {
+    const firstUtxoAddress = spendableUtxos[0].address;
+
+    tx.addOutput({
+      address: firstUtxoAddress!,
+      value: changeAmount.toNumber(),
+    });
+  }
+
+  for (let index = 0; index < spendableUtxos.length; index++) {
+    const utxo = spendableUtxos[index];
+    const keyPair = addressKeyPairs[utxo.address];
+
+    const Signer = {
+      sign: (hash: Uint8Array) => {
+        return Buffer.from(keyPair.sign(hash));
+      },
+      publicKey: Buffer.from(keyPair.publicKey),
+    } as unknown as bitcoin.Signer;
+
+    tx.signInput(index, Signer);
+  }
+  tx.validateSignaturesOfAllInputs(validator);
+  tx.finalizeAllInputs();
+
+  return tx.extractTransaction();
+};