zano_web3 1.0.0

package/README.md

@@ -0,0 +1,97 @@
+
+# ZanoWallet
+
+`zano-web3` is a TypeScript library for interacting with the ZanoWallet extension in the browser. It allows you to connect to a user's ZanoWallet, handle authentication, and manage wallet credentials.
+
+## Features
+
+- **Easy Integration**: Simplifies the process of connecting to the ZanoWallet extension.
+- **Local Storage Support**: Optionally store wallet credentials in local storage.
+- **Customizable**: Offers hooks for various connection lifecycle events.
+- **Error Handling**: Provides a structured way to handle errors during the connection process.
+
+## Installation
+
+To install `zano-web3`, use npm or yarn:
+
+```bash
+npm install zano-web3
+```
+
+or
+
+```bash
+yarn add zano-web3
+```
+
+## Usage
+
+### Importing the Library
+
+```typescript
+import ZanoWallet from 'zano-web3';
+```
+
+### Creating a ZanoWallet Instance
+
+To create a `ZanoWallet` instance, you need to provide configuration options via the `ZanoWalletParams` interface.
+
+```typescript
+const zanoWallet = new ZanoWallet({
+    authPath: '/api/auth', // Custom server path for authentication
+    useLocalStorage: true, // Store wallet credentials in local storage (default: true)
+    aliasRequired: false,  // Whether an alias is required (optional)
+    customLocalStorageKey: 'myWalletKey', // Custom key for local storage (optional)
+    customNonce: 'customNonceValue', // Custom nonce for signing (optional)
+    disableServerRequest: false, // Disable server request after signing (optional)
+
+    onConnectStart: () => {
+        console.log('Connecting to ZanoWallet...');
+    },
+    onConnectEnd: (data) => {
+        console.log('Connected:', data);
+    },
+    onConnectError: (error) => {
+        console.error('Connection error:', error);
+    },
+    beforeConnect: async () => {
+        console.log('Preparing to connect...');
+    },
+    onLocalConnectEnd: (data) => {
+        console.log('Local connection established:', data);
+    }
+});
+```
+
+### Connecting to ZanoWallet
+
+To initiate the connection process, call the `connect` method:
+
+```typescript
+await zanoWallet.connect();
+```
+
+### Handling Wallet Credentials
+
+You can manually manage wallet credentials using `getSavedWalletCredentials` and `setWalletCredentials` methods:
+
+```typescript
+const credentials = zanoWallet.getSavedWalletCredentials();
+if (credentials) {
+    console.log('Stored credentials:', credentials);
+}
+
+zanoWallet.setWalletCredentials({
+    nonce: 'newNonce',
+    signature: 'newSignature',
+    publicKey: 'newPublicKey'
+});
+```
+
+## Requirements
+
+- ZanoWallet browser extension must be installed.
+
+## Contributing
+
+If you find any issues or want to contribute, please create a pull request or submit an issue.

package/dist/zanoWallet.d.ts

@@ -0,0 +1,31 @@
+interface ZanoWalletParams {
+    authPath: string;
+    useLocalStorage?: boolean;
+    aliasRequired?: boolean;
+    customLocalStorageKey?: string;
+    customNonce?: string;
+    customServerPath?: string;
+    disableServerRequest?: boolean;
+    onConnectStart?: (...params: any) => any;
+    onConnectEnd?: (...params: any) => any;
+    onConnectError?: (...params: any) => any;
+    beforeConnect?: (...params: any) => any;
+    onLocalConnectEnd?: (...params: any) => any;
+}
+interface WalletCredentials {
+    nonce: string;
+    signature: string;
+    publicKey: string;
+}
+declare class ZanoWallet {
+    private DEFAULT_LOCAL_STORAGE_KEY;
+    private localStorageKey;
+    private params;
+    private zanoWallet;
+    constructor(params: ZanoWalletParams);
+    private handleError;
+    getSavedWalletCredentials(): WalletCredentials | undefined;
+    setWalletCredentials(credentials: WalletCredentials | undefined): void;
+    connect(): Promise<void>;
+}
+export default ZanoWallet;

package/dist/zanoWallet.js

@@ -0,0 +1,190 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+var uuid_1 = require("uuid");
+var ZanoWallet = /** @class */ (function () {
+    function ZanoWallet(params) {
+        this.DEFAULT_LOCAL_STORAGE_KEY = "wallet";
+        if (typeof window === 'undefined') {
+            throw new Error('ZanoWallet can only be used in the browser');
+        }
+        if (!window.zano) {
+            throw new Error('ZanoWallet requires the ZanoWallet extension to be installed');
+        }
+        this.params = params;
+        this.zanoWallet = window.zano;
+        this.localStorageKey = params.customLocalStorageKey || this.DEFAULT_LOCAL_STORAGE_KEY;
+    }
+    ZanoWallet.prototype.handleError = function (_a) {
+        var message = _a.message;
+        if (this.params.onConnectError) {
+            this.params.onConnectError(message);
+        }
+        else {
+            console.error(message);
+        }
+    };
+    ZanoWallet.prototype.getSavedWalletCredentials = function () {
+        var savedWallet = localStorage.getItem(this.localStorageKey);
+        if (!savedWallet)
+            return undefined;
+        try {
+            return JSON.parse(savedWallet);
+        }
+        catch (_a) {
+            return undefined;
+        }
+    };
+    ZanoWallet.prototype.setWalletCredentials = function (credentials) {
+        if (credentials) {
+            localStorage.setItem(this.localStorageKey, JSON.stringify(credentials));
+        }
+        else {
+            localStorage.removeItem(this.localStorageKey);
+        }
+    };
+    ZanoWallet.prototype.connect = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var walletData, nonce, signature, publicKey, existingWallet, generatedNonce, signResult, serverData, result;
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (!this.params.beforeConnect) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.params.beforeConnect()];
+                    case 1:
+                        _b.sent();
+                        _b.label = 2;
+                    case 2:
+                        if (this.params.onConnectStart) {
+                            this.params.onConnectStart();
+                        }
+                        return [4 /*yield*/, window.zano.request('GET_WALLET_DATA')];
+                    case 3:
+                        walletData = (_b.sent()).data;
+                        if (!(walletData === null || walletData === void 0 ? void 0 : walletData.address)) {
+                            return [2 /*return*/, this.handleError({ message: 'Companion is offline' })];
+                        }
+                        if (!(walletData === null || walletData === void 0 ? void 0 : walletData.alias) && this.params.aliasRequired) {
+                            return [2 /*return*/, this.handleError({ message: 'Alias not found' })];
+                        }
+                        nonce = "";
+                        signature = "";
+                        publicKey = "";
+                        existingWallet = this.params.useLocalStorage ? this.getSavedWalletCredentials() : undefined;
+                        if (!existingWallet) return [3 /*break*/, 4];
+                        nonce = existingWallet.nonce;
+                        signature = existingWallet.signature;
+                        publicKey = existingWallet.publicKey;
+                        return [3 /*break*/, 6];
+                    case 4:
+                        generatedNonce = this.params.customNonce || (0, uuid_1.v4)();
+                        return [4 /*yield*/, this.zanoWallet.request('REQUEST_MESSAGE_SIGN', {
+                                message: generatedNonce
+                            }, null)];
+                    case 5:
+                        signResult = _b.sent();
+                        if (!((_a = signResult === null || signResult === void 0 ? void 0 : signResult.data) === null || _a === void 0 ? void 0 : _a.result)) {
+                            return [2 /*return*/, this.handleError({ message: 'Failed to sign message' })];
+                        }
+                        nonce = generatedNonce;
+                        signature = signResult.data.result.sig;
+                        publicKey = signResult.data.result.pkey;
+                        _b.label = 6;
+                    case 6:
+                        serverData = {
+                            alias: walletData.alias,
+                            address: walletData.address,
+                            signature: signature,
+                            publicKey: publicKey,
+                            message: nonce,
+                            isSavedData: !!existingWallet
+                        };
+                        if (this.params.onLocalConnectEnd) {
+                            this.params.onLocalConnectEnd(serverData);
+                        }
+                        if (!!this.params.disableServerRequest) return [3 /*break*/, 8];
+                        return [4 /*yield*/, fetch(this.params.customServerPath || "/api/auth", {
+                                method: "POST",
+                                headers: {
+                                    "Content-Type": "application/json",
+                                },
+                                body: JSON.stringify({
+                                    data: serverData
+                                })
+                            })
+                                .then(function (res) { return res.json(); })
+                                .catch(function (e) { return ({
+                                success: false,
+                                error: e.message
+                            }); })];
+                    case 7:
+                        result = _b.sent();
+                        if (!(result === null || result === void 0 ? void 0 : result.success) || !(result === null || result === void 0 ? void 0 : result.data)) {
+                            return [2 /*return*/, this.handleError({ message: result.error })];
+                        }
+                        if (!existingWallet && this.params.useLocalStorage) {
+                            this.setWalletCredentials({
+                                publicKey: publicKey,
+                                signature: signature,
+                                nonce: nonce
+                            });
+                        }
+                        if (this.params.onConnectEnd) {
+                            this.params.onConnectEnd(__assign(__assign({}, serverData), { token: result.data.token }));
+                        }
+                        _b.label = 8;
+                    case 8: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return ZanoWallet;
+}());
+exports.default = ZanoWallet;

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "zano_web3",
+  "version": "1.0.0",
+  "description": "",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/uuid": "^10.0.0",
+    "typescript": "^5.5.4"
+  },
+  "dependencies": {
+    "uuid": "^10.0.0"
+  }
+}

package/src/zanoWallet.ts

@@ -0,0 +1,192 @@
+import { v4 as uuidv4 } from 'uuid';
+
+interface ZanoWalletParams {
+    authPath: string;
+    useLocalStorage?: boolean; // default: true
+    aliasRequired?: boolean; 
+    customLocalStorageKey?: string;
+    customNonce?: string;
+    customServerPath?: string;
+    disableServerRequest?: boolean;
+
+    onConnectStart?: (...params: any) => any;
+    onConnectEnd?: (...params: any) => any;
+    onConnectError?: (...params: any) => any;
+
+    beforeConnect?: (...params: any) => any;
+    onLocalConnectEnd?: (...params: any) => any;
+}
+
+type GlobalWindow = Window & typeof globalThis;
+
+interface ZanoWindowParams {
+    request: (str: string, params?: any, timeoutMs?: number | null) => Promise<any>;
+}
+
+type ZanoWindow = Omit<GlobalWindow, 'Infinity'> & {
+    zano: ZanoWindowParams
+}
+
+interface WalletCredentials {
+    nonce: string;
+    signature: string;
+    publicKey: string;
+}
+
+class ZanoWallet {
+
+    private DEFAULT_LOCAL_STORAGE_KEY = "wallet";
+    private localStorageKey: string;
+
+    private params: ZanoWalletParams;
+    private zanoWallet: ZanoWindowParams;
+    
+    constructor(params: ZanoWalletParams) {
+
+        if (typeof window === 'undefined') {
+            throw new Error('ZanoWallet can only be used in the browser');
+        }
+
+        if (!((window as unknown) as ZanoWindow).zano) {
+            throw new Error('ZanoWallet requires the ZanoWallet extension to be installed');
+        }
+
+        this.params = params;
+        this.zanoWallet = ((window as unknown) as ZanoWindow).zano;
+        this.localStorageKey = params.customLocalStorageKey || this.DEFAULT_LOCAL_STORAGE_KEY;
+    }
+    
+
+    private handleError({ message } : { message: string }) {
+        if (this.params.onConnectError) {
+            this.params.onConnectError(message);
+        } else {
+            console.error(message);
+        }
+    }
+
+    getSavedWalletCredentials() {
+        const savedWallet = localStorage.getItem(this.localStorageKey);
+        if (!savedWallet) return undefined;
+        try {
+            return JSON.parse(savedWallet) as WalletCredentials;
+        } catch {
+            return undefined;
+        }
+    }
+
+    setWalletCredentials(credentials: WalletCredentials | undefined) {
+        if (credentials) {
+            localStorage.setItem(this.localStorageKey, JSON.stringify(credentials));
+        } else {
+            localStorage.removeItem(this.localStorageKey);
+        }
+    }
+
+    async connect() {
+
+        if (this.params.beforeConnect) {
+            await this.params.beforeConnect();
+        }
+
+        if (this.params.onConnectStart) {
+            this.params.onConnectStart();
+        }
+
+        const walletData = (await ((window as unknown) as ZanoWindow).zano.request('GET_WALLET_DATA')).data;
+
+
+        if (!walletData?.address) {
+            return this.handleError({ message: 'Companion is offline' });
+        }
+
+        if (!walletData?.alias && this.params.aliasRequired) {
+            return this.handleError({ message: 'Alias not found' });
+        }
+
+        let nonce = "";
+        let signature = "";
+        let publicKey = "";
+
+
+        const existingWallet = this.params.useLocalStorage ? this.getSavedWalletCredentials() : undefined;
+
+        if (existingWallet) {
+            nonce = existingWallet.nonce;
+            signature = existingWallet.signature;
+            publicKey = existingWallet.publicKey;
+        } else {
+            const generatedNonce = this.params.customNonce || uuidv4();
+
+            const signResult = await this.zanoWallet.request(
+                'REQUEST_MESSAGE_SIGN', 
+                {
+                    message: generatedNonce
+                }, 
+                null
+            );
+
+            if (!signResult?.data?.result) {
+                return this.handleError({ message: 'Failed to sign message' });
+            }      
+
+            nonce = generatedNonce;
+            signature = signResult.data.result.sig;
+            publicKey = signResult.data.result.pkey;
+        }
+
+        
+        const serverData = {
+            alias: walletData.alias,
+            address: walletData.address,
+            signature,
+            publicKey,
+            message: nonce,
+            isSavedData: !!existingWallet
+        }
+
+        if (this.params.onLocalConnectEnd) {
+            this.params.onLocalConnectEnd(serverData);
+        }
+
+        if (!this.params.disableServerRequest) {
+            const result = await fetch( this.params.customServerPath || "/api/auth", {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                },
+                body: JSON.stringify(
+                    {
+                        data: serverData
+                    }
+                )
+            })
+            .then(res => res.json())
+            .catch((e) => ({
+                success: false,
+                error: e.message
+            }));  
+
+            if (!result?.success || !result?.data) {
+                return this.handleError({ message: result.error });
+            }
+
+            if (!existingWallet && this.params.useLocalStorage) {
+                this.setWalletCredentials({
+                    publicKey,
+                    signature,
+                    nonce
+                });
+            }
+
+            if (this.params.onConnectEnd) {
+                this.params.onConnectEnd({
+                    ...serverData,
+                    token: result.data.token
+                });
+            }
+        }
+    }
+}
+
+export default ZanoWallet;

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES5",                          
+    "module": "CommonJS",                     
+    "declaration": true,                     
+    "outDir": "./dist",                      
+    "strict": true,                          
+    "esModuleInterop": true                  
+  },
+  "include": ["src/**/*"]
+}