@otoplo/wallet-common 0.2.2 → 0.4.0

package/src/persistence/wallet-db.ts

@@ -1,69 +1,65 @@
-import type { DBStore } from "./datastore/db";
+import type { Repository } from "./repository";
 import { AccountType } from "../utils/enums";
-import type { AccountDTO, AccountEntity, AddressDTO, AddressEntity, AssetEntity, AssetTransactionEntity, NftEntity, SessionEntity, TokenEntity, TransactionEntity, VaultDTO, VaultEntity } from "../types/db.types";
+import type { AccountDTO, AccountEntity, AddressDTO, AddressEntity, AssetEntity, AssetTransactionEntity, NftEntity, SessionEntity, TokenEntity, TransactionDTO, TransactionEntity, VaultDTO, VaultEntity } from "../types/db.types";
 import type { AssetType } from "../types/wallet.types";
 import { currentTimestamp } from "../utils/common";
 
-export type DBEvent =
-  | { type: 'tx_refresh'; }
-  | { type: 'nft_refresh'; }
-  | { type: 'token_refresh'; }
-
-export type DBUpdateCallback = (event: DBEvent) => void;
-
 export class WalletDB {
 
-  private readonly store: DBStore;
-  private updateCallback?: DBUpdateCallback;
-
-  constructor(store: DBStore) {
-    this.store = store;
-  }
-
-  public onUpdate(callback: DBUpdateCallback): void {
-    this.updateCallback = callback;
-  }
+  private readonly repository: Repository;
 
-  private notify(event: DBEvent): void {
-    this.updateCallback?.(event);
+  constructor(repository: Repository) {
+    this.repository = repository;
   }
 
-  public async initSchema(): Promise<boolean> {
-    return this.store.initSchema();
+  public initSchema(): Promise<boolean> {
+    return this.repository.initSchema();
   }
 
-  public async clearData(): Promise<void> {
-    return this.store.clearData();
+  public clearData(): Promise<void> {
+    return this.repository.clearData();
   }
 
-  public async addLocalTransaction(tx: TransactionEntity): Promise<void> {
-    try {
-      await this.store.upsertTransaction(tx);
-      this.notify({ type: 'tx_refresh' });
-    } catch (error) {
-      console.error(error);
-    }
+  public upsertTransaction(tx: TransactionDTO): Promise<void> {
+    const txEntity: TransactionEntity = {
+      ...tx,
+      othersOutputs: JSON.stringify(tx.othersOutputs),
+      myOutputs: JSON.stringify(tx.myOutputs),
+      myInputs: JSON.stringify(tx.myInputs)
+    };
+    return this.repository.upsertTransaction(txEntity);
   }
 
-  public async addAssetTransaction(assetTx: AssetTransactionEntity): Promise<void> {
-    return this.store.upsertAssetTransaction(assetTx);
+  public upsertAssetTransaction(assetTx: AssetTransactionEntity): Promise<void> {
+    return this.repository.upsertAssetTransaction(assetTx);
   }
 
-  public async getLocalTransactions(account: number, tokenId?: string): Promise<TransactionEntity[]> {
-    return this.store.getTransactions(account, tokenId);
+  public async getTransactions(account: number, tokenId?: string): Promise<TransactionEntity[]> {
+    const txs = await this.repository.getTransactions(account, tokenId);
+    return txs.map(tx => ({
+      ...tx,
+      othersOutputs: JSON.parse(tx.othersOutputs),
+      myOutputs: JSON.parse(tx.myOutputs),
+      myInputs: JSON.parse(tx.myInputs)
+    }));
   }
 
-  public async getPageLocalTransactions(account: number, pageNum: number, pageSize: number, tokenId?: string): Promise<TransactionEntity[]> {
-    return this.store.getPageTransactions(account, pageNum, pageSize, tokenId);
+  public async getPageTransactions(account: number, pageNum: number, pageSize: number, tokenId?: string): Promise<TransactionEntity[]> {
+    const txs = await this.repository.getPageTransactions(account, pageNum, pageSize, tokenId);
+    return txs.map(tx => ({
+      ...tx,
+      othersOutputs: JSON.parse(tx.othersOutputs),
+      myOutputs: JSON.parse(tx.myOutputs),
+      myInputs: JSON.parse(tx.myInputs)
+    }));
   }
 
-  public async countLocalTransactions(account: number, tokenId?: string): Promise<number> {
-    return this.store.countTransactions(account, tokenId);
+  public countTransactions(account: number, tokenId?: string): Promise<number> {
+    return this.repository.countTransactions(account, tokenId);
   }
 
-  public async clearLocalTransactions(account: number): Promise<void> {
-    await this.store.clearTransactions(account);
-    this.notify({ type: 'tx_refresh' });
+  public clearTransactions(account: number): Promise<void> {
+    return this.repository.clearTransactions(account);
   }
 
   public async saveToken(account: number, token: TokenEntity): Promise<void> {
@@ -73,26 +69,24 @@ export class WalletDB {
       type: "token",
       addedTime: currentTimestamp()
     }
-    await this.store.upsertToken(token);
+    await this.repository.upsertToken(token);
     await this.saveAsset(asset);
-    this.notify({ type: 'token_refresh' });
   }
 
-  public async getLocalTokens(account: number, pageNum: number, pageSize: number): Promise<TokenEntity[]> {
-    return this.store.getTokens(account, pageNum, pageSize);
+  public getTokens(account: number, pageNum: number, pageSize: number): Promise<TokenEntity[]> {
+    return this.repository.getTokens(account, pageNum, pageSize);
   }
 
-  public async getToken(id: string): Promise<TokenEntity | undefined> {
-    return this.store.getToken(id);
+  public getToken(id: string): Promise<TokenEntity | undefined> {
+    return this.repository.getToken(id);
   }
 
   public async deleteToken(account: number, tokenId: string): Promise<void> {
     await this.removeAsset(account, tokenId);
-    const count = await this.store.countAssetsById(tokenId);
+    const count = await this.repository.countAssetsById(tokenId);
     if (count == 0) {
-      await this.store.deleteToken(tokenId);
+      await this.repository.deleteToken(tokenId);
     }
-    this.notify({ type: 'token_refresh' });
   }
 
   public async saveNft(account: number, nft: NftEntity, time: number): Promise<void> {
@@ -102,45 +96,43 @@ export class WalletDB {
       type: "nft",
       addedTime: time
     }
-    await this.store.upsertNft(nft);
+    await this.repository.upsertNft(nft);
     await this.saveAsset(asset);
-    this.notify({ type: 'nft_refresh' });
   }
 
-  public async getLocalNfts(account: number, pageNum: number, pageSize: number): Promise<NftEntity[]> {
-    return this.store.getNfts(account, pageNum, pageSize);
+  public getNfts(account: number, pageNum: number, pageSize: number): Promise<NftEntity[]> {
+    return this.repository.getNfts(account, pageNum, pageSize);
   }
 
-  public async getLocalNft(id: string): Promise<NftEntity | undefined> {
-    return this.store.getNft(id);
+  public getNft(id: string): Promise<NftEntity | undefined> {
+    return this.repository.getNft(id);
   }
 
   public async deleteNft(account: number, tokenId: string): Promise<void> {
     await this.removeAsset(account, tokenId);
-    const count = await this.store.countAssetsById(tokenId);
+    const count = await this.repository.countAssetsById(tokenId);
     if (count == 0) {
-      await this.store.deleteNft(tokenId);
+      await this.repository.deleteNft(tokenId);
     }
-    this.notify({ type: 'nft_refresh' });
   }
 
-  public async countLocalNfts(account: number): Promise<number> {
-    return this.store.countNfts(account);
+  public countNfts(account: number): Promise<number> {
+    return this.repository.countNfts(account);
   }
 
-  public async getAssets(account: number, type: AssetType): Promise<AssetEntity[]> {
-    return this.store.getAssets(account, type);
+  public getAssets(account: number, type: AssetType): Promise<AssetEntity[]> {
+    return this.repository.getAssets(account, type);
   }
 
-  public async saveAsset(asset: AssetEntity): Promise<void> {
-    await this.store.upsertAsset(asset);
+  public saveAsset(asset: AssetEntity): Promise<void> {
+    return this.repository.upsertAsset(asset);
   }
 
-  public async removeAsset(account: number, id: string): Promise<void> {
-    return this.store.deleteAsset(account, id);
+  public removeAsset(account: number, id: string): Promise<void> {
+    return this.repository.deleteAsset(account, id);
   }
 
-  public async saveAccount(account: AccountDTO): Promise<void> {
+  public saveAccount(account: AccountDTO): Promise<void> {
     const accountEntity: AccountEntity = {
       id: account.id,
       address: account.address,
@@ -151,11 +143,11 @@ export class WalletDB {
       balance: JSON.stringify(account.balance),
       tokensBalance: JSON.stringify(account.tokensBalance)
     }
-    return this.store.upsertAccount(accountEntity);
+    return this.repository.upsertAccount(accountEntity);
   }
 
   public async getAccounts(): Promise<AccountDTO[]> {
-    const accs = await this.store.getAccounts();
+    const accs = await this.repository.getAccounts();
     return accs.map(a => ({
       ...a,
       type: AccountType.DAPP,
@@ -164,27 +156,27 @@ export class WalletDB {
     }));
   }
 
-  public async countAccounts(): Promise<number> {
-    return this.store.countAccounts();
+  public countAccounts(): Promise<number> {
+    return this.repository.countAccounts();
   }
 
-  public async updateAccountName(account: number, name: string): Promise<void> {
-    return this.store.updateAccountName(account, name);
+  public updateAccountName(account: number, name: string): Promise<void> {
+    return this.repository.updateAccountName(account, name);
   }
 
-  public async saveSession(session: SessionEntity): Promise<void> {
-    return this.store.upsertSession(session);
+  public saveSession(session: SessionEntity): Promise<void> {
+    return this.repository.upsertSession(session);
   }
 
-  public async getAccountSessions(accountId: number): Promise<SessionEntity[]> {
-    return this.store.getSessionsByAccount(accountId);
+  public getAccountSessions(accountId: number): Promise<SessionEntity[]> {
+    return this.repository.getSessionsByAccount(accountId);
   }
 
-  public async removeSession(sessionId: string): Promise<void> {
-    return this.store.deleteSession(sessionId);
+  public removeSession(sessionId: string): Promise<void> {
+    return this.repository.deleteSession(sessionId);
   }
 
-  public async saveAddress(address: AddressDTO): Promise<void> {
+  public saveAddress(address: AddressDTO): Promise<void> {
     const addressEntity: AddressEntity = {
       address: address.address,
       idx: address.idx,
@@ -195,11 +187,11 @@ export class WalletDB {
       balance: JSON.stringify(address.balance),
       tokensBalance: JSON.stringify(address.tokensBalance)
     }
-    return this.store.upsertAddress(addressEntity);
+    return this.repository.upsertAddress(addressEntity);
  }
 
   public async getReceiveAddresses(): Promise<AddressDTO[]> {
-    const addrs = await this.store.getReceiveAddresses();
+    const addrs = await this.repository.getReceiveAddresses();
     return addrs.map(a => ({
       ...a,
       type: AccountType.MAIN,
@@ -209,7 +201,7 @@ export class WalletDB {
   }
 
   public async getChangeAddresses(): Promise<AddressDTO[]> {
-    const addrs = await this.store.getChangeAddresses();
+    const addrs = await this.repository.getChangeAddresses();
     return addrs.map(a => ({
       ...a,
       type: AccountType.MAIN,
@@ -218,12 +210,12 @@ export class WalletDB {
     }));
   }
 
-  public async countAddresses(): Promise<number> {
-    return this.store.countAddresses();
+  public countAddresses(): Promise<number> {
+    return this.repository.countAddresses();
   }
 
   public async getVaults(): Promise<VaultDTO[]> {
-    const vaults = await this.store.getVaults();
+    const vaults = await this.repository.getVaults();
     return vaults.map(v => ({
       ...v,
       type: AccountType.VAULT,
@@ -232,7 +224,7 @@ export class WalletDB {
     }));
   }
 
-  public async saveVault(vault: VaultDTO): Promise<void> {
+  public saveVault(vault: VaultDTO): Promise<void> {
     const vaultEntity: VaultEntity = {
       address: vault.address,
       idx: vault.idx,
@@ -242,6 +234,18 @@ export class WalletDB {
       balance: JSON.stringify(vault.balance),
       tokensBalance: JSON.stringify(vault.tokensBalance)
     };
-    return this.store.upsertVault(vaultEntity);
+    return this.repository.upsertVault(vaultEntity);
+  }
+
+  public getSetting(name: string): Promise<string | undefined> {
+    return this.repository.getSetting(name);
+  }
+
+  public saveSetting(name: string, value: string): Promise<void> {
+    return this.repository.saveSetting(name, value);
+  }
+
+  public removeSetting(name: string): Promise<void> {
+    return this.repository.deleteSetting(name);
   }
 }

package/src/services/asset.ts

@@ -1,5 +1,5 @@
 import type { NftEntity, TokenEntity } from "../types/db.types";
-import { getAssetMetadata } from "../utils/asset";
+import { getAssetFileUrl, getAssetMetadataUrl } from "../utils/asset";
 import { currentTimestamp, tokenIdToHex } from "../utils/common";
 import type { WalletDB } from "../persistence/wallet-db";
 import type { WalletCache } from "./cache";
@@ -17,42 +17,42 @@ export class AssetService {
 
   public async getAssetInfo(assetId: string): Promise<AssetInfo | undefined> {
     try {
-      if (this.walletCache.hasToken(assetId)) {
-        const token = await this.walletCache.getToken(assetId);
+      const token = await this.walletCache.getToken(assetId);
+      if (token) {
         return {
           type: "token",
-          parent: token!.parent,
-          token: token!.token,
-          tokenIdHex: token!.tokenIdHex,
+          parent: token.parent,
+          token: token.token,
+          tokenIdHex: token.tokenIdHex,
           data: {
-            name: token!.name,
-            ticker: token!.ticker,
-            decimals: token!.decimals,
-            iconUrl: token!.iconUrl
+            name: token.name,
+            ticker: token.ticker,
+            decimals: token.decimals,
+            iconUrl: token.iconUrl
           }
         }
       }
 
-      if (this.walletCache.hasNft(assetId)) {
-        const nft = await this.walletCache.getNft(assetId);
+      const nft = await this.walletCache.getNft(assetId);
+      if (nft) {
         return {
           type: "nft",
-          parent: nft!.parent,
-          token: nft!.token,
-          tokenIdHex: nft!.tokenIdHex,
+          parent: nft.parent,
+          token: nft.token,
+          tokenIdHex: nft.tokenIdHex,
           data: {
-            name: nft!.name,
-            series: nft!.series,
-            collection: nft!.collection,
-            author: nft!.author,
-            public: nft!.public,
-            front: nft!.front,
-            back: nft!.back
+            name: nft.name,
+            series: nft.series,
+            collection: nft.collection,
+            author: nft.author,
+            public: nft.public,
+            front: nft.front,
+            back: nft.back
           }
         }
       }
 
-      return await getAssetMetadata(assetId);
+      return await this.getAssetMetadata(assetId);
     } catch (e) {
       console.error(e);
       return undefined;
@@ -68,7 +68,7 @@ export class AssetService {
         parent: nft.parent,
         ...nft.data
       }
-      await this.walletDb.saveNft(accountId, nftEntity, time);
+      await this.saveNft(accountId, nftEntity, time);
     }
   }
 
@@ -84,7 +84,7 @@ export class AssetService {
             parent: token.parent,
             ...token.data
           };
-          await this.walletDb.saveToken(accountId, tokenEntity);
+          await this.saveToken(accountId, tokenEntity);
         }
       }
     }
@@ -115,13 +115,47 @@ export class AssetService {
     }
   }
 
+  public async saveToken(accountId: number, token: TokenEntity): Promise<void> {
+    await this.walletDb.saveToken(accountId, token);
+  }
+
   public async deleteToken(accountId: number, tokenId: string): Promise<void> {
     await this.walletDb.deleteToken(accountId, tokenId);
     this.walletCache.removeToken(tokenId);
   }
 
+  public async saveNft(accountId: number, nft: NftEntity, time: number): Promise<void> {
+    await this.walletDb.saveNft(accountId, nft, time);
+  }
+
   public async deleteNft(accountId: number, tokenId: string): Promise<void> {
     await this.walletDb.deleteNft(accountId, tokenId);
     this.walletCache.removeNft(tokenId);
   }
-}
+
+  public getAssetFile(token: string, asset: string): Promise<Uint8Array> {
+    return this.performGet(getAssetFileUrl(token, asset), 'raw');
+  }
+
+  private getAssetMetadata(token: string): Promise<AssetInfo> {
+    return this.performGet(getAssetMetadataUrl(token), 'json');
+  }
+
+  private async performGet(url: string, responseType?: 'json' | 'raw'): Promise<any> {
+    try {
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new Error(`Failed to perform GET. status: ${response.status}`);
+      }
+
+      if (responseType === 'raw') {
+        const arrayBuffer = await response.arrayBuffer();
+        return new Uint8Array(arrayBuffer);
+      } else {
+        return await response.json();
+      }
+    } catch (e) {
+      throw new Error(`Unexpected Error: ${e}`);
+    }
+  }
+}

package/src/services/cache.ts

@@ -18,20 +18,10 @@ export class WalletCache {
     this.nfts.clear();
   }
 
-  public hasToken(id: string): boolean {
-    id = tokenIdToHex(id);
-    return this.tokens.has(id);
-  }
-
-  public hasNft(id: string): boolean {
-    id = tokenIdToHex(id);
-    return this.nfts.has(id);
-  }
-
   public async getToken(id: string): Promise<TokenEntity | undefined> {
     id = tokenIdToHex(id);
     if (this.tokens.has(id)) {
-      return this.tokens.get(id)!;
+      return this.tokens.get(id);
     }
 
     const token = await this.walletDb.getToken(id);
@@ -44,10 +34,10 @@ export class WalletCache {
   public async getNft(id: string): Promise<NftEntity | undefined> {
     id = tokenIdToHex(id);
     if (this.nfts.has(id)) {
-      return this.nfts.get(id)!;
+      return this.nfts.get(id);
     }
 
-    const nft = await this.walletDb.getLocalNft(id);
+    const nft = await this.walletDb.getNft(id);
     if (nft) {
       this.nfts.set(id, nft);
     }
@@ -61,4 +51,4 @@ export class WalletCache {
   public removeNft(id: string): void {
     this.nfts.delete(tokenIdToHex(id));
   }
-}
+}

package/src/services/discovery.ts

@@ -1,7 +1,7 @@
 import { Address, BNExtended, BufferWriter, Script, ScriptOpcode } from "libnexa-ts";
-import type { VaultDTO } from "../types";
+import type { ITXHistory, VaultDTO } from "../types";
 import { AccountType, generateVaultAddress, KeySpace } from "../utils";
-import type { KeyManager } from "./key";
+import { KeyManager } from "./key";
 import type { RostrumService } from "./rostrum";
 
 const HODL_FIRST_BLOCK = 274710;
@@ -18,58 +18,70 @@ export class WalletDiscoveryService {
   }
 
   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;
-        }
+    let batchStart = 0;
+    let lastUsedBatchStart = -1;
+    let lastUsedBatchResults: boolean[] = [];
+
+    while (true) {
+      const results = await Promise.all(
+        Array.from({ length: KeyManager.GAP_LIMIT }, (_, i) =>
+          this.rostrumService.isAddressUsed(this.keyManager.deriveAddress(type, keySpace, batchStart + i))
+        )
+      );
+
+      if (results.some(used => used)) {
+        lastUsedBatchStart = batchStart;
+        lastUsedBatchResults = results;
+        batchStart += KeyManager.GAP_LIMIT;
+      } else {
+        break;
       }
-      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);
+    if (lastUsedBatchStart === -1) {
+      return -1;
     }
 
-    const res = await Promise.all(vaultsPromises);
+    for (let i = KeyManager.GAP_LIMIT - 1; i >= 0; i--) {
+      if (lastUsedBatchResults[i]) {
+        return lastUsedBatchStart + i;
+      }
+    }
+
+    return lastUsedBatchStart;
+  }
+
+  public async discoverVaults(walletTxs: ITXHistory[]): Promise<Map<string, VaultDTO>> {
+    const vaultsHex = await this.checkForVaults(walletTxs);
     const vaults = new Map<string, VaultDTO>();
 
-    res.forEach(set => {
-      set.forEach(hex => {
-        const vault = this.parseVaultDetails(hex);
-        if (vault) {
-          vaults.set(vault.address, vault);
-        }
-      });
+    vaultsHex.forEach(hex => {
+      const vault = this.parseVaultDetails(hex);
+      if (vault) {
+        vaults.set(vault.address, vault);
+      }
     });
 
     return vaults;
   }
 
-  private async checkVaultsForAddress(address: string): Promise<Set<string>> {
+  private async checkForVaults(history: ITXHistory[]): 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);
-      }
-    }
+    await Promise.all(
+      history.map(async txHistory => {
+        if (txHistory.height > 0 && txHistory.height < HODL_FIRST_BLOCK) {
+          return;
+        }
+
+        const tx = await this.rostrumService.getTransaction(txHistory.tx_hash);
+        for (const out of tx.vout) {
+          if (out.scriptPubKey.hex.startsWith(HODL_SCRIPT_PREFIX)) {
+            vaults.add(out.scriptPubKey.hex);
+          }
+        }
+      })
+    );
     
     return vaults;
   }
@@ -107,4 +119,4 @@ export class WalletDiscoveryService {
 
     return dto;
   }
-}
+}

package/src/services/index.ts

@@ -5,4 +5,5 @@ export * from './asset';
 export * from './transaction';
 export * from './session';
 export * from './tx-transformer';
-export * from './wallet';
+export * from './wallet';
+export * from './market';

package/src/services/key.ts

@@ -1,11 +1,13 @@
 import { mnemonicToSeedSync } from "@scure/bip39";
 import { HDPrivateKey } from "libnexa-ts";
-import type { AccountType } from "../utils/enums";
+import type { AccountType, KeySpace } from "../utils/enums";
 import type { KeyPath } from "../types/wallet.types";
 import { keyPathToString, stringToKeyPath } from "../utils/keypath";
 
 export class KeyManager {
 
+  public static readonly GAP_LIMIT = 20;
+
   private seed!: Uint8Array;
   private masterKey!: HDPrivateKey;
   private accountKeys = new Map<number, HDPrivateKey>();
@@ -35,6 +37,10 @@ export class KeyManager {
     return key;
   }
 
+  public deriveAddress(account: AccountType, space: KeySpace, index: number): string {
+    return this.getKey({ account, type: space, index }).privateKey.toAddress().toString();
+  }
+
   public getKey(keyPath: string | KeyPath): HDPrivateKey {
     const path = typeof keyPath === 'string'
       ? keyPath
@@ -52,4 +58,4 @@ export class KeyManager {
 
     return key;
   }
-}
+}