@otoplo/wallet-common 0.1.0

package/src/persistence/datastore/kv.ts

@@ -0,0 +1,129 @@
+import type { RostrumParams } from "../../types/rostrum.types";
+import { isNullOrEmpty, isTestnet } from "../../utils/common";
+
+export abstract class KVStore {
+  
+  public abstract getValue(key: string): Promise<string | null>;
+  public abstract setValue(key: string, value: string): Promise<void>;
+  public abstract removeValue(key: string): Promise<void>;
+  public abstract clearData(): Promise<void>;
+
+  protected getPrefix(): string {
+    return isTestnet() ? 'testnet-' : '';
+  }
+
+  public async getEncryptedSeed(): Promise<string | null> {
+    return this.getValue("seed");
+  }
+
+  public async saveEncryptedSeed(seed: string): Promise<void> {
+    return this.setValue('seed', seed);
+  }
+
+  public async getVersionCode(): Promise<string | null> {
+    return this.getValue("version-code");
+  }
+
+  public async setVersionCode(code: string): Promise<void> {
+    return this.setValue('version-code', code);
+  }
+
+  public async getReleaseNumber(): Promise<string | null> {
+    return this.getValue("release-number");
+  }
+
+  public async setReleaseNumber(release: string): Promise<void> {
+    return this.setValue('release-number', release);
+  }
+
+  public async getRostrumParams(): Promise<RostrumParams | undefined> {
+    const params = await this.getValue(this.getPrefix() + "rostrum-params");
+    if (params) {
+      return JSON.parse(params);
+    }
+  }
+
+  public async saveRostrumParams(params: RostrumParams): Promise<void> {
+    return this.setValue(this.getPrefix() + "rostrum-params", JSON.stringify(params));
+  }
+
+  public async removeRostrumParams(): Promise<void> {
+    return this.removeValue(this.getPrefix() + "rostrum-params");
+  }
+
+  public async setHideZeroTokenConfig(hide: boolean): Promise<void> {
+    return this.setValue("zero-tokens", JSON.stringify(hide));
+  }
+
+  public async getHideZeroTokenConfig(): Promise<boolean> {
+    const hide = await this.getValue("zero-tokens");
+    return hide === "true";
+  }
+
+  public async setHideZeroVaultsConfig(hide: boolean): Promise<void> {
+    return this.setValue("zero-vaults", JSON.stringify(hide));
+  }
+
+  public async getHideZeroVaultsConfig(): Promise<boolean> {
+    const hide = await this.getValue("zero-vaults");
+    return hide === "true";
+  }
+
+  public async getSelectedCurrency(): Promise<string> {
+    const value = await this.getValue('selectedCurrency');
+    return value || 'usd';
+  }
+
+  public async setSelectedCurrency(currency: string): Promise<void> {
+    return this.setValue('selectedCurrency', currency);
+  }
+
+  public async getUseBiometric(): Promise<boolean> {
+    const value = await this.getValue('biometrics');
+    return value === "true";
+  }
+
+  public async setUseBiometric(useBiometric: boolean): Promise<void> {
+    return this.setValue('biometrics', JSON.stringify(useBiometric));
+  }
+
+  public async getRequireAuth(): Promise<boolean> {
+    const value = await this.getValue('auth');
+    return isNullOrEmpty(value) || value === "true";
+  }
+
+  public async setRequireAuth(requireAuth: boolean): Promise<void> {
+    await this.setValue('auth', JSON.stringify(requireAuth));
+  }
+
+  public async getReleaseNotesTime(): Promise<number | undefined> {
+    const value = await this.getValue('show-notes');
+    return value ? Number(value) : undefined;
+  }
+
+  public async setReleaseNotesTime(time: string): Promise<void> {
+    if (isNullOrEmpty(time)) {
+      await this.removeValue('show-notes');
+    } else {
+      await this.setValue('show-notes', time);
+    }
+  }
+
+  public async getIsTestnet(): Promise<boolean> {
+    const value = await this.getValue('testnet');
+    return value === "1";
+  }
+
+  public async setIsTestnet(isTestnet: boolean): Promise<void> {
+    await this.setValue('testnet', isTestnet ? "1" : "0");
+  }
+
+  public async getAutoLockSeconds(): Promise<number> {
+    const value = await this.getValue('auto-lock');
+    return value ? parseInt(value) : 60;
+  }
+
+  public async setAutoLockSeconds(autoLock: number): Promise<void> {
+    await this.setValue('auto-lock', `${autoLock}`);
+  }
+}

package/src/persistence/index.ts

@@ -0,0 +1,2 @@
+export * from './datastore';
+export * from './wallet-db';

package/src/persistence/wallet-db.ts

@@ -0,0 +1,251 @@
+import type { DBStore } from "./datastore/db";
+import { AccountType, AssetType } from "../utils/enums";
+import type { AccountDTO, AccountEntity, AddressDTO, AddressEntity, AssetEntity, AssetTransactionEntity, NftEntity, SessionEntity, TokenEntity, TransactionEntity, VaultDTO, VaultEntity } from "../types/db.types";
+import { currentTimestamp } from "../utils/common";
+
+export type DBEvent =
+  | { type: 'tx_refresh'; }
+  | { type: 'nft_refresh'; }
+  | { type: 'token_added'; accountId: number; token: AssetEntity; }
+  | { type: 'token_removed'; accountId: number; tokenId: string; }
+  | { type: 'nft_deleted'; id: string; }
+
+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 notify(event: DBEvent): void {
+    this.updateCallback?.(event);
+  }
+
+  public async initSchema(): Promise<boolean> {
+    return this.store.initSchema();
+  }
+
+  public async clearData(): Promise<void> {
+    return this.store.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 async addAssetTransaction(assetTx: AssetTransactionEntity): Promise<void> {
+    return this.store.upsertAssetTransaction(assetTx);
+  }
+
+  public async getLocalTransactions(account: number, tokenId?: string): Promise<TransactionEntity[] | undefined> {
+    return this.store.getTransactions(account, tokenId);
+  }
+
+  public async getPageLocalTransactions(account: number, pageNum: number, pageSize: number, tokenId?: string): Promise<TransactionEntity[] | undefined> {
+    return this.store.getPageTransactions(account, pageNum, pageSize, tokenId);
+  }
+
+  public async countLocalTransactions(account: number, tokenId?: string): Promise<number> {
+    return this.store.countTransactions(account, tokenId);
+  }
+
+  public async clearLocalTransactions(account: number): Promise<void> {
+    await this.store.clearTransactions(account);
+    this.notify({ type: 'tx_refresh' });
+  }
+
+  public async saveToken(account: number, token: TokenEntity): Promise<void> {
+    const asset: AssetEntity = {
+      accountId: account,
+      tokenIdHex: token.tokenIdHex,
+      type: AssetType.TOKEN,
+      addedTime: currentTimestamp()
+    }
+    await this.store.upsertAsset(asset);
+    await this.store.upsertToken(token);
+    this.notify({ type: 'token_added', accountId: account, token: asset });
+  }
+
+  public async getLocalTokens(account: number): Promise<AssetEntity[] | undefined> {
+    return this.store.getTokens(account);
+  }
+
+  public async getToken(id: string): Promise<TokenEntity | undefined> {
+    return this.store.getToken(id);
+  }
+
+  public async deleteToken(account: number, tokenId: string): Promise<void> {
+    await this.removeAsset(account, tokenId);
+    const count = await this.store.countAssetsById(tokenId);
+    if (count == 0) {
+      await this.store.deleteToken(tokenId);
+    }
+    this.notify({ type: 'token_removed', accountId: account, tokenId: tokenId });
+  }
+
+  public async saveNft(asset: AssetEntity, nft: NftEntity): Promise<void> {
+    await this.store.upsertNft(nft);
+    await this.saveAsset(asset, true);
+  }
+
+  public async getLocalNfts(account: number, pageNum: number, pageSize: number): Promise<AssetEntity[] | undefined> {
+    return this.store.getNfts(account, pageNum, pageSize);
+  }
+
+  public async getLocalNft(id: string): Promise<NftEntity | undefined> {
+    return this.store.getNft(id);
+  }
+
+  public async deleteNft(account: number, tokenId: string, notify = false): Promise<void> {
+    await this.removeAsset(account, tokenId);
+    const count = await this.store.countAssetsById(tokenId);
+    if (count == 0) {
+      await this.store.deleteNft(tokenId);
+      this.notify({ type: 'nft_deleted', id: tokenId });
+    }
+    if (notify) {
+      this.notify({ type: 'nft_refresh' });
+    }
+  }
+
+  public async countLocalNfts(account: number): Promise<number> {
+    return this.store.countNfts(account);
+  }
+
+  public async isNftExist(id: string): Promise<boolean> {
+    return this.store.isNftExist(id);
+  }
+
+  public async saveAsset(asset: AssetEntity, notifyNft = false): Promise<void> {
+    await this.store.upsertAsset(asset);
+    if (notifyNft) {
+      this.notify({ type: 'nft_refresh' });
+    }
+  }
+
+  public async removeAsset(account: number, id: string): Promise<void> {
+    return this.store.deleteAsset(account, id);
+  }
+
+  public async isAssetExistForAccount(account: number, id: string): Promise<boolean> {
+    return this.store.isAssetExistForAccount(account, id);
+  }
+
+  public async saveAccount(account: AccountDTO): Promise<void> {
+    const accountEntity: AccountEntity = {
+      id: account.id,
+      address: account.address,
+      name: account.name,
+      height: account.height,
+      hidden: account.hidden,
+      statusHash: account.statusHash,
+      balance: JSON.stringify(account.balance),
+      tokensBalance: JSON.stringify(account.tokensBalance)
+    }
+    return this.store.upsertAccount(accountEntity);
+  }
+
+  public async getAccounts(): Promise<AccountDTO[]> {
+    const accs = await this.store.getAccounts();
+    return accs.map(a => ({
+      ...a,
+      type: AccountType.DAPP,
+      balance: JSON.parse(a.balance),
+      tokensBalance: JSON.parse(a.tokensBalance)
+    }));
+  }
+
+  public async countAccounts(): Promise<number> {
+    return this.store.countAccounts();
+  }
+
+  public async updateAccountName(account: number, name: string): Promise<void> {
+    return this.store.updateAccountName(account, name);
+  }
+
+  public async saveSession(session: SessionEntity): Promise<void> {
+    return this.store.upsertSession(session);
+  }
+
+  public async getAccountSessions(accountId: number): Promise<SessionEntity[]> {
+    return this.store.getSessionsByAccount(accountId);
+  }
+
+  public async removeSession(sessionId: string): Promise<void> {
+    return this.store.deleteSession(sessionId);
+  }
+
+  public async saveAddress(address: AddressDTO): Promise<void> {
+    const addressEntity: AddressEntity = {
+      address: address.address,
+      idx: address.idx,
+      space: address.space,
+      height: address.height,
+      statusHash: address.statusHash,
+      used: address.used,
+      balance: JSON.stringify(address.balance),
+      tokensBalance: JSON.stringify(address.tokensBalance)
+    }
+    return this.store.upsertAddress(addressEntity);
+ }
+
+  public async getReceiveAddresses(): Promise<AddressDTO[]> {
+    const addrs = await this.store.getReceiveAddresses();
+    return addrs.map(a => ({
+      ...a,
+      type: AccountType.MAIN,
+      balance: JSON.parse(a.balance),
+      tokensBalance: JSON.parse(a.tokensBalance)
+    }));
+  }
+
+  public async getChangeAddresses(): Promise<AddressDTO[]> {
+    const addrs = await this.store.getChangeAddresses();
+    return addrs.map(a => ({
+      ...a,
+      type: AccountType.MAIN,
+      balance: JSON.parse(a.balance),
+      tokensBalance: JSON.parse(a.tokensBalance)
+    }));
+  }
+
+  public async countAddresses(): Promise<number> {
+    return this.store.countAddresses();
+  }
+
+  public async getVaults(): Promise<VaultDTO[]> {
+    const vaults = await this.store.getVaults();
+    return vaults.map(v => ({
+      ...v,
+      type: AccountType.VAULT,
+      balance: JSON.parse(v.balance),
+      tokensBalance: JSON.parse(v.tokensBalance)
+    }));
+  }
+
+  public async saveVault(vault: VaultDTO): Promise<void> {
+    const vaultEntity: VaultEntity = {
+      address: vault.address,
+      idx: vault.idx,
+      block: vault.block,
+      height: vault.height,
+      statusHash: vault.statusHash,
+      balance: JSON.stringify(vault.balance),
+      tokensBalance: JSON.stringify(vault.tokensBalance)
+    };
+    return this.store.upsertVault(vaultEntity);
+  }
+}

package/src/services/asset.ts

@@ -0,0 +1,220 @@
+import { Address, AddressType, BufferUtils, GroupIdType, GroupToken, Networks } from "libnexa-ts";
+import type { AssetEntity, NftEntity, TokenEntity } from "../types/db.types";
+import { fetchAssetBlob, fetchAssetDoc, getNiftyToken, isNiftySubgroup, transformTokenIconUrl } from "../utils/asset";
+import { currentTimestamp, getAddressBuffer, tokenHexToAddr, tokenIdToHex } from "../utils/common";
+import { AssetType } from "../utils/enums";
+import type { WalletDB } from "../persistence/wallet-db";
+import type { RostrumService } from "./rostrum";
+import type { WalletCache } from "./cache";
+import JSZip from "jszip";
+import type { AssetInfo, Balance } from "../types/wallet.types";
+
+export class AssetService {
+
+  private readonly walletDb: WalletDB;
+  private readonly rostrumService: RostrumService;
+  private readonly walletCache: WalletCache;
+
+  constructor(walletDb: WalletDB, rostrumService: RostrumService, walletCache: WalletCache) {
+    this.walletDb = walletDb;
+    this.rostrumService = rostrumService;
+    this.walletCache = walletCache;
+  }
+
+  public async getTokenInfo(token: string, checkCache = true): Promise<TokenEntity | undefined> {
+    try {
+      if (checkCache) {
+        const cachedToken = await this.walletCache.getTokenById(token);
+        if (cachedToken) {
+          return cachedToken;
+        }
+      }
+
+      const genesis = await this.rostrumService.getTokenGenesis(token);
+      const groupId = BufferUtils.hexToBuffer(genesis.token_id_hex);
+      let parent = "";
+      let iconUrl = "";
+      
+      if (genesis.op_return_id == GroupIdType.NRC2 || genesis.op_return_id == GroupIdType.NRC3 || isNiftySubgroup(token)) {
+        return undefined;
+      }
+      
+      if (GroupToken.isSubgroup(groupId)) {
+        parent = new Address(GroupToken.getParentGroupId(groupId), Networks.defaultNetwork, AddressType.GroupIdAddress).toString();
+      }
+      
+      if (genesis.document_url) {
+        try {
+          if (genesis.op_return_id == GroupIdType.NRC1) {
+            const token_zip = await fetchAssetBlob(genesis.document_url);
+            const zip = await JSZip.loadAsync(token_zip);
+            const info = zip.file('info.json');
+            if (info) {
+              const infoData = await info.async('string');
+              const infoJson = JSON.parse(infoData);
+              iconUrl = transformTokenIconUrl(infoJson[0]?.icon, genesis.document_url);
+            }
+          } else {
+            const infoJson = await fetchAssetDoc(genesis.document_url);
+            iconUrl = transformTokenIconUrl(infoJson[0]?.icon, genesis.document_url);
+          }
+        } catch (e) {
+          console.error("Failed to load metadata", e)
+        }
+      }
+      
+      const tokenEntity: TokenEntity = {
+        token: genesis.group,
+        tokenIdHex: genesis.token_id_hex,
+        decimals: genesis.decimal_places ?? 0,
+        parentGroup: parent,
+        name: genesis.name ?? "",
+        ticker: genesis.ticker ?? "",
+        iconUrl: iconUrl
+      };
+      
+      return tokenEntity;
+    } catch (e) {
+      console.error(e)
+      return undefined;
+    }
+  }
+
+  public async isNftToken(token: string): Promise<boolean> {
+    try {
+      if (isNiftySubgroup(token)) {
+        return true;
+      }
+
+      const cachedToken = await this.walletCache.getNftById(token);
+      if (cachedToken) {
+        return true;
+      }
+
+      const genesis = await this.rostrumService.getTokenGenesis(token);
+      if (genesis.op_return_id == GroupIdType.NRC3) {
+        return true;
+      }
+    } catch (e) {
+      console.error(e)
+    }
+
+    return false;
+  }
+
+  public async getAssetInfo(token: string): Promise<AssetInfo | undefined> {
+    let asset: AssetInfo | undefined = await this.getTokenInfo(token);
+    if (!asset) {
+      const isNft = await this.isNftToken(token);
+      if (isNft) {
+        asset = {
+          token: tokenHexToAddr(token),
+          tokenIdHex: tokenIdToHex(token),
+          decimals: 0,
+        };
+      }
+    }
+    return asset;
+  }
+
+  public async handleNftReceive(accountId: number, tokenIdHex: string, time: number): Promise<void> {
+    const exist = await this.walletDb.isNftExist(tokenIdHex);
+    if (exist) {
+      const asset: AssetEntity = {
+        accountId: accountId,
+        tokenIdHex: tokenIdHex,
+        type: AssetType.NFT,
+        addedTime: time
+      }
+      await this.walletDb.saveAsset(asset, true);
+      return;
+    }
+
+    const genesis = await this.rostrumService.getTokenGenesis(tokenIdHex);
+    if (genesis.op_return_id == GroupIdType.NRC3) {
+      const groupId = getAddressBuffer(tokenIdHex);
+      if (GroupToken.isSubgroup(groupId)) {
+        const parentGroupId = new Address(groupId.subarray(0, 32), Networks.defaultNetwork, AddressType.GroupIdAddress).toString();
+        const parentGenesis = await this.rostrumService.getTokenGenesis(parentGroupId);
+        if (parentGenesis?.op_return_id == GroupIdType.NRC2) {
+          // parent is an NRC-2 collection, this is an NRC-3 NFT. The name of the collection and NRC-3 NFT belongs
+          // to is the name of the NRC-2 collection.
+          await this.saveNft(accountId, tokenIdHex, genesis.document_url ?? '', parentGroupId, time, parentGenesis?.name ?? "");
+        }
+      }
+    } else if (isNiftySubgroup(tokenIdHex)) {
+      // NiftyArt does not have collections, pass "" for the collection
+      await this.saveNft(accountId, tokenIdHex, 'nifty', getNiftyToken().token, time, "");
+    }
+  }
+
+  private async saveNft(account: number, hexId: string, source: string, parent: string, time: number, collection: string): Promise<void> {
+    if (!source) {
+      return;
+    }
+
+    try {
+      const asset: AssetEntity = {
+        accountId: account,
+        tokenIdHex: hexId,
+        type: AssetType.NFT,
+        addedTime: time
+      }
+      const nftEntity: NftEntity = {
+        parentGroup: parent,
+        token: tokenHexToAddr(hexId),
+        tokenIdHex: hexId,
+        source: source,
+        collection: collection
+      }
+
+      await this.walletDb.saveNft(asset, nftEntity);
+    } catch (e) {
+      console.error('failed to save NFT', e);
+    }
+  }
+
+  public async fetchAndSaveTokens(accountId: number, tokenBalances: Record<string, Balance>): Promise<void> {
+    for (const tokenId in tokenBalances) {
+      const token = await this.getTokenInfo(tokenId);
+      if (token) {
+        await this.walletDb.saveToken(accountId, token);
+      }
+    }
+  }
+
+  public async syncNfts(accountId: number, tokensBalance: Record<string, Balance>): Promise<void> {
+    const currentAssets = Object.keys(tokensBalance);
+    const internalAssets = await this.walletDb.getLocalNfts(accountId, 1, 1000);
+
+    const handleNftDelete = async (tokenId: string): Promise<void> => {
+      await this.walletDb.deleteNft(accountId, tokenId, true);
+      this.walletCache.removeNft(tokenId);
+    }
+
+    const staleAssets = internalAssets?.filter(a => !currentAssets.includes(a.tokenIdHex)) ?? [];
+    for (const asset of staleAssets) {
+      await handleNftDelete(asset.tokenIdHex);
+    }
+
+    for (const [token, balance] of Object.entries(tokensBalance)) {
+      const tokenId = tokenIdToHex(token);
+      const hasBalance = balance && BigInt(balance.confirmed) + BigInt(balance.unconfirmed) > 0n;
+      const isAssetExist = internalAssets?.some(a => a.tokenIdHex == tokenId);
+      if ((!hasBalance && !isAssetExist) || (hasBalance && isAssetExist)) {
+        continue;
+      }
+
+      const isNft = await this.isNftToken(tokenId);
+      if (!isNft) {
+        continue;
+      }
+      
+      if (!hasBalance && isAssetExist) {
+        await handleNftDelete(tokenId);
+      } else {
+        await this.handleNftReceive(accountId, tokenId, currentTimestamp());
+      }
+    }
+  }
+}

package/src/services/cache.ts

@@ -0,0 +1,54 @@
+import type { NftEntity, TokenEntity } from "../types/db.types";
+import { tokenIdToHex } from "../utils/common";
+import type { WalletDB } from "../persistence/wallet-db";
+
+export class WalletCache {
+
+  private readonly walletDb: WalletDB;
+
+  private readonly tokens = new Map<string, TokenEntity>();
+  private readonly nfts = new Map<string, NftEntity>();
+
+  public constructor(walletDb: WalletDB) {
+    this.walletDb = walletDb;
+  }
+
+  public clear(): void {
+    this.tokens.clear();
+    this.nfts.clear();
+  }
+
+  public async getTokenById(id: string): Promise<TokenEntity | undefined> {
+    id = tokenIdToHex(id);
+    if (this.tokens.has(id)) {
+      return this.tokens.get(id)!;
+    }
+
+    const token = await this.walletDb.getToken(id);
+    if (token) {
+      this.tokens.set(id, token);
+    }
+    return token;
+  }
+
+  public async getNftById(id: string): Promise<NftEntity | undefined> {
+    id = tokenIdToHex(id);
+    if (this.nfts.has(id)) {
+      return this.nfts.get(id)!;
+    }
+
+    const nft = await this.walletDb.getLocalNft(id);
+    if (nft) {
+      this.nfts.set(id, nft);
+    }
+    return nft;
+  }
+
+  public removeToken(id: string): void {
+    this.tokens.delete(tokenIdToHex(id));
+  }
+
+  public removeNft(id: string): void {
+    this.nfts.delete(tokenIdToHex(id));
+  }
+}