@docknetwork/wallet-sdk-wasm 0.4.19

package/lib/account-df68209b.js

@@ -0,0 +1,764 @@
+import assert from 'assert';
+import { isAddressValid } from './core/validation.mjs';
+import { walletService } from './services/wallet/service.mjs';
+import { utilCryptoService } from './services/util-crypto/service.mjs';
+import { keyringService } from './services/keyring/service.mjs';
+import { substrateService } from './services/substrate/service.mjs';
+import { polkadotService } from './services/polkadot/service.mjs';
+import { v4 } from 'uuid';
+import { getStorage } from './core/storage.mjs';
+import { dockService } from './services/dock/service.mjs';
+import { EventManager } from './modules/event-manager.mjs';
+import { NetworkManager } from './modules/network-manager.mjs';
+import { migrate } from './modules/data-migration.mjs';
+import { Logger } from './core/logger.mjs';
+import { Errors } from './errors.mjs';
+import { KeypairTypes } from './types.mjs';
+
+var doc2213 = {
+	"@context": [
+		"https://w3id.org/wallet/v1"
+	],
+	id: "credential-1652390503413",
+	value: {
+		"@context": [
+			"https://www.w3.org/2018/credentials/v1",
+			{
+				dk: "https://ld.dock.io/credentials#",
+				BasicCredential: "dk:BasicCredential",
+				subjectName: "dk:subjectName",
+				title: "dk:title",
+				name: "dk:name",
+				description: "dk:description",
+				logo: "dk:logo"
+			}
+		],
+		credentialStatus: {
+			id: "rev-reg:dock:0x8e4ff3d6de36a3e4dbd014b5979e6fc0ab1e4c0a5f1ceddae2c7c67a4b94d0de",
+			type: "CredentialStatusList2017"
+		},
+		id: "https://creds.dock.io/79277556ab5504ec064492780d3678d04f9f4ec370de28537e9d5be09f11df92",
+		type: [
+			"VerifiableCredential",
+			"BasicCredential"
+		],
+		credentialSubject: {
+			id: "planespotter325",
+			subjectName: "Oleh Yatskiv",
+			title: "Beta Testing Credential"
+		},
+		issuanceDate: "2022-05-10T10:06:49.346Z",
+		proof: {
+			type: "Ed25519Signature2018",
+			created: "2022-05-10T10:07:08Z",
+			verificationMethod: "did:dock:5C53c6uirausdvARD891dyyEkQE388iXhDwypkmp1nHh1odv#keys-1",
+			proofPurpose: "assertionMethod",
+			proofValue: "z2RVKT1jYhooV3JidULqxTwPq2R41RqPNEMf14GWMTrh2NpzoFj4uiEzkzcu3HYZ8C8Vc7qBctVALMjXferqTiJkQ"
+		},
+		issuer: {
+			name: "Dock Beta Testing",
+			description: "",
+			logo: "data:image/png;base64,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",
+			id: "did:dock:5C53c6uirausdvARD891dyyEkQE388iXhDwypkmp1nHh1odv"
+		}
+	},
+	type: "VerifiableCredential"
+};
+var legacyWalletSchema = {
+	"doc:d4bd8145-4a56-456e-9b78-71509184f6ed": {
+	"@context": [
+		"https://w3id.org/wallet/v1"
+	],
+	id: "6ee76a80-bdf2-4cf8-9647-4897ed6feadd",
+	name: "Account 1",
+	type: "Mnemonic",
+	value: "toe crowd portion cook feel minute deny piece feel barrel member swarm"
+},
+	"doc:74366f2f-a137-46f1-b661-be2956d9afb2": {
+	"@context": [
+		"https://w3id.org/wallet/v1"
+	],
+	id: "0a7d45d3-8ca4-41a2-93c8-d4bec5652376",
+	name: "mnemonic 1",
+	type: "Mnemonic",
+	value: "exact next frown coconut exit pledge blind program film elephant wife clutch"
+},
+	"doc:670ef0a2-c748-45ab-9515-460d907ba529": {
+	"@context": [
+		"https://w3id.org/wallet/v1"
+	],
+	id: "7e0b6479-59c8-4f76-95d5-d25f7413751f",
+	name: "mnemonic1 ",
+	type: "Mnemonic",
+	value: "exact next frown coconut exit pledge blind program film elephant wife clutch"
+},
+	"doc:497337c2-29fc-4a88-9b78-ee55abd0a500": {
+	"@context": [
+		"https://w3id.org/wallet/v1"
+	],
+	id: "37g1HpqrRjWozRxT5MCpqUDxHQtu2ASPy6yJRD5cqKRVBefS",
+	type: "Account",
+	correlation: [
+		"7e0b6479-59c8-4f76-95d5-d25f7413751f"
+	],
+	meta: {
+		name: "mnemonic1 ",
+		keypairType: "sr25519",
+		derivationPath: "",
+		hasBackup: true,
+		balance: 0
+	}
+},
+	"doc:069c5733-8516-4dff-aa91-cb3eefc3f16d": {
+	"@context": [
+		"https://w3id.org/wallet/v1"
+	],
+	id: "80f68f17-14a8-4f2d-9865-b1477e605115",
+	name: "test 33",
+	type: "KeyPair",
+	value: {
+		encoded: "MFMCAQEwBQYDK2VwBCIEIGhWQpGhRsLAOg8FFbvjUOOZ0UZZX2OJzIKhrTJ2Od1mKEidt13wS9Kxefy98pm/8w9an45To/IuYiKX7PlDyS6hIwMhAP4WQCN9VTz2Hn18GOwXw9ZhVZyCYQnbE5DcZeMamHYt",
+		encoding: {
+			content: [
+				"pkcs8",
+				"sr25519"
+			],
+			type: [
+				"none"
+			],
+			version: "3"
+		},
+		address: "3CH1Ce5k516MNoyJvRbq4CtuiSDisa8SF9JBqCcSYRAEzgUk",
+		meta: {
+			genesisHash: "0x17643cd935f8379c6683c74f739460be4ccc4e4c30b0183bdb2fb9973af242f1",
+			isHardware: false,
+			name: "test 33",
+			tags: [
+			],
+			whenCreated: 1654447770598
+		}
+	}
+},
+	"doc:d56aa925-2da8-469a-ab4b-c4878e19b9fc": {
+	"@context": [
+		"https://w3id.org/wallet/v1"
+	],
+	id: "3CH1Ce5k516MNoyJvRbq4CtuiSDisa8SF9JBqCcSYRAEzgUk",
+	type: "Account",
+	correlation: [
+		"80f68f17-14a8-4f2d-9865-b1477e605115"
+	],
+	meta: {
+		name: "test 33",
+		hasBackup: true,
+		balance: 0
+	}
+},
+	"doc:69cfaf57-4b04-40b4-9d2a-143c4f05a2e3": {
+	"@context": [
+		"https://w3id.org/wallet/v1"
+	],
+	id: "dd3868e5-dab7-4e43-95ac-530a65ef8917",
+	name: "ACCOUNT NEW",
+	type: "Mnemonic",
+	value: "surround cotton ecology happy artist opera alert resemble jewel jaguar risk rude"
+},
+	"doc:729e40eb-e36c-460e-a85b-0f9ad2fbf199": {
+	"@context": [
+		"https://w3id.org/wallet/v1"
+	],
+	id: "3BcMTtyijuEQYBfSCR45jaZUCgEeCgLCNeJGZm336S638C7G",
+	type: "Account",
+	correlation: [
+		"dd3868e5-dab7-4e43-95ac-530a65ef8917"
+	],
+	meta: {
+		name: "ACCOUNT NEW",
+		keypairType: "sr25519",
+		derivationPath: "",
+		hasBackup: false,
+		balance: 0
+	}
+},
+	doc2213: doc2213
+};
+
+// @ts-nocheck
+/** Wallet events */
+const WalletEvents = {
+    ready: 'ready',
+    error: 'error',
+    migrated: 'migrated',
+    statusUpdated: 'status-updated',
+    documentAdded: 'document-added',
+    documentUpdated: 'document-updated',
+    documentRemoved: 'document-removed',
+    walletDeleted: 'wallet-deleted',
+    walletImported: 'wallet-imported',
+    networkUpdated: 'network-updated',
+    networkConnected: 'network-connected',
+    networkError: 'network-error',
+};
+/**
+ * Can be used to debug the data migration behavior in the wallet
+ */
+const MOCK_STORAGE = process.env.MOCK_STORAGE;
+async function shouldMockStorage(walletId) {
+    if (MOCK_STORAGE !== 'true') {
+        return;
+    }
+    await getStorage().setItem(walletId, JSON.stringify(legacyWalletSchema));
+}
+// const environment = getEnvironment();
+// if (environment !== 'reactnative') {
+// require('../setup-nodejs');
+// }
+/**
+ * Wallet
+ */
+class Wallet {
+    networkManager;
+    context;
+    status;
+    apiConnected;
+    eventManager;
+    walletId;
+    accounts;
+    /**
+     * @constructor
+     * @param {object} params
+     */
+    constructor({ walletId = 'wallet', context = ['https://w3id.org/wallet/v1'], } = {}) {
+        this.walletId = walletId;
+        this.context = context;
+        this.networkManager = NetworkManager.getInstance();
+        this.eventManager = new EventManager();
+        this.accounts = Accounts.getInstance({ wallet: this });
+    }
+    async recoverFromBadState() {
+        const storageItems = await getStorage().getItem(this.walletId);
+        const walletData = JSON.parse(storageItems);
+        Object.keys(walletData).forEach(docKey => {
+            const document = walletData[docKey];
+            if (!document['@context']) {
+                document['@context'] = this.context;
+            }
+        });
+        await getStorage().setItem(this.walletId, JSON.stringify(walletData));
+        await this.createWallet();
+    }
+    async createWallet() {
+        await walletService.create({
+            walletId: this.walletId,
+            type: 'rpc',
+        });
+        await walletService.sync();
+        await walletService.load();
+    }
+    /**
+     * Get the y value.
+     * @return {Promise} The y value.
+     */
+    async load() {
+        if (this.status === 'loading') {
+            return this.eventManager.waitFor(WalletEvents.ready);
+        }
+        if (this.status === 'ready') {
+            return;
+        }
+        this.setStatus('loading');
+        // TODO: get network from dataStore
+        const networkId = (await getStorage().getItem('networkId')) || 'mainnet';
+        this.networkManager.setNetworkId(networkId);
+        await shouldMockStorage(this.walletId);
+        try {
+            await utilCryptoService.cryptoWaitReady();
+            await keyringService.initialize({
+                ss58Format: this.networkManager.getNetworkInfo().addressPrefix,
+            });
+            try {
+                await this.createWallet();
+            }
+            catch (err) {
+                await this.recoverFromBadState();
+            }
+            this.setStatus('ready');
+            this.eventManager.emit(WalletEvents.ready);
+            this.initNetwork();
+            this.migrated = await migrate({ wallet: this });
+            this.eventManager.emit(WalletEvents.migrated);
+        }
+        catch (err) {
+            this.setStatus('error');
+            this.eventManager.emit(WalletEvents.error, err);
+            throw err;
+        }
+    }
+    async getVersion() {
+        const docs = await this.query({});
+        const versionDoc = docs.find((item) => item.type === 'Metadata' && !!item.walletVersion);
+        return (versionDoc && versionDoc.walletVersion) || '0.1';
+    }
+    /**
+     *
+     * Close wallet
+     */
+    async close() {
+        await dockService.disconnect();
+        this.setStatus('closed');
+    }
+    async switchNetwork(networkId) {
+        getStorage().setItem('networkId', networkId);
+        this.networkManager.setNetworkId(networkId);
+        await this.initNetwork();
+    }
+    /**
+     * delete wallet
+     */
+    async deleteWallet() {
+        this.eventManager.emit(WalletEvents.walletDeleted);
+        await getStorage().removeItem('logs');
+        await getStorage().removeItem('transactions');
+        await getStorage().removeItem(this.walletId);
+        await walletService.create({
+            walletId: this.walletId,
+        });
+        await walletService.load();
+        await walletService.sync();
+    }
+    /**
+     *
+     * @param {*} status
+     */
+    setStatus(status) {
+        assert(!!status, 'status is required');
+        this.status = status;
+        this.eventManager.emit(WalletEvents.statusUpdated, status);
+    }
+    /**
+     * Ensure network
+     *
+     * @returns Promise
+     */
+    async ensureNetwork() {
+        if (!this.connectionInProgress) {
+            this.initNetwork();
+        }
+        else if (this.networkReady) {
+            return;
+        }
+        await this.eventManager.waitFor(WalletEvents.networkConnected);
+    }
+    async initNetwork() {
+        try {
+            this.connectionInProgress = true;
+            const networkInfo = this.networkManager.getNetworkInfo();
+            await keyringService.initialize({
+                ss58Format: networkInfo.addressPrefix,
+            });
+            Logger.debug(`Initializing network ${JSON.stringify(networkInfo)}`);
+            const isDockConnected = await dockService.isApiConnected();
+            if (isDockConnected) {
+                await dockService.disconnect();
+            }
+            await dockService.init({
+                address: networkInfo.substrateUrl,
+            });
+            this.eventManager.emit(WalletEvents.networkConnected);
+        }
+        catch (err) {
+            this.eventManager.emit(WalletEvents.error, err);
+            throw err;
+        }
+        finally {
+            this.connectionInProgress = false;
+            this.networkReady = true;
+        }
+    }
+    async waitReady() {
+        if (this.status === 'ready') {
+            return;
+        }
+        let warningTimeout = setTimeout(() => {
+            throw new Error('Wallet module timed out. Make sure the wallet is loaded, or you are not using multiple instances');
+        }, 6000);
+        await this.eventManager.waitFor(WalletEvents.ready);
+        clearTimeout(warningTimeout);
+    }
+    getContext() {
+        return this.getContext;
+    }
+    setContext(context) {
+        this.context = context;
+    }
+    assertReady() {
+        return this.waitReady();
+    }
+    /**
+     * Remove document
+     * @returns Promise<boolean>
+     */
+    async remove(documentId) {
+        await walletService.remove(documentId);
+        this.eventManager.emit(WalletEvents.documentRemoved, documentId);
+    }
+    async upsert(document) {
+        const existing = await this.getDocumentById(document.id);
+        if (existing) {
+            return this.update({
+                ...existing,
+                ...document,
+            });
+        }
+        return this.add(document);
+    }
+    /**
+     * Add document to the wallet
+     * @param {*} options
+     * @throws InvalidAccountErrors
+     * @returns document
+     */
+    async add(document) {
+        await this.assertReady();
+        const newDocument = {
+            ...document,
+            id: document.id || v4(),
+            '@context': document.context || this.context,
+        };
+        await walletService.add(newDocument);
+        this.eventManager.emit(WalletEvents.documentAdded, newDocument);
+        return newDocument;
+    }
+    async update(document) {
+        await this.assertReady();
+        await walletService.update({
+            '@context': document['@context'] || this.context,
+            ...document,
+        });
+        this.eventManager.emit(WalletEvents.documentUpdated, document);
+        return document;
+    }
+    async export(password) {
+        return walletService.exportWallet(password);
+    }
+    /**
+     * Add all documents in the wallet
+     * @param {*} options
+     * @returns document
+     */
+    async query(params = {}) {
+        await this.assertReady();
+        let equals;
+        Object.keys(params).forEach(key => {
+            const value = params[key];
+            if (!value) {
+                return;
+            }
+            if (!equals) {
+                equals = {};
+            }
+            equals[`content.${key}`] = value;
+        });
+        return walletService.query({
+            equals,
+        });
+    }
+    async getDocumentById(documentId) {
+        await this.assertReady();
+        const result = await this.query({ id: documentId });
+        return result[0];
+    }
+    static async create({ walletId, json, password } = {}) {
+        const wallet = new Wallet({ walletId });
+        await wallet.load();
+        if (json) {
+            await wallet.importWallet({ json, password });
+        }
+        return wallet;
+    }
+    async importWallet({ json, password }) {
+        await this.deleteWallet();
+        await walletService.importWallet({ json, password });
+        this.migrated = await migrate({ wallet: this });
+        await this.eventManager.emit(WalletEvents.walletImported);
+    }
+    async getDocumentsFromEncryptedWallet({ encryptedJSONWallet, password }) {
+        return walletService.getDocumentsFromEncryptedWallet({
+            encryptedJSONWallet,
+            password,
+        });
+    }
+    async resolveCorrelations(documentId) {
+        return walletService.resolveCorrelations(documentId);
+    }
+    async exportDocuments({ documents, password }) {
+        return walletService.exportDocuments({
+            documents,
+            password,
+        });
+    }
+    /**
+     * Get wallet module instance
+     * @returns Wallet
+     */
+    static getInstance() {
+        if (!Wallet.instance) {
+            Wallet.instance = new Wallet();
+        }
+        return Wallet.instance;
+    }
+}
+
+// @ts-nocheck
+const AccountsEvents = {
+    loaded: 'loaded',
+    accountCreated: 'account-added',
+    accountUpdated: 'account-updated',
+    accountRemoved: 'account-removed',
+};
+class Accounts {
+    accounts;
+    wallet;
+    eventManager;
+    static DocumentFilters = {
+        mnemonicType: (item) => item.type === 'Mnemonic',
+        currencyType: (item) => item.type === 'Currency',
+    };
+    constructor({ wallet, walletService: walletService$1 } = {}) {
+        this.accounts = [];
+        this.wallet = wallet || Wallet.getInstance();
+        this.walletService = walletService$1 || walletService;
+        this.eventManager = new EventManager();
+    }
+    async load() {
+        this.accounts = await this.wallet.query({
+            type: 'Address',
+        });
+        this.eventManager.emit(AccountsEvents.loaded);
+        return this.accounts;
+    }
+    async exportAccount(address, password) {
+        return this.walletService.exportAccount({ address, password });
+    }
+    async importAccount(json, password) {
+        return this.create({
+            json,
+            password,
+        });
+    }
+    async fetchBalance(address) {
+        assert(isAddressValid(address), 'invalid address');
+        console.log('fetching balance from substrate');
+        let balance;
+        try {
+            balance = await substrateService.getAccountBalance({ address });
+            console.log('balance found', balance.toString());
+            console.log('updating cache');
+            const currency = await this.findCorrelationByType(address, 'Currency', true);
+            console.log('currency', currency);
+            if (currency.value !== balance) {
+                currency.value = balance;
+                await this.wallet.update(currency);
+            }
+        }
+        catch (err) {
+            console.log('Unable to update cache');
+            console.error(err);
+        }
+        return balance;
+    }
+    async getBalance(address, skipFetch) {
+        assert(isAddressValid(address), 'address is required');
+        if (!skipFetch) {
+            await this.fetchBalance(address);
+        }
+        const currency = await this.findCorrelationByType(address, 'Currency', true);
+        return currency.value;
+    }
+    getAccounts() {
+        return this.accounts;
+    }
+    getAccountIcon(address, isAlternative) {
+        return polkadotService.getPolkadotSvgIcon(address, isAlternative);
+    }
+    async getByAddress(address) {
+        return Account.with(address);
+    }
+    async findCorrelationByType(address, type, assertResult) {
+        assert(isAddressValid(address), 'invalid address');
+        const correlations = await this.wallet.resolveCorrelations(address);
+        const result = correlations.find(c => c.type.includes(type));
+        if (assertResult) {
+            assert(!!result, `${type} document not found for the account ${address}`);
+        }
+        return result;
+    }
+    generateMnemonic() {
+        return utilCryptoService.mnemonicGenerate(12);
+    }
+    async update(account) {
+        assert(!!account, 'account is required');
+        await this.walletService.update(account);
+        this.eventManager.emit(AccountsEvents.accountUpdated);
+        await this.load();
+    }
+    async getOrCreate(params) {
+        return this.create({
+            ...params,
+            getIfExists: true,
+        });
+    }
+    async create(params) {
+        let { name, json, password, type = 'sr25519', getIfExists, hasBackup } = params;
+        assert(!!name, 'name is required');
+        assert(!!type, 'keypair type is required');
+        assert(KeypairTypes.find(t => t === type), `invalid keypair type ${type}`);
+        if (json) {
+            assert(typeof password === 'string', 'password is required');
+        }
+        const mnemonic = params.mnemonic || (!json && (await this.generateMnemonic()));
+        const derivePath = params.derivationPath || '';
+        const address = json
+            ? json.address
+            : await keyringService.addressFromUri({
+                mnemonic,
+                type,
+                derivePath,
+            });
+        const existingAccountDocs = await this.wallet.query({
+            id: address,
+        });
+        const accountExists = existingAccountDocs.length > 0;
+        if (getIfExists && accountExists) {
+            return this.getByAddress(address);
+        }
+        assert(!accountExists, Errors.accountAlreadyExists);
+        if (json) {
+            const pair = await keyringService.decryptKeyPair({
+                jsonData: json,
+                password,
+            });
+            assert(pair && pair.address, 'invalid keypair');
+            type = pair.type;
+        }
+        const account = {
+            id: address,
+            name,
+            type,
+            address,
+        };
+        const documents = await this.walletService.createAccountDocuments({
+            name,
+            type,
+            derivePath,
+            mnemonic,
+            json,
+            password,
+            hasBackup,
+        });
+        documents.forEach(doc => {
+            this.wallet.eventManager.emit(WalletEvents.documentAdded, doc);
+        });
+        this.eventManager.emit(AccountsEvents.accountCreated, account);
+        await this.load();
+        return Account.withAsync(account.address, this);
+    }
+    async remove(accountId) {
+        await this.wallet.remove(accountId);
+        // remove other documents
+        // mnemonic phrase and all the stuff
+        this.eventManager.emit(AccountsEvents.accountRemoved, accountId);
+        this.load();
+    }
+    static getInstance(options) {
+        if (!Accounts.instance || options) {
+            Accounts.instance = new Accounts(options);
+        }
+        return Accounts.instance;
+    }
+}
+
+// @ts-nocheck
+/**
+ * Account
+ */
+class Account {
+    details;
+    address;
+    name;
+    accounts;
+    constructor(address, accounts) {
+        this.accounts = accounts;
+        this.address = address;
+        this.id = address;
+    }
+    /**
+     * Get account for a given address
+     * The account needs to exist in the wallet
+     *
+     * @example
+     * const accounts = Account.with('some-address')
+     * @param {string} address
+     * @returns
+     */
+    static with(address, accounts) {
+        assert(isAddressValid(address), 'invalid address');
+        const account = new Account(address, accounts || Accounts.getInstance());
+        account.loadPromise = account.loadDetails();
+        return account;
+    }
+    /**
+     *
+     * @param {string} address
+     * @returns
+     */
+    static async withAsync(address, accounts) {
+        const account = Account.with(address, accounts);
+        await account.loadPromise;
+        return account;
+    }
+    /**
+     * @returns {Promise<void>}
+     */
+    async loadDetails() {
+        this.details = await this.accounts.wallet.getDocumentById(this.id);
+        this.name = this.details && this.details.name;
+    }
+    getAddress() {
+        return this.details.address;
+    }
+    getDetails() {
+        return this.details;
+    }
+    async getBalance(skipFetch) {
+        return this.accounts.getBalance(this.details.address, skipFetch);
+    }
+    export(password) {
+        return this.accounts.exportAccount(this.address, password);
+    }
+    remove() {
+        return this.accounts.remove(this.address);
+    }
+    update({ name }) {
+        return this.accounts.update({
+            ...this.details,
+            name,
+        });
+    }
+    async getMnemonic() {
+        const doc = await this.accounts.findCorrelationByType(this.address, 'Mnemonic');
+        return doc.value;
+    }
+    async getKeyPair() {
+        const doc = await this.accounts.findCorrelationByType(this.address, 'KeyringPair');
+        return doc.value;
+    }
+    getName() {
+        return this.details.name;
+    }
+    getIcon(isAlternative) {
+        return this.accounts.getAccountIcon(this.details.address, isAlternative);
+    }
+}
+
+export { AccountsEvents as A, Wallet as W, WalletEvents as a, Accounts as b, Account as c };