@otoplo/wallet-common 0.1.0

package/src/services/discovery.ts

@@ -0,0 +1,110 @@
+import { Address, BNExtended, BufferWriter, Script, ScriptOpcode } from "libnexa-ts";
+import type { VaultDTO } from "../types";
+import { AccountType, generateVaultAddress, KeySpace } from "../utils";
+import type { KeyManager } from "./key";
+import type { RostrumService } from "./rostrum";
+
+const HODL_FIRST_BLOCK = 274710;
+const HODL_SCRIPT_PREFIX =  "0014461ad25081cb0119d034385ff154c8d3ad6bdd76";
+
+export class WalletDiscoveryService {
+
+  private readonly rostrumService: RostrumService;
+  private readonly keyManager: KeyManager;
+
+  public constructor(rostrumService: RostrumService, keyManager: KeyManager) {
+    this.rostrumService = rostrumService;
+    this.keyManager = keyManager;
+  }
+
+  public async discoverWalletIndex(type: AccountType, keySpace: KeySpace): Promise<number> {
+    let index = 0, stop = false, addrBatch = 0;
+    
+    do {
+      stop = true;
+      for (let i = addrBatch; i < addrBatch+20; i++) {
+        const keyPath = { account: type, type: keySpace, index: i };
+        const rAddr = this.keyManager.getKey(keyPath).privateKey.toAddress().toString();
+        const isUsed = await this.rostrumService.isAddressUsed(rAddr);
+        if (isUsed) {
+          index = i;
+          stop = false;
+        }
+      }
+      addrBatch += 20;
+    } while (!stop);
+    
+    return index;
+  }
+
+  public async discoverVaults(addresses: string[]): Promise<Map<string, VaultDTO>> {
+    const vaultsPromises: Promise<Set<string>>[] = [];
+    for (const address of addresses) {
+      const p = this.checkVaultsForAddress(address);
+      vaultsPromises.push(p);
+    }
+
+    const res = await Promise.all(vaultsPromises);
+    const vaults = new Map<string, VaultDTO>();
+
+    res.forEach(set => {
+      set.forEach(hex => {
+        const vault = this.parseVaultDetails(hex);
+        if (vault) {
+          vaults.set(vault.address, vault);
+        }
+      });
+    });
+
+    return vaults;
+  }
+
+  private async checkVaultsForAddress(address: string): Promise<Set<string>> {
+    const vaults = new Set<string>();
+
+    const history = await this.rostrumService.getTransactionsHistory(address, HODL_FIRST_BLOCK);
+    for (const txHistory of history) {
+      const tx = await this.rostrumService.getTransaction(txHistory.tx_hash);
+      const hodls = tx.vout.filter(out => out.scriptPubKey.hex.startsWith(HODL_SCRIPT_PREFIX));
+      for (const hodl of hodls) { 
+        vaults.add(hodl.scriptPubKey.hex);
+      }
+    }
+    
+    return vaults;
+  }
+
+  private parseVaultDetails(hex: string): VaultDTO | undefined {
+    const scirptTemplate = Script.fromHex(hex);
+    const buf = new BufferWriter().writeVarLengthBuf(scirptTemplate.toBuffer()).toBuffer();
+    const actualAddress = new Address(buf).toString();
+
+    const args = scirptTemplate.getVisibleArgs();
+
+    const block = BNExtended.fromScriptNumBuffer(args.chunks[0].buf!).toNumber();
+    const index = ScriptOpcode.isSmallIntOp(args.chunks[1].opcodenum)
+                  ? ScriptOpcode.decodeOP_N(args.chunks[1].opcodenum)
+                  : BNExtended.fromScriptNumBuffer(args.chunks[1].buf!).toNumber();
+
+    const visibleArgs = [block, index];
+    const key = this.keyManager.getKey({ account: AccountType.VAULT, type: KeySpace.RECEIVE, index: index });
+    const expectedAddress = generateVaultAddress(key.publicKey, visibleArgs);
+
+    if (actualAddress != expectedAddress) {
+      return undefined;
+    }
+
+    const dto: VaultDTO = {
+      address: actualAddress,
+      block: block,
+      idx: index,
+      statusHash: '',
+      balance: { confirmed: "0", unconfirmed: "0" },
+      tokensBalance: {},
+      height: 0,
+      type: AccountType.VAULT
+    }
+
+    return dto;
+  }
+}

package/src/services/index.ts

@@ -0,0 +1,8 @@
+export * from './cache';
+export * from './rostrum';
+export * from './key';
+export * from './asset';
+export * from './transaction';
+export * from './session';
+export * from './tx-transformer';
+export * from './wallet';

package/src/services/key.ts

@@ -0,0 +1,55 @@
+import { mnemonicToSeedSync } from "@scure/bip39";
+import { HDPrivateKey } from "libnexa-ts";
+import type { AccountType } from "../utils/enums";
+import type { KeyPath } from "../types/wallet.types";
+import { keyPathToString, stringToKeyPath } from "../utils/keypath";
+
+export class KeyManager {
+
+  private seed!: Uint8Array;
+  private masterKey!: HDPrivateKey;
+  private accountKeys = new Map<number, HDPrivateKey>();
+  private walletKeys = new Map<string, HDPrivateKey>();
+
+  public init(mnemonic: string | Uint8Array): void {
+    this.seed = typeof mnemonic === "string" ? mnemonicToSeedSync(mnemonic) : mnemonic;
+    this.masterKey = HDPrivateKey.fromSeed(this.seed).deriveChild(44, true).deriveChild(29223, true);
+  }
+
+  public reset(): void {
+    if (!this.seed) {
+      throw new Error("KeysManager not initialized");
+    }
+    this.masterKey = HDPrivateKey.fromSeed(this.seed).deriveChild(44, true).deriveChild(29223, true);
+    this.accountKeys.clear();
+    this.walletKeys.clear();
+  }
+
+  private getAccountKey(account: AccountType): HDPrivateKey {
+    let key = this.accountKeys.get(account);
+    if (!key) {
+      key = this.masterKey.deriveChild(account, true);
+      this.accountKeys.set(account, key);
+    }
+
+    return key;
+  }
+
+  public getKey(keyPath: string | KeyPath): HDPrivateKey {
+    const path = typeof keyPath === 'string'
+      ? keyPath
+      : keyPathToString(keyPath.account, keyPath.type, keyPath.index);
+
+    let key = this.walletKeys.get(path);
+    if (!key) {
+      const { account, type, index } = typeof keyPath === 'string'
+        ? stringToKeyPath(keyPath)
+        : keyPath;
+      const accountKey = this.getAccountKey(account);
+      key = accountKey.deriveChild(type, false).deriveChild(index, false);
+      this.walletKeys.set(path, key);
+    }
+
+    return key;
+  }
+}

package/src/services/rostrum.ts

@@ -0,0 +1,214 @@
+import type { RequestResponse} from "@otoplo/electrum-client";
+import { ConnectionStatus, ElectrumClient, TransportScheme } from "@otoplo/electrum-client";
+import type { BlockTip, IFirstUse, IListUnspentRecord, ITokenGenesis, ITokenListUnspent, ITokensBalance, ITokenUtxo, ITransaction, ITXHistory, IUtxo, RostrumParams, ServerFeatures } from "../types/rostrum.types";
+import type { Balance } from "../types/wallet.types";
+import { isTestnet } from "../utils/common";
+import type { KVStore } from "../persistence/datastore/kv";
+
+type RPCParameter = object | string | number | boolean | null;
+
+export class RostrumService {
+
+  private readonly kvStore: KVStore;
+
+  private client?: ElectrumClient;
+
+  public constructor(kvStore: KVStore) {
+    this.kvStore = kvStore;
+  }
+  
+  public getFeatures(): Promise<ServerFeatures> {
+    return this.execute<ServerFeatures>('server.features');
+  }
+
+  public getBlockTip(): Promise<BlockTip> {
+    return this.execute<BlockTip>('blockchain.headers.tip');
+  }
+
+  public getBalance(address: string): Promise<Balance> {
+    return this.execute<Balance>('blockchain.address.get_balance', address, 'exclude_tokens');
+  }
+
+  public getTransactionsHistory(address: string, fromHeight = 0): Promise<ITXHistory[]> {
+    return this.execute<ITXHistory[]>('blockchain.address.get_history', address, { from_height: fromHeight });
+  }
+
+  public getFirstUse(address: string): Promise<IFirstUse> {
+    return this.execute<IFirstUse>('blockchain.address.get_first_use', address);
+  }
+
+  public async isAddressUsed(address: string): Promise<boolean> {
+    try {
+      const firstUse = await this.getFirstUse(address);
+      return !!(firstUse.tx_hash && firstUse.tx_hash !== "");
+    } catch (e) {
+      if (e instanceof Error && e.message.includes("not found")) {
+        return false;
+      }
+      throw e;
+    }
+  }
+  
+  public getTransaction(id: string, verbose = true): Promise<ITransaction> {
+    return this.execute<ITransaction>('blockchain.transaction.get', id, verbose);
+  }
+
+  public getUtxo(outpoint: string): Promise<IUtxo> {
+    return this.execute<IUtxo>('blockchain.utxo.get', outpoint);
+  }
+
+  public getNexaUtxos(address: string): Promise<IListUnspentRecord[]> {
+    return this.execute<IListUnspentRecord[]>('blockchain.address.listunspent', address, 'exclude_tokens');
+  }
+  
+  public async getTokenUtxos(address: string, token: string): Promise<ITokenUtxo[]> {
+    const listunspent = await this.execute<ITokenListUnspent>('token.address.listunspent', address, null, token);
+    return listunspent.unspent;
+  }
+
+  public async getTokensBalance(address: string): Promise<Record<string, Balance>> {
+    const tokensBalance = await this.execute<ITokensBalance>('token.address.get_balance', address);
+    const balance: Record<string, Balance> = {};
+    
+    for (const cToken in tokensBalance.confirmed) {
+      if (tokensBalance.confirmed[cToken] != 0) {
+        balance[cToken] = { confirmed: BigInt(tokensBalance.confirmed[cToken]).toString(), unconfirmed: "0" }
+      }
+    }
+    
+    for (const uToken in tokensBalance.unconfirmed) {
+      if (tokensBalance.unconfirmed[uToken] != 0) {
+        if (balance[uToken]) {
+          balance[uToken].unconfirmed = BigInt(tokensBalance.unconfirmed[uToken]).toString();
+        } else {
+          balance[uToken] = { confirmed: "0", unconfirmed: BigInt(tokensBalance.unconfirmed[uToken]).toString() }
+        }
+      }
+    }
+    
+    return balance;
+  }
+  
+  public getTokenGenesis(token: string): Promise<ITokenGenesis> {
+    return this.execute<ITokenGenesis>('token.genesis.info', token);
+  }
+
+  public broadcast(txHex: string): Promise<string> {
+    return this.execute<string>('blockchain.transaction.broadcast', txHex);
+  }
+
+  public subscribeHeaders(handler: (block: number) => void): Promise<Error | RequestResponse> {
+    return this.client!.subscribe((response: any) => {
+      const data = Array.isArray(response) ? response[0] : response;
+      const height = typeof data?.height === 'number' ? data.height : 0;
+      handler(height);
+    }, 'blockchain.headers.subscribe');
+  }
+
+  public subscribeAddress(address: string, handler: (data: unknown) => void): Promise<Error | RequestResponse> {
+    return this.client!.subscribe(handler, 'blockchain.address.subscribe', address);
+  }
+  
+  public async getLatency(): Promise<number> {
+    try {
+      const start = Date.now();
+      const res = await this.getBlockTip();
+      if (res) {
+        return Date.now() - start;
+      }
+      return 0;
+    } catch {
+      return 0;
+    }
+  }
+  
+  public async connect(params?: RostrumParams): Promise<void> {
+    try {
+      if (!params) {
+        params = await this.getCurrentInstance();
+      }
+
+      this.client = new ElectrumClient("com.otoplo.wallet", "1.4.3", params.host, params.port, params.scheme, 45*1000, 10*1000);
+      await this.client.connect();
+    } catch (e) {
+      if (e instanceof Error) {
+        console.info(e.message);
+      } else {
+        console.error(e);
+      }
+      throw e;
+    }
+  }
+  
+  public async disconnect(force?: boolean): Promise<boolean> {
+    try {
+      return await this.client?.disconnect(force) ?? false;
+    } catch (e) {
+      console.error(e)
+      return false;
+    }
+  }
+  
+  private async execute<T>(method: string, ...parameters: RPCParameter[]): Promise<T> {
+    await this.waitForConnection();
+    const res = await this.client!.request(method, ...parameters);
+    if (res instanceof Error) {
+      throw res;
+    }
+    return res as T;
+  }
+
+  private waitForConnection(timeout = 5000): Promise<void> {
+    const start = Date.now();
+
+    return new Promise((resolve, reject) => {
+      const check = (): void => {
+        if (this.client?.connectionStatus == ConnectionStatus.CONNECTED) {
+          return resolve();
+        }
+        if (Date.now() - start > timeout) {
+          return reject(new Error("Rostrum Connection timeout"));
+        }
+        setTimeout(check, 250);
+      };
+
+      check();
+    });
+  }
+
+  public async getCurrentInstance(): Promise<RostrumParams> {
+    const params = await this.kvStore.getRostrumParams();
+    if (params) {
+      return params;
+    }
+    return RostrumService.getPredefinedInstances()[0];
+  }
+
+  public static getPredefinedInstances(): RostrumParams[] {    
+    if (isTestnet()) {
+      return [
+        {
+          scheme: TransportScheme.WSS,
+          host: 'testnet-electrum.nexa.org',
+          port: 30004,
+          label: 'NexaOrg'
+        }
+      ];
+    } else {
+      return [
+        {
+          scheme: TransportScheme.WSS,
+          host: 'rostrum.otoplo.com',
+          port: 443,
+          label: 'Otoplo'
+        },
+        {
+          scheme: TransportScheme.WSS,
+          host: 'electrum.nexa.org',
+          port: 20004,
+          label: 'NexaOrg'
+        }
+      ];
+    }
+  }
+}

package/src/services/session.ts

@@ -0,0 +1,225 @@
+import { DAppProvider } from "wallet-comms-sdk";
+import type { SessionInfo, AccountDTO, KeyPath, AppNotification, DappRpcRequest } from "../types";
+import type { WalletDB } from "../persistence";
+import { AccountType, KeySpace, MAIN_WALLET_ID, SessionRequestType } from "../utils";
+import { Networks } from "libnexa-ts";
+import type { KeyManager } from "./key";
+
+type MethodHandler = {
+  resolve: (value: any) => void;
+  reject: (value: any) => void;
+}
+
+export type SessionEvent =
+  | { type: 'session_added'; accountId: number; sessionInfo: SessionInfo }
+  | { type: 'session_removed'; accountId: number; sessionId: string }
+  | { type: 'sessions_cleared', accountId: number }
+  | { type: 'new_notification'; notification: AppNotification }
+  | { type: 'new_request'; request: DappRpcRequest };
+
+export type SessionUpdateCallback = (event: SessionEvent) => void;
+
+export class SessionManager {
+
+  private readonly walletDb: WalletDB;
+  private readonly keyManager: KeyManager;
+
+  private readonly providers: Map<number, Map<string, DAppProvider>>;
+  private readonly handlers: Map<string, MethodHandler>;
+
+  private removeOnClose: boolean;
+
+  private updateCallback?: SessionUpdateCallback;
+  
+  private constructor(walletDb: WalletDB, keyManager: KeyManager) {
+    this.walletDb = walletDb;
+    this.keyManager = keyManager;
+    this.providers = new Map();
+    this.handlers = new Map();
+    this.removeOnClose = true;
+  }
+
+  public onUpdate(callback: SessionUpdateCallback): void {
+    this.updateCallback = callback;
+  }
+
+  private notify(event: SessionEvent): void {
+    this.updateCallback?.(event);
+  }
+
+  public getHandler(request: string): MethodHandler | undefined {
+    return this.handlers.get(request);
+  }
+
+  public add(account: AccountDTO, provider: DAppProvider, sessionInfo: SessionInfo): void {
+    if (!this.providers.has(account.id)) {
+      this.providers.set(account.id, new Map());
+    }
+
+    const sessionId = sessionInfo.details.sessionId;
+    const accountSessions = this.providers.get(account.id)!;
+
+    this.registerHandlers(account, provider, sessionId);
+    accountSessions.set(sessionId, provider);
+    this.notify({ type: 'session_added', accountId: account.id, sessionInfo });
+  }
+
+  public remove(accountId: number, sessionId: string): void {
+    const sessionMap = this.providers.get(accountId);
+    if (sessionMap) {
+      const provider = sessionMap.get(sessionId);
+      if (provider) {
+        provider.disconnect();
+        sessionMap.delete(sessionId);
+      }
+      if (sessionMap.size === 0) {
+        this.providers.delete(accountId);
+      }
+    }
+    this.notify({ type: 'session_removed', accountId, sessionId });
+  }
+
+  public async reload(accounts: Map<number, AccountDTO>): Promise<void> {
+    for (const account of accounts.values()) {
+      if (account.id == MAIN_WALLET_ID) {
+        continue;
+      }
+      const storedSessions = await this.walletDb.getAccountSessions(account.id);
+      const currentSessions = this.providers.get(account.id);
+
+      const loadedSessions = storedSessions.map(async (session) => {
+        if (currentSessions?.has(session.sessionId)) {
+          return;
+        }
+
+        let provider;
+        try {
+          provider = new DAppProvider(session.uri);
+          const details = provider.getSessionInfo();
+          await provider.connect(3000);
+          const appInfo = await provider.getAppInfo(2000);
+          await provider.joinSession(account.address, 2000);
+          const messages = await provider.fetchPendingMessages();
+          for (const msg of messages) {
+            this.notify({
+              type: 'new_notification',
+              notification: {
+                id: crypto.randomUUID(),
+                createdAt: msg.createdAt,
+                type: 'web3',
+                title: 'Request pending approval',
+                message: `A connected dApp (${appInfo.name}) has requested an action from your Account: ${account.name}. Review the request details before approving or rejecting.`,
+                action: {
+                  type: 'DAPP_REQUEST',
+                  account: account.id,
+                  sessionId: details.sessionId,
+                  payload: msg.message
+                }
+              }
+            });
+          }
+          return { account: account, provider, metadata: { details, appInfo } };
+        } catch (error) {
+          console.error(`Failed to reload session ${session.sessionId}`, error);
+          provider?.disconnect();
+          await this.walletDb.removeSession(session.sessionId);
+        }
+      });
+
+      const results= await Promise.allSettled(loadedSessions);
+      for (const result of results) {
+        if (result.status === 'fulfilled' && result.value) {
+          this.add(result.value.account, result.value.provider, result.value.metadata);
+        }
+      }
+    }
+  }
+ 
+  public clear(): void {
+    try {
+      this.removeOnClose = false;
+      for (const [accountId, sessions] of this.providers) {
+        for (const [,provider] of sessions) {
+          provider.disconnect();
+        }
+        sessions.clear();
+        this.notify({ type: 'sessions_cleared', accountId });
+      }
+      this.providers.clear();
+    } finally {
+      this.removeOnClose = true;
+    }
+  }
+
+  public async revoke(accountId: number, sessionId: string): Promise<void> {
+    const sessionMap = this.providers.get(accountId);
+    if (sessionMap) {
+      const provider = sessionMap.get(sessionId);
+      if (provider) {
+        await provider.revokeSession();
+      }
+    }
+  }
+
+  public async replayMessage(accountId: number, sessionId: string, payload: string): Promise<void> {
+    const sessionMap = this.providers.get(accountId);
+    if (sessionMap) {
+      const provider = sessionMap.get(sessionId);
+      if (provider) {
+        await provider.replayMessage(payload);
+      }
+    }
+  }
+
+  private registerHandlers(account: AccountDTO, provider: DAppProvider, sessionId: string): void {
+    provider.onSessionDelete((): Promise<void> => {
+      return this.walletDb.removeSession(sessionId);
+    });
+
+    provider.onClose((): void => {
+      if (this.removeOnClose) {
+        this.remove(account.id, sessionId);
+      }
+    });
+
+    const handleRequest = <T>(type: SessionRequestType, request: unknown): Promise<T> => {
+      return new Promise<T>((resolve, reject) => {
+        this.handlers.set(type, { resolve, reject });
+        this.notify({ type: 'new_request', request: { type, accountId: account.id, sessionId, request } });
+      });
+    }
+
+    provider.onSignMessage(signMsgReq => {
+      return handleRequest(SessionRequestType.SignMessage, signMsgReq);
+    });
+
+    provider.onAddToken(addTokenReq => {
+      return handleRequest(SessionRequestType.AddToken, addTokenReq);
+    });
+
+    provider.onSendTransaction(sendTransactionReq => {
+      return handleRequest(SessionRequestType.SendTransaction, sendTransactionReq);
+    });
+
+    provider.onSignTransaction(signTransactionReq => {
+      return handleRequest(SessionRequestType.SignTransaction, signTransactionReq);
+    });
+
+    provider.onGetAccount(() => {
+      const path: KeyPath = { account: AccountType.DAPP, type: KeySpace.RECEIVE, index: account.id };
+      return {
+        name: account.name,
+        address: account.address,
+        pubkey: this.keyManager.getKey(path).publicKey.toString(),
+        blockchain: "nexa",
+        network: Networks.defaultNetwork.name,
+        capabilities: {
+          addToken: true,
+          sendTransaction: true,
+          signMessage: true,
+          signTransaction: true
+        }
+      }
+    });
+  }
+}