zano_web3 9.2.0 → 9.2.1

package/server/src/server.ts

@@ -1,380 +1,380 @@
-import axios from "axios";
-import Big from "big.js";
-import {
-  AuthData,
-  AliasAuth,
-  PkeyAuth,
-  ValidationParams,
-  BalanceInfo,
-  TxInfo,
-  AliasDetails,
-} from "./types";
-
-import { ZANO_ASSET_ID, ZanoError } from "./utils";
-import { APIAsset, APIBalance } from "./types";
-import forge from "node-forge";
-
-interface ConstructorParams {
-  walletUrl: string;
-  daemonUrl: string;
-  walletAuthToken?: string;
-}
-
-interface GetTxsParams {
-  count: number;
-  offset: number;
-  exclude_mining_txs?: boolean;
-  exclude_unconfirmed?: boolean;
-  order?: string;
-  update_provision_info?: boolean;
-}
-
-interface JWTPayload {
-  body_hash: string,
-  user: string,
-  salt: string,
-  exp: number
-}
-
-class ServerWallet {
-  private walletUrl: string;
-  private daemonUrl: string;
-  private walletAuthToken: string;
-
-  constructor(params: ConstructorParams) {
-    this.walletUrl = params.walletUrl;
-    this.daemonUrl = params.daemonUrl;
-    this.walletAuthToken = params.walletAuthToken || "";
-  }
-
-  private generateRandomString(length: number) {
-    const bytes = forge.random.getBytesSync(Math.ceil(length / 2));
-    const hexString = forge.util.bytesToHex(bytes);
-    return hexString.substring(0, length);
-  }
-
-  private createJWSToken(payload: JWTPayload, secretStr: string): string {
-    const header = { alg: "HS256", typ: "JWT" };
-    const encodedHeader = Buffer.from(JSON.stringify(header))
-      .toString("base64")
-      .replace(/=/g, "");
-    const encodedPayload = Buffer.from(JSON.stringify(payload))
-      .toString("base64")
-      .replace(/=/g, "");
-  
-    const signature = forge.hmac.create();
-    signature.start("sha256", secretStr);
-    signature.update(`${encodedHeader}.${encodedPayload}`);
-    const encodedSignature = forge.util
-      .encode64(signature.digest().getBytes())
-      .replace(/=/g, "");
-  
-    return `${encodedHeader}.${encodedPayload}.${encodedSignature}`;
-  }
-  
-
-  private generateAccessToken(httpBody: string) {
-    // Calculate the SHA-256 hash of the HTTP body
-    const md = forge.md.sha256.create();
-    md.update(httpBody);
-    const bodyHash = md.digest().toHex();
-  
-    // Example payload
-    const payload = {
-      body_hash: bodyHash,
-      user: "zano_extension",
-      salt: this.generateRandomString(64),
-      exp: Math.floor(Date.now() / 1000) + 60, // Expires in 1 minute
-    };
-  
-    return this.createJWSToken(payload, this.walletAuthToken);
-  }
-  
-
-  async fetchDaemon(method: string, params: any) {
-
-    
-    const data = {
-      jsonrpc: "2.0",
-      id: 0,
-      method: method,
-      params: params,
-    };
-
-    const headers = {
-      "Content-Type": "application/json",
-      "Zano-Access-Token": this.generateAccessToken(JSON.stringify(data)),
-    };
-
-    return axios.post(this.daemonUrl, data, { headers });
-  }
-
-  async fetchWallet(method: string, params: any) {
-
-    const data = {
-      jsonrpc: "2.0",
-      id: 0,
-      method: method,
-      params: params,
-    };
-
-    const headers = { 
-      "Content-Type": "application/json",
-      "Zano-Access-Token": this.generateAccessToken(JSON.stringify(data)),
-     };
-
-    return axios.post(this.walletUrl, data, { headers });
-  }
-
-  async updateWalletRpcUrl(rpcUrl: string) {
-    this.walletUrl = rpcUrl;
-  }
-
-  async updateDaemonRpcUrl(rpcUrl: string) {
-    this.daemonUrl = rpcUrl;
-  }
-
-  async getAssetsList() {
-    const count = 100;
-    let offset = 0;
-    let allAssets: APIAsset[] = [];
-    let keepFetching = true;
-
-    while (keepFetching) {
-      try {
-        const response = await this.fetchDaemon("get_assets_list", {
-          count,
-          offset,
-        });
-
-        const assets = response.data.result.assets;
-        if (assets.length < count) {
-          keepFetching = false;
-        }
-        allAssets = allAssets.concat(assets);
-        offset += count;
-      } catch (error) {
-        throw new ZanoError(
-          "Failed to fetch assets list",
-          "ASSETS_FETCH_ERROR"
-        );
-      }
-    }
-
-    return allAssets as APIAsset[];
-  }
-
-  async getAssetDetails(assetId: string) {
-    const assets = await this.getAssetsList();
-    const asset = assets.find((a) => a.asset_id === assetId);
-
-    if (!asset) {
-      throw new ZanoError(
-        `Asset with ID ${assetId} not found`,
-        "ASSET_NOT_FOUND"
-      );
-    }
-
-    return asset as APIAsset;
-  }
-
-  async getAssetInfo(assetId: string) {
-    try {
-      const response = await this.fetchDaemon("get_asset_info", {
-        asset_id: assetId,
-      });
-
-      if (response.data.result) {
-        return response.data.result;
-      } else {
-        throw new ZanoError(
-          `Error fetching info for asset ID ${assetId}`,
-          "ASSET_INFO_ERROR"
-        );
-      }
-    } catch (error) {
-      console.error(error);
-      throw new ZanoError(
-        "Failed to fetch asset info",
-        "ASSET_INFO_FETCH_ERROR"
-      );
-    }
-  }
-
-  async sendTransfer(assetId: string, address: string, amount: string) {
-    let decimalPoint: number;
-    let auditable: boolean;
-
-    if (assetId === ZANO_ASSET_ID) {
-      decimalPoint = 12;
-    } else {
-      const asset = await this.getAssetDetails(assetId);
-      decimalPoint = asset.decimal_point;
-    }
-
-    try {
-      const response = await this.fetchWallet("getaddress", {});
-      auditable = response.data.result.address.startsWith("a");
-    } catch (error) {
-      throw new ZanoError("Failed to fetch address", "ADDRESS_FETCH_ERROR");
-    }
-
-    const bigAmount = new Big(amount)
-      .times(new Big(10).pow(decimalPoint))
-      .toString();
-
-    try {
-      const response = await this.fetchWallet("transfer", {
-        destinations: [{ address, amount: bigAmount, asset_id: assetId }],
-        fee: "10000000000",
-        mixin: auditable ? 0 : 15,
-      });
-
-      if (response.data.result) {
-        return response.data.result;
-      } else if (
-        response.data.error &&
-        response.data.error.message === "WALLET_RPC_ERROR_CODE_NOT_ENOUGH_MONEY"
-      ) {
-        throw new ZanoError("Not enough funds", "NOT_ENOUGH_FUNDS");
-      } else {
-        throw new ZanoError("Error sending transfer", "TRANSFER_ERROR");
-      }
-    } catch (error) {
-      if (error instanceof ZanoError) {
-        throw error;
-      } else {
-        throw new ZanoError("Failed to send transfer", "TRANSFER_SEND_ERROR");
-      }
-    }
-  }
-
-  async getAliasByAddress(address: string) {
-    try {
-      const response = await this.fetchDaemon("get_alias_by_address", address);
-
-      if (response.data.result) {
-        return response.data.result;
-      } else {
-        throw new ZanoError(
-          `Error fetching alias for address ${address}`,
-          "ALIAS_FETCH_ERROR"
-        );
-      }
-    } catch (error) {
-      throw new ZanoError("Failed to fetch alias", "ALIAS_FETCH_ERROR");
-    }
-  }
-
-  async getBalances() {
-    try {
-      const response = await this.fetchWallet("getbalance", {});
-      const balancesData = response.data.result.balances as APIBalance[];
-
-      const balances = balancesData.map((asset) => ({
-        name: asset.asset_info.full_name,
-        ticker: asset.asset_info.ticker,
-        id: asset.asset_info.asset_id,
-        amount: new Big(asset.unlocked)
-          .div(new Big(10).pow(asset.asset_info.decimal_point))
-          .toString(),
-        awaiting_in: new Big(asset.awaiting_in).toString(),
-        awaiting_out: new Big(asset.awaiting_out).toString(),
-        total: new Big(asset.total).toString(),
-        unlocked: new Big(asset.unlocked).toString(),
-        asset_info: asset.asset_info,
-      }));
-
-      return balances.sort((a, b) => {
-        if (a.id === ZANO_ASSET_ID) return -1;
-        if (b.id === ZANO_ASSET_ID) return 1;
-        return 0;
-      }) as BalanceInfo[];
-    } catch (error) {
-      throw new ZanoError("Failed to fetch balances", "BALANCES_FETCH_ERROR");
-    }
-  }
-
-  async validateWallet(authData: AuthData) {
-    const { message, address, signature } = authData;
-
-    const alias = (authData as AliasAuth).alias || undefined;
-    const pkey = (authData as PkeyAuth).pkey || undefined;
-
-    if (!message || (!alias && !pkey) || !signature) {
-      return false;
-    }
-
-    const validationParams: ValidationParams = {
-      buff: Buffer.from(message).toString("base64"),
-      sig: signature,
-    };
-
-    if (alias) {
-      validationParams["alias"] = alias;
-    } else {
-      validationParams["pkey"] = pkey;
-    }
-
-    const response = await this.fetchDaemon(
-      "validate_signature",
-      validationParams
-    );
-
-    const valid = response?.data?.result?.status === "OK";
-
-    if (!valid) {
-      return false;
-    }
-
-    if (alias) {
-      const aliasDetailsResponse = await this.fetchDaemon("get_alias_details", {
-        alias: alias,
-      });
-
-      const aliasDetails = aliasDetailsResponse?.data?.result?.alias_details;
-      const aliasAddress = aliasDetails?.address;
-
-      const addressValid = !!aliasAddress && aliasAddress === address;
-
-      if (!addressValid) {
-        return false;
-      }
-    }
-
-    return valid;
-  }
-
-  async getTxs(params: GetTxsParams) {
-    const txs = await this.fetchWallet("get_recent_txs_and_info2", {
-      count: params.count,
-      exclude_mining_txs: params.exclude_mining_txs || false,
-      exclude_unconfirmed: params.exclude_unconfirmed || false,
-      offset: params.offset,
-      order: params.order || "FROM_END_TO_BEGIN",
-      update_provision_info: params.update_provision_info || true,
-    });
-
-    return txs.data.result as TxInfo;
-  }
-  async getAliasDetails(alias: string) {
-    try {
-        const response = await this.fetchDaemon("get_alias_details", {
-            alias,
-        });
-        if (response.data.result) {
-            return response.data.result as AliasDetails;
-        } else {
-            throw new ZanoError(
-                `Error fetching alias ${alias}`,
-                "ALIAS_FETCH_ERROR"
-            );
-        }
-    } catch {
-        throw new ZanoError("Failed to fetch alias", "ALIAS_FETCH_ERROR");
-    }
-}
-
-}
-
-export default ServerWallet;
+import axios from "axios";
+import Big from "big.js";
+import {
+  AuthData,
+  AliasAuth,
+  PkeyAuth,
+  ValidationParams,
+  BalanceInfo,
+  TxInfo,
+  AliasDetails,
+} from "./types";
+
+import { ZANO_ASSET_ID, ZanoError } from "./utils";
+import { APIAsset, APIBalance } from "./types";
+import forge from "node-forge";
+
+interface ConstructorParams {
+  walletUrl: string;
+  daemonUrl: string;
+  walletAuthToken?: string;
+}
+
+interface GetTxsParams {
+  count: number;
+  offset: number;
+  exclude_mining_txs?: boolean;
+  exclude_unconfirmed?: boolean;
+  order?: string;
+  update_provision_info?: boolean;
+}
+
+interface JWTPayload {
+  body_hash: string,
+  user: string,
+  salt: string,
+  exp: number
+}
+
+class ServerWallet {
+  private walletUrl: string;
+  private daemonUrl: string;
+  private walletAuthToken: string;
+
+  constructor(params: ConstructorParams) {
+    this.walletUrl = params.walletUrl;
+    this.daemonUrl = params.daemonUrl;
+    this.walletAuthToken = params.walletAuthToken || "";
+  }
+
+  private generateRandomString(length: number) {
+    const bytes = forge.random.getBytesSync(Math.ceil(length / 2));
+    const hexString = forge.util.bytesToHex(bytes);
+    return hexString.substring(0, length);
+  }
+
+  private createJWSToken(payload: JWTPayload, secretStr: string): string {
+    const header = { alg: "HS256", typ: "JWT" };
+    const encodedHeader = Buffer.from(JSON.stringify(header))
+      .toString("base64")
+      .replace(/=/g, "");
+    const encodedPayload = Buffer.from(JSON.stringify(payload))
+      .toString("base64")
+      .replace(/=/g, "");
+  
+    const signature = forge.hmac.create();
+    signature.start("sha256", secretStr);
+    signature.update(`${encodedHeader}.${encodedPayload}`);
+    const encodedSignature = forge.util
+      .encode64(signature.digest().getBytes())
+      .replace(/=/g, "");
+  
+    return `${encodedHeader}.${encodedPayload}.${encodedSignature}`;
+  }
+  
+
+  private generateAccessToken(httpBody: string) {
+    // Calculate the SHA-256 hash of the HTTP body
+    const md = forge.md.sha256.create();
+    md.update(httpBody);
+    const bodyHash = md.digest().toHex();
+  
+    // Example payload
+    const payload = {
+      body_hash: bodyHash,
+      user: "zano_extension",
+      salt: this.generateRandomString(64),
+      exp: Math.floor(Date.now() / 1000) + 60, // Expires in 1 minute
+    };
+  
+    return this.createJWSToken(payload, this.walletAuthToken);
+  }
+  
+
+  async fetchDaemon(method: string, params: any) {
+
+    
+    const data = {
+      jsonrpc: "2.0",
+      id: 0,
+      method: method,
+      params: params,
+    };
+
+    const headers = {
+      "Content-Type": "application/json",
+      "Zano-Access-Token": this.generateAccessToken(JSON.stringify(data)),
+    };
+
+    return axios.post(this.daemonUrl, data, { headers });
+  }
+
+  async fetchWallet(method: string, params: any) {
+
+    const data = {
+      jsonrpc: "2.0",
+      id: 0,
+      method: method,
+      params: params,
+    };
+
+    const headers = { 
+      "Content-Type": "application/json",
+      "Zano-Access-Token": this.generateAccessToken(JSON.stringify(data)),
+     };
+
+    return axios.post(this.walletUrl, data, { headers });
+  }
+
+  async updateWalletRpcUrl(rpcUrl: string) {
+    this.walletUrl = rpcUrl;
+  }
+
+  async updateDaemonRpcUrl(rpcUrl: string) {
+    this.daemonUrl = rpcUrl;
+  }
+
+  async getAssetsList() {
+    const count = 100;
+    let offset = 0;
+    let allAssets: APIAsset[] = [];
+    let keepFetching = true;
+
+    while (keepFetching) {
+      try {
+        const response = await this.fetchDaemon("get_assets_list", {
+          count,
+          offset,
+        });
+
+        const assets = response.data.result.assets;
+        if (assets.length < count) {
+          keepFetching = false;
+        }
+        allAssets = allAssets.concat(assets);
+        offset += count;
+      } catch (error) {
+        throw new ZanoError(
+          "Failed to fetch assets list",
+          "ASSETS_FETCH_ERROR"
+        );
+      }
+    }
+
+    return allAssets as APIAsset[];
+  }
+
+  async getAssetDetails(assetId: string) {
+    const assets = await this.getAssetsList();
+    const asset = assets.find((a) => a.asset_id === assetId);
+
+    if (!asset) {
+      throw new ZanoError(
+        `Asset with ID ${assetId} not found`,
+        "ASSET_NOT_FOUND"
+      );
+    }
+
+    return asset as APIAsset;
+  }
+
+  async getAssetInfo(assetId: string) {
+    try {
+      const response = await this.fetchDaemon("get_asset_info", {
+        asset_id: assetId,
+      });
+
+      if (response.data.result) {
+        return response.data.result;
+      } else {
+        throw new ZanoError(
+          `Error fetching info for asset ID ${assetId}`,
+          "ASSET_INFO_ERROR"
+        );
+      }
+    } catch (error) {
+      console.error(error);
+      throw new ZanoError(
+        "Failed to fetch asset info",
+        "ASSET_INFO_FETCH_ERROR"
+      );
+    }
+  }
+
+  async sendTransfer(assetId: string, address: string, amount: string) {
+    let decimalPoint: number;
+    let auditable: boolean;
+
+    if (assetId === ZANO_ASSET_ID) {
+      decimalPoint = 12;
+    } else {
+      const asset = await this.getAssetDetails(assetId);
+      decimalPoint = asset.decimal_point;
+    }
+
+    try {
+      const response = await this.fetchWallet("getaddress", {});
+      auditable = response.data.result.address.startsWith("a");
+    } catch (error) {
+      throw new ZanoError("Failed to fetch address", "ADDRESS_FETCH_ERROR");
+    }
+
+    const bigAmount = new Big(amount)
+      .times(new Big(10).pow(decimalPoint))
+      .toString();
+
+    try {
+      const response = await this.fetchWallet("transfer", {
+        destinations: [{ address, amount: bigAmount, asset_id: assetId }],
+        fee: "10000000000",
+        mixin: auditable ? 0 : 15,
+      });
+
+      if (response.data.result) {
+        return response.data.result;
+      } else if (
+        response.data.error &&
+        response.data.error.message === "WALLET_RPC_ERROR_CODE_NOT_ENOUGH_MONEY"
+      ) {
+        throw new ZanoError("Not enough funds", "NOT_ENOUGH_FUNDS");
+      } else {
+        throw new ZanoError("Error sending transfer", "TRANSFER_ERROR");
+      }
+    } catch (error) {
+      if (error instanceof ZanoError) {
+        throw error;
+      } else {
+        throw new ZanoError("Failed to send transfer", "TRANSFER_SEND_ERROR");
+      }
+    }
+  }
+
+  async getAliasByAddress(address: string) {
+    try {
+      const response = await this.fetchDaemon("get_alias_by_address", address);
+
+      if (response.data.result) {
+        return response.data.result;
+      } else {
+        throw new ZanoError(
+          `Error fetching alias for address ${address}`,
+          "ALIAS_FETCH_ERROR"
+        );
+      }
+    } catch (error) {
+      throw new ZanoError("Failed to fetch alias", "ALIAS_FETCH_ERROR");
+    }
+  }
+
+  async getBalances() {
+    try {
+      const response = await this.fetchWallet("getbalance", {});
+      const balancesData = response.data.result.balances as APIBalance[];
+
+      const balances = balancesData.map((asset) => ({
+        name: asset.asset_info.full_name,
+        ticker: asset.asset_info.ticker,
+        id: asset.asset_info.asset_id,
+        amount: new Big(asset.unlocked)
+          .div(new Big(10).pow(asset.asset_info.decimal_point))
+          .toString(),
+        awaiting_in: new Big(asset.awaiting_in).toString(),
+        awaiting_out: new Big(asset.awaiting_out).toString(),
+        total: new Big(asset.total).toString(),
+        unlocked: new Big(asset.unlocked).toString(),
+        asset_info: asset.asset_info,
+      }));
+
+      return balances.sort((a, b) => {
+        if (a.id === ZANO_ASSET_ID) return -1;
+        if (b.id === ZANO_ASSET_ID) return 1;
+        return 0;
+      }) as BalanceInfo[];
+    } catch (error) {
+      throw new ZanoError("Failed to fetch balances", "BALANCES_FETCH_ERROR");
+    }
+  }
+
+  async validateWallet(authData: AuthData) {
+    const { message, address, signature } = authData;
+
+    const alias = (authData as AliasAuth).alias || undefined;
+    const pkey = (authData as PkeyAuth).pkey || undefined;
+
+    if (!message || (!alias && !pkey) || !signature) {
+      return false;
+    }
+
+    const validationParams: ValidationParams = {
+      buff: Buffer.from(message).toString("base64"),
+      sig: signature,
+    };
+
+    if (alias) {
+      validationParams["alias"] = alias;
+    } else {
+      validationParams["pkey"] = pkey;
+    }
+
+    const response = await this.fetchDaemon(
+      "validate_signature",
+      validationParams
+    );
+
+    const valid = response?.data?.result?.status === "OK";
+
+    if (!valid) {
+      return false;
+    }
+
+    if (alias) {
+      const aliasDetailsResponse = await this.fetchDaemon("get_alias_details", {
+        alias: alias,
+      });
+
+      const aliasDetails = aliasDetailsResponse?.data?.result?.alias_details;
+      const aliasAddress = aliasDetails?.address;
+
+      const addressValid = !!aliasAddress && aliasAddress === address;
+
+      if (!addressValid) {
+        return false;
+      }
+    }
+
+    return valid;
+  }
+
+  async getTxs(params: GetTxsParams) {
+    const txs = await this.fetchWallet("get_recent_txs_and_info2", {
+      count: params.count,
+      exclude_mining_txs: params.exclude_mining_txs || false,
+      exclude_unconfirmed: params.exclude_unconfirmed || false,
+      offset: params.offset,
+      order: params.order || "FROM_END_TO_BEGIN",
+      update_provision_info: params.update_provision_info || true,
+    });
+
+    return txs.data.result as TxInfo;
+  }
+  async getAliasDetails(alias: string) {
+    try {
+        const response = await this.fetchDaemon("get_alias_details", {
+            alias,
+        });
+        if (response.data.result) {
+            return response.data.result as AliasDetails;
+        } else {
+            throw new ZanoError(
+                `Error fetching alias ${alias}`,
+                "ALIAS_FETCH_ERROR"
+            );
+        }
+    } catch {
+        throw new ZanoError("Failed to fetch alias", "ALIAS_FETCH_ERROR");
+    }
+}
+
+}
+
+export default ServerWallet;