zano_web3 6.13.0 → 6.15.0

package/README.md

@@ -204,6 +204,7 @@ export interface Wallet {
 - `sendTransfer(assetId: string, address: string, amount: string)`: Sends a transfer to an address.
 - `getBalances()`: Retrieves the balances.
 - `validateWallet(rpcUrl: string, authData: AuthData)`: Validates the wallet.
+- `getAliasDetails(alias:string)` : Retrieves information about a specific address alias.
 
 
 #### 1. **Updating Wallet RPC URL**
@@ -370,6 +371,28 @@ import { AuthData } from "./types";
 })();
 ```
 
+#### 9. **Get Alias details**
+
+```javascript
+import { ServerWallet } from "zano_web3/server";
+
+const alias = "alias";
+
+(async (alias) => {
+    const zanoServerAPI = new ServerWallet({
+        walletUrl: "http://127.0.0.1:11211/json_rpc",
+        daemonUrl: "http://127.0.0.1:11211/json_rpc"
+    });
+
+    try {
+        const aliasDetails = await zanoServerAPI.getAliasDetails(alias);
+        console.log(aliasDetails);
+    } catch (error) {
+        console.error(error.message);
+    }
+})(alias);
+```
+
 ## Requirements
 
 - Correct RPC URLs for the wallet and daemon.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zano_web3",
-  "version": "6.13.0",
+  "version": "6.15.0",
   "description": "",
   "type": "module",
   "scripts": {

package/server/src/server.ts

@@ -1,290 +1,316 @@
-import axios from 'axios';
+import axios from "axios";
 import Big from "big.js";
 import {
-    AuthData,
-    AliasAuth,
-    PkeyAuth,
-    ValidationParams,
-    BalanceInfo,
-    TxInfo,
-} from './types';
-
-import { ZANO_ASSET_ID, ZanoError } from './utils';
-import { APIAsset, APIBalance } from './types';
-
+  AuthData,
+  AliasAuth,
+  PkeyAuth,
+  ValidationParams,
+  BalanceInfo,
+  TxInfo,
+  AliasDetails,
+} from "./types";
+
+import { ZANO_ASSET_ID, ZanoError } from "./utils";
+import { APIAsset, APIBalance } from "./types";
 
 interface ConstructorParams {
-    walletUrl: string;
-    daemonUrl: string;
+  walletUrl: string;
+  daemonUrl: string;
 }
 
 interface GetTxsParams {
-    count: number;
-    offset: number;
-    exclude_mining_txs?: boolean;
-    exclude_unconfirmed?: boolean;
-    order?: string;
-    update_provision_info?: boolean;
+  count: number;
+  offset: number;
+  exclude_mining_txs?: boolean;
+  exclude_unconfirmed?: boolean;
+  order?: string;
+  update_provision_info?: boolean;
 }
 
 class ServerWallet {
-    private walletUrl: string;
-    private daemonUrl: string;
+  private walletUrl: string;
+  private daemonUrl: string;
+
+  constructor(params: ConstructorParams) {
+    this.walletUrl = params.walletUrl;
+    this.daemonUrl = params.daemonUrl;
+  }
+
+  private async fetchDaemon(method: string, params: any) {
+    const headers = { "Content-Type": "application/json" };
+
+    const data = {
+      jsonrpc: "2.0",
+      id: 0,
+      method: method,
+      params: params,
+    };
 
-    constructor(params: ConstructorParams) {
-        this.walletUrl = params.walletUrl;
-        this.daemonUrl = params.daemonUrl;
-    }
+    return axios.post(this.daemonUrl, data, { headers });
+  }
+
+  private async fetchWallet(method: string, params: any) {
+    const headers = { "Content-Type": "application/json" };
+
+    const data = {
+      jsonrpc: "2.0",
+      id: 0,
+      method: method,
+      params: params,
+    };
 
-    private async fetchDaemon(method: string, params: any) {
-        const headers = { "Content-Type": "application/json" };
+    return axios.post(this.walletUrl, data, { headers });
+  }
 
-        const data = {
-            jsonrpc: "2.0",
-            id: 0,
-            method: method,
-            params: params
-        };
+  async updateWalletRpcUrl(rpcUrl: string) {
+    this.walletUrl = rpcUrl;
+  }
 
-        return axios.post(this.daemonUrl, data, { headers })
+  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"
+        );
+      }
     }
 
-    private async fetchWallet(method: string, params: any) {
-        const headers = { "Content-Type": "application/json" };
+    return allAssets as APIAsset[];
+  }
 
-        const data = {
-            jsonrpc: "2.0",
-            id: 0,
-            method: method,
-            params: params
-        };
+  async getAssetDetails(assetId: string) {
+    const assets = await this.getAssetsList();
+    const asset = assets.find((a) => a.asset_id === assetId);
 
-        return axios.post(this.walletUrl, data, { headers })
+    if (!asset) {
+      throw new ZanoError(
+        `Asset with ID ${assetId} not found`,
+        "ASSET_NOT_FOUND"
+      );
     }
 
-    async updateWalletRpcUrl(rpcUrl: string) {
-        this.walletUrl = rpcUrl;
+    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;
 
-    async updateDaemonRpcUrl(rpcUrl: string) {
-        this.daemonUrl = rpcUrl;
+    if (assetId === ZANO_ASSET_ID) {
+      decimalPoint = 12;
+    } else {
+      const asset = await this.getAssetDetails(assetId);
+      decimalPoint = asset.decimal_point;
     }
 
-    async getAssetsList() {
-        const count = 100; // Number of items to fetch per request
-        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");
-            }
-        }
+    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");
+    }
 
-        return allAssets as APIAsset[];
-    };
+    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 getAssetDetails(assetId: string) {
-        const assets = await this.getAssetsList();
-        const asset = assets.find((a) => a.asset_id === assetId);
+  async validateWallet(authData: AuthData) {
+    const { message, address, signature } = authData;
 
-        if (!asset) {
-            throw new ZanoError(
-                `Asset with ID ${assetId} not found`,
-                "ASSET_NOT_FOUND"
-            );
-        }
+    const alias = (authData as AliasAuth).alias || undefined;
+    const pkey = (authData as PkeyAuth).pkey || undefined;
 
-        return asset as APIAsset;
+    if (!message || (!alias && !pkey) || !signature) {
+      return false;
     }
 
-
-    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");
-        }
+    const validationParams: ValidationParams = {
+      buff: Buffer.from(message).toString("base64"),
+      sig: signature,
     };
 
-    async sendTransfer(assetId: string, address: string, amount: string) {
-        let decimalPoint: number;
+    if (alias) {
+      validationParams["alias"] = alias;
+    } else {
+      validationParams["pkey"] = pkey;
+    }
 
-        if (assetId === ZANO_ASSET_ID) {
-            decimalPoint = 12;
-        } else {
-            const asset = await this.getAssetDetails(assetId);
-            decimalPoint = asset.decimal_point;
-        }
+    const response = await this.fetchDaemon(
+      "validate_signature",
+      validationParams
+    );
 
-        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: 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; // Re-throw the custom error
-            } else {
-                throw new ZanoError("Failed to send transfer", "TRANSFER_SEND_ERROR");
-            }
-        }
-    };
+    const valid = response?.data?.result?.status === "OK";
 
-    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");
-        }
+    if (!valid) {
+      return false;
     }
 
-    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");
-        }
-    };
+    if (alias) {
+      const aliasDetailsResponse = await this.fetchDaemon("get_alias_details", {
+        alias: alias,
+      });
 
-    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;
+      const aliasDetails = aliasDetailsResponse?.data?.result?.alias_details;
+      const aliasAddress = aliasDetails?.address;
+
+      const addressValid = !!aliasAddress && aliasAddress === address;
+
+      if (!addressValid) {
+        return false;
+      }
     }
 
-    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 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,
         });
-
-        return txs.data.result as TxInfo;
+        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;
+export default ServerWallet;

package/server/src/types.ts

@@ -100,4 +100,10 @@ export interface TxInfo {
     };
     total_transfers: number;
     transfers: Transfer[];
+}
+
+export interface AliasDetails {
+    address: string;
+    comment: string;
+    tracking_key: string;
 }