@otoplo/wallet-common 0.1.0

package/src/types/wallet.types.ts

@@ -0,0 +1,62 @@
+import type { DAppInfo, SessionDetails } from "wallet-comms-sdk";
+import type { AssetEntity } from "./db.types";
+import type { AccountType, KeySpace } from "../utils/enums";
+
+export interface KeyPath {
+  account: AccountType;
+  type: KeySpace;
+  index: number;
+}
+
+export interface AddressKey {
+  keyPath: string;
+  address: string;
+  balance: Balance;
+  tokensBalance: Record<string, Balance>;
+}
+
+export interface Balance {
+  confirmed: string | number;
+  unconfirmed: string | number;
+}
+
+export interface Price {
+  value: number;
+  change: number;
+}
+
+export interface Account {
+  id: number;
+  name: string;
+  address: string;
+  balance: Balance;
+  tokensBalance: Record<string, Balance>;
+  tokens: AssetEntity[];
+  sessions: Record<string, SessionInfo>
+}
+
+export interface VaultInfo {
+  address: string;
+  balance: Balance;
+  block: number;
+  index: number;
+}
+
+export interface NftPreview {
+  infoJson: string;
+  image: string;
+}
+
+export interface SessionInfo {
+  details: SessionDetails;
+  appInfo: DAppInfo;
+};
+
+export interface AssetInfo {
+  token: string;
+  tokenIdHex: string;
+  decimals: number;
+  name?: string;
+  ticker?: string;
+  iconUrl?: string;
+}

package/src/utils/asset.ts

@@ -0,0 +1,103 @@
+import { BufferUtils, GroupToken } from "libnexa-ts";
+import type { TokenEntity } from "../types/db.types";
+import { getAddressBuffer, isTestnet } from "./common";
+
+export function getNiftyToken(): TokenEntity {
+  return {
+    name: 'NiftyArt',
+    ticker: 'NIFTY',
+    iconUrl: 'https://niftyart.cash/td/niftyicon.svg',
+    parentGroup: '',
+    token: isTestnet()
+      ? 'nexatest:tq8r37lcjlqazz7vuvug84q2ev50573hesrnxkv9y6hvhhl5k5qqqnmyf79mx'
+      : 'nexa:tr9v70v4s9s6jfwz32ts60zqmmkp50lqv7t0ux620d50xa7dhyqqqcg6kdm6f',
+    tokenIdHex: isTestnet()
+      ? '0e38fbf897c1d10bcce33883d40acb28fa7a37cc0733598526aecbdff4b50000'
+      : 'cacf3d958161a925c28a970d3c40deec1a3fe06796fe1b4a7b68f377cdb90000',
+    decimals: 0
+  };
+}
+
+export function fetchNiftyNFT(id: string): Promise<Uint8Array> {
+  return performGet(getNiftyEndpoint() + id, 'raw');
+}
+
+export function isNiftySubgroup(group: string): boolean {
+  try {
+    const addrBuf = getAddressBuffer(group);
+    if (!GroupToken.isSubgroup(addrBuf)) {
+        return false;
+    }
+
+    return BufferUtils.bufferToHex(addrBuf.subarray(0, 32)) === getNiftyToken().tokenIdHex;
+  } catch {
+    return false;
+  }
+}
+
+export function fetchAssetDoc(url: string): Promise<any> {
+  // it is possible that legacy token description is stored on IPFS, check for this
+  // example: ipfs://bafkvmicdm2vdjgieqvk3s5ykqlddtzd42yuy7voum4cifpknjvhv3uarwu
+  url = translateIfIpfsUrl(url);
+  return performGet(url, 'json');
+}
+
+export function fetchAssetBlob(url: string): Promise<Uint8Array> {
+  // it is possible that NRC (Token / NFT) description is stored on IPFS, check for this
+  // example: ipfs://bafkvmicdm2vdjgieqvk3s5ykqlddtzd42yuy7voum4cifpknjvhv3uarwu
+  url = translateIfIpfsUrl(url);
+  return performGet(url, 'raw');
+}
+
+export function transformTokenIconUrl(icon: string, documentUrl: string): string {
+  if (icon && typeof icon === 'string') {
+    if (icon.startsWith('http')) {
+      return icon.replace('http://', 'https://');
+    }
+    if (icon.startsWith('ipfs://')) {
+      return icon;
+    }
+    const url = new URL(documentUrl);
+    return `${url.origin}${icon}`;
+  }
+  return "";
+}
+
+export function parseTokenDataUrl(data?: string): string | null {
+  if (!data) {
+    return null;
+  }
+  return translateIfIpfsUrl(data);
+}
+
+function translateIfIpfsUrl(url: string, gateway = "https://ipfs.nebula.markets/"): string {
+  // if ipfs gateway is implemented properly, you will be able to trim
+  // the ipfs:// from the url and append the url to the gateway path
+  // see https://docs.ipfs.tech/concepts/ipfs-gateway/#path for more info
+  if (url?.startsWith("ipfs://")) {
+    return gateway + url.substring(7);
+  }
+  return url;
+}
+
+function getNiftyEndpoint(): string {
+  return `https://${isTestnet() ? 'testnet.' : ''}niftyart.cash/_public/`;
+}
+
+async function 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/utils/common.ts

@@ -0,0 +1,159 @@
+import { Address, AddressType, BufferUtils, CommonUtils, Networks } from "libnexa-ts";
+import type { Balance } from "../types/wallet.types";
+
+export const MAIN_WALLET_ID = -1;
+export const MAX_INT64 = 9223372036854775807n;
+export const VAULT_FIRST_BLOCK = 274710;
+export const VAULT_SCRIPT_PREFIX =  "0014461ad25081cb0119d034385ff154c8d3ad6bdd76";
+
+export function isTestnet(): boolean {
+  return Networks.defaultNetwork == Networks.testnet;
+}
+
+export function isGenesisHashValid(hash: string): boolean {
+  if(isTestnet()) {
+    return hash == "508c843a4b98fb25f57cf9ebafb245a5c16468f06519cdd467059a91e7b79d52";
+  }
+  return hash == "edc7144fe1ba4edd0edf35d7eea90f6cb1dba42314aa85da8207e97c5339c801";
+}
+
+export function isValidNexaAddress(address: string, type = AddressType.PayToScriptTemplate): boolean {
+  return Address.isValid(address, Networks.defaultNetwork, type);
+}
+
+export function getExplorerUrl(): string {
+  return `https://${(isTestnet() ? 'testnet-' : '')}explorer.nexa.org`;
+}
+
+export function currentTimestamp(): number {
+  return Math.floor(Date.now() / 1000);
+}
+
+export function estimateDateByFutureBlock(current: number, future: number): string {
+  const estimateMins = (future - current) * 2;
+  const time = new Date();
+  time.setMinutes(time.getMinutes() + estimateMins);
+  return time.toLocaleDateString();
+}
+
+export function isNullOrEmpty(arg?: string | any[] | null): arg is undefined | [] | null | '' {
+  return !arg || arg.length === 0;
+}
+
+export function truncateStringMiddle(str?: string, maxLength = 0): string {
+  if (!str || str.length <= maxLength) {
+    return str || '';
+  }
+
+  const ellipsis = '...';
+  const halfLength = Math.floor((maxLength - ellipsis.length) / 2);
+  const firstHalf = str.slice(0, halfLength);
+  const secondHalf = str.slice(str.length - halfLength);
+
+  return firstHalf + ellipsis + secondHalf;
+};
+
+export function capitalizeFirstLetter(str: string): string {
+  if (str.length === 0) {
+    return "";
+  }
+  return str.charAt(0).toUpperCase() + str.substring(1);
+}
+
+export function getAddressBuffer(address: string): Uint8Array {
+  if (CommonUtils.isHexa(address)) {
+    return BufferUtils.hexToBuffer(address) ;
+  }
+  return Address.fromString(address).data;
+}
+
+export function tokenIdToHex(token: string): string {
+  if (CommonUtils.isHexa(token)) {
+    return token;
+  }
+  return BufferUtils.bufferToHex(getAddressBuffer(token));
+}
+
+export function tokenHexToAddr(token: string): string {
+  if (!CommonUtils.isHexa(token)) {
+    return token;
+  }
+  return new Address(getAddressBuffer(token), Networks.defaultNetwork, AddressType.GroupIdAddress).toString();
+}
+
+export function tokenAmountToAssetAmount(amount?: string | number | bigint): string {
+  if (amount == null || amount === "") {
+    return "";
+  }
+  if (BigInt(amount) <= 0n) {
+    return "0";
+  }
+  return amount.toString();
+}
+
+export function sumBalance(balances: Balance[]): Balance {
+  let confirmed = BigInt(0), unconfirmed = BigInt(0);
+  balances.forEach(b => {
+    confirmed += BigInt(b.confirmed);
+    unconfirmed += BigInt(b.unconfirmed);
+  });
+  return {confirmed: confirmed.toString(), unconfirmed: unconfirmed.toString()};
+}
+
+export function sumTokensBalance(balances: Record<string, Balance>[]): Record<string, Balance> {
+  const tokensBalance: Record<string, Balance> = {};
+  balances.forEach(b => {
+    for (const key in b) {
+      if (tokensBalance[key]) {
+        tokensBalance[key].confirmed = (BigInt(tokensBalance[key].confirmed) + BigInt(b[key].confirmed)).toString();
+        tokensBalance[key].unconfirmed = (BigInt(tokensBalance[key].unconfirmed) + BigInt(b[key].unconfirmed)).toString();
+      } else {
+        tokensBalance[key] = { confirmed: BigInt(b[key].confirmed).toString(), unconfirmed: BigInt(b[key].unconfirmed).toString() };
+      }
+    }
+  });
+  
+  return tokensBalance;
+}
+
+const FILE_EXTENSION_TO_TYPE = {
+  // Images
+  //'.svg': { media: 'image', mime: 'image/svg+xml' },
+  '.gif': { media: 'image', mime: 'image/gif' },
+  '.png': { media: 'image', mime: 'image/png' },
+  '.apng': { media: 'image', mime: 'image/apng' },
+  '.jpg': { media: 'image', mime: 'image/jpeg' },
+  '.jpeg': { media: 'image', mime: 'image/jpeg' },
+  '.avif': { media: 'image', mime: 'image/avif' },
+  '.webp': { media: 'image', mime: 'image/webp' },
+  '.bmp': { media: 'image', mime: 'image/bmp' },
+  
+  // Videos
+  '.mp4': { media: 'video', mime: 'video/mp4' },
+  '.mpeg': { media: 'video', mime: 'video/mpeg' },
+  '.mpg': { media: 'video', mime: 'video/mpeg' },
+  '.webm': { media: 'video', mime: 'video/webm' },
+  '.mov': { media: 'video', mime: 'video/quicktime' },
+  
+  // Audio
+  '.mp3': { media: 'audio', mime: 'audio/mpeg' },
+  '.ogg': { media: 'audio', mime: 'audio/ogg' },
+  '.wav': { media: 'audio', mime: 'audio/wav' },
+  '.m4a': { media: 'audio', mime: 'audio/mp4' },
+} as const;
+
+export function getFileMediaType(filename: string): 'video' | 'audio' | 'image' | 'unknown' {
+  const lastDotIndex = filename.lastIndexOf('.');
+  if (lastDotIndex === -1) return 'unknown';
+  
+  const extension = filename.slice(lastDotIndex).toLowerCase();
+  return FILE_EXTENSION_TO_TYPE[extension as keyof typeof FILE_EXTENSION_TO_TYPE]?.media ?? 'unknown';
+}
+
+export function getFileMimeType(filename: string): string {
+  const lastDotIndex = filename.lastIndexOf('.');
+  if (lastDotIndex === -1) return 'application/octet-stream';
+  
+  const extension = filename.slice(lastDotIndex).toLowerCase();
+  return FILE_EXTENSION_TO_TYPE[extension as keyof typeof FILE_EXTENSION_TO_TYPE]?.mime ?? 'application/octet-stream';
+}

package/src/utils/enums.ts

@@ -0,0 +1,22 @@
+export enum AccountType {
+  MAIN = 0,
+  VAULT = 1,
+  DAPP = 2
+}
+
+export enum KeySpace {
+  RECEIVE = 0,
+  CHANGE = 1
+}
+
+export enum SessionRequestType {
+  SignMessage = 'signMessage',
+  AddToken = 'addToken',
+  SignTransaction = 'signTransaction',
+  SendTransaction = 'sendTransaction',
+}
+
+export enum AssetType {
+  TOKEN = 'token',
+  NFT = 'nft'
+}

package/src/utils/index.ts

@@ -0,0 +1,7 @@
+export * from './asset';
+export * from './common';
+export * from './enums';
+export * from './seed';
+export * from './price';
+export * from './vault';
+export * from './keypath';

package/src/utils/keypath.ts

@@ -0,0 +1,15 @@
+import type { KeyPath } from "../types";
+import type { AccountType, KeySpace } from "./enums";
+
+export function keyPathToString(account: AccountType, type: KeySpace, index: number): string {
+  return `${account}'/${type}/${index}`;
+}
+
+export function stringToKeyPath(path: string): KeyPath {
+  const parts = path.split('/');
+  return {
+    account: parseInt(parts[0].replace("'", "")) as AccountType,
+    type: parseInt(parts[1]) as KeySpace,
+    index: parseInt(parts[2])
+  };
+}

package/src/utils/price.ts

@@ -0,0 +1,40 @@
+import type { Price } from "../types/wallet.types";
+
+const currencySymbols = {
+  usd: "$",
+  eur: "€",
+  gbp: "£",
+  cny: "¥",
+  jpy: "¥",
+  aud: "A$",
+  cad: "C$",
+  chf: "Fr"
+} as const;
+
+type Currency = keyof typeof currencySymbols;
+
+export const currencies = Object.keys(currencySymbols);
+
+export async function getNexaPrices(): Promise<Record<string, number>> {
+  const vs_currencies = currencies.join(",");
+  
+  const res = await fetch(`https://api.coingecko.com/api/v3/simple/price?ids=nexacoin&include_24hr_change=true&vs_currencies=${vs_currencies}`);
+  if (!res.ok) {
+    throw new Error("Failed to fetch price");
+  }
+
+  const data = await res.json();
+  return data.nexacoin || {};
+}
+
+export function getCurrencySymbol(currency: Currency): string {
+  return currencySymbols[currency] || currency;
+}
+
+export function initializePrices(): Record<string, Price> {
+  const prices: Record<string, Price> = {};
+  currencies.forEach(currency => {
+    prices[currency] = { value: 0, change: 0 };
+  });
+  return prices;
+}

package/src/utils/seed.ts

@@ -0,0 +1,57 @@
+import { gcm } from "@noble/ciphers/aes.js";
+import { pbkdf2Async } from "@noble/hashes/pbkdf2.js";
+import { sha256 } from "@noble/hashes/sha2.js";
+import { generateMnemonic, validateMnemonic } from "@scure/bip39";
+import { wordlist } from "@scure/bip39/wordlists/english.js";
+import { BufferUtils } from "libnexa-ts";
+
+export function generateNewMnemonic(size: 12 | 24 = 12): string {
+  return generateMnemonic(wordlist, size === 24 ? 256 : 128);
+}
+
+export function isMnemonicValid(mnemonic: string): boolean {
+  return validateMnemonic(mnemonic, wordlist);
+}
+
+async function deriveKey(password: string, salt: Uint8Array): Promise<Uint8Array> {
+  return pbkdf2Async(sha256, password, salt, { c: 600_000, dkLen: 32 });
+}
+
+export async function encryptMnemonic(phrase: string, password: string): Promise<string> {
+  const salt = BufferUtils.getRandomBuffer(16);
+  const iv = BufferUtils.getRandomBuffer(12);
+  const data = BufferUtils.utf8ToBuffer(phrase);
+
+  const key = await deriveKey(password, salt);
+
+  const cipher = gcm(key, iv).encrypt(data);
+  const encBuf = BufferUtils.concat([salt, iv, cipher]);
+  return BufferUtils.bufferToBase64(encBuf);
+}
+
+async function decryptMnemonic(encSeed: string, password: string): Promise<string> {
+  const encBuf = BufferUtils.base64ToBuffer(encSeed);
+
+  const salt = encBuf.subarray(0, 16);
+  const iv = encBuf.subarray(16, 28);
+  const cipher = encBuf.subarray(28);
+
+  const key = await deriveKey(password, salt);
+
+  const data = gcm(key, iv).decrypt(cipher);
+  return BufferUtils.bufferToUtf8(data);
+}
+
+export async function validateAndDecryptMnemonic(encSeed: string, password: string): Promise<string | boolean> {
+  try {
+    if (encSeed) {
+      const decMn = await decryptMnemonic(encSeed, password);
+      if (decMn && isMnemonicValid(decMn)) {
+        return decMn;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}

package/src/utils/vault.ts

@@ -0,0 +1,39 @@
+import type { PublicKey, ScriptElement} from "libnexa-ts";
+import { Address, BNExtended, Hash, Opcode, Script, ScriptOpcode } from "libnexa-ts";
+
+export function getVaultTemplate(): Script {
+  return Script.empty()
+    .add(Opcode.OP_FROMALTSTACK).add(Opcode.OP_DROP)
+    .add(Opcode.OP_FROMALTSTACK).add(Opcode.OP_CHECKLOCKTIMEVERIFY).add(Opcode.OP_DROP)
+    .add(Opcode.OP_FROMALTSTACK).add(Opcode.OP_CHECKSIGVERIFY);
+}
+
+export function getVaultTemplateHash(): Uint8Array {
+  const template = getVaultTemplate();
+  return Hash.sha256ripemd160(template.toBuffer());
+}
+
+export function generateVaultConstraint(pubKey: PublicKey): Script {
+  return Script.empty().add(pubKey.toBuffer());
+}
+
+export function getVaultConstraintHash(pubKey: PublicKey): Uint8Array {
+  const constraint = generateVaultConstraint(pubKey);
+  return Hash.sha256ripemd160(constraint.toBuffer());
+}
+
+export function generateVaultVisibleArgs(args: number[]): ScriptElement[] {
+  return args.map(arg => arg <= 16 ? ScriptOpcode.smallInt(arg) : BNExtended.fromNumber(arg).toScriptNumBuffer());
+}
+
+export function generateVaultAddress(pubKey: PublicKey, args: number[]): string | undefined {
+  if (args.length !== 2) {
+    return undefined;
+  }
+
+  const templateHash = getVaultTemplateHash();
+  const constraintHash = getVaultConstraintHash(pubKey);
+  const visibleArgs = generateVaultVisibleArgs(args);
+  const address = Address.fromScriptTemplate(templateHash, constraintHash, visibleArgs);
+  return address.toString();
+}