@taquito/beacon-wallet 24.2.0 → 24.3.0-beta.1

package/dist/taquito-beacon-wallet.es6.js

@@ -1,45 +1,13 @@
-import { Regions, getDAppClientInstance, SigningType, PermissionScope } from '@ecadlabs/beacon-dapp';
+import { Regions, getDAppClientInstance, PermissionScope, SigningType } from '@ecadlabs/beacon-dapp';
 export { BeaconEvent } from '@ecadlabs/beacon-dapp';
 import { PermissionDeniedError, UnsupportedActionError } from '@taquito/core';
 import toBuffer from 'typedarray-to-buffer';
 import { createTransferOperation, createTransferTicketOperation, createIncreasePaidStorageOperation, createOriginationOperation, createSetDelegateOperation, createRegisterGlobalConstantOperation } from '@taquito/taquito';
 import { hex2buf, mergebuf, buf2hex } from '@taquito/utils';
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(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());
-    });
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
 /**
  *  @category Error
- *  @description Error that indicates the Beacon wallet not being initialized
+ *  Error that indicates the Beacon wallet not being initialized
  */
 class BeaconWalletNotInitialized extends PermissionDeniedError {
     constructor() {
@@ -51,7 +19,7 @@ class BeaconWalletNotInitialized extends PermissionDeniedError {
 }
 /**
  *  @category Error
- *  @description Error that indicates missing required permission scopes
+ *  Error that indicates missing required permission scopes
  */
 class MissingRequiredScopes extends PermissionDeniedError {
     constructor(requiredScopes) {
@@ -64,8 +32,8 @@ class MissingRequiredScopes extends PermissionDeniedError {
 
 // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
 const VERSION = {
-    "commitHash": "105a7b15cfb862a0732c204e0e9741098d697775",
-    "version": "24.2.0"
+    "commitHash": "05df48fee92f846cba793920d6fa829afd6a1847",
+    "version": "24.3.0-beta.1"
 };
 
 /**
@@ -115,9 +83,11 @@ const TAQUITO_CURATED_MATRIX_NODES = {
 };
 class BeaconWallet {
     constructor(options) {
-        var _a;
-        const matrixNodes = Object.assign(Object.assign({}, TAQUITO_CURATED_MATRIX_NODES), ((_a = options.matrixNodes) !== null && _a !== void 0 ? _a : {}));
-        this.client = getDAppClientInstance(Object.assign(Object.assign({}, options), { matrixNodes }));
+        const matrixNodes = {
+            ...TAQUITO_CURATED_MATRIX_NODES,
+            ...(options.matrixNodes ?? {}),
+        };
+        this.client = getDAppClientInstance({ ...options, matrixNodes });
     }
     validateRequiredScopesOrFail(permissionScopes, requiredScopes) {
         const mandatoryScope = new Set(requiredScopes);
@@ -130,155 +100,130 @@ class BeaconWallet {
             throw new MissingRequiredScopes(Array.from(mandatoryScope));
         }
     }
-    requestPermissions(request) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.requestPermissions(request);
-        });
+    async requestPermissions(request) {
+        await this.client.requestPermissions(request);
     }
-    getPKH() {
-        return __awaiter(this, void 0, void 0, function* () {
-            const account = yield this.client.getActiveAccount();
-            if (!account) {
-                throw new BeaconWalletNotInitialized();
-            }
-            return account.address;
-        });
+    async getPKH() {
+        const account = await this.client.getActiveAccount();
+        if (!account) {
+            throw new BeaconWalletNotInitialized();
+        }
+        return account.address;
     }
-    getPK() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            const account = yield this.client.getActiveAccount();
-            if (!account) {
-                throw new BeaconWalletNotInitialized();
-            }
-            return (_a = account.publicKey) !== null && _a !== void 0 ? _a : '';
-        });
+    async getPK() {
+        const account = await this.client.getActiveAccount();
+        if (!account) {
+            throw new BeaconWalletNotInitialized();
+        }
+        return account.publicKey ?? '';
     }
-    mapTransferParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let walletParams;
-            yield this.client.showPrepare();
-            try {
-                walletParams = yield params();
-            }
-            catch (err) {
-                yield this.client.hideUI(['alert']);
-                throw err;
-            }
-            return this.removeDefaultParams(walletParams, yield createTransferOperation(this.formatParameters(walletParams)));
-        });
+    async mapTransferParamsToWalletParams(params) {
+        let walletParams;
+        await this.client.showPrepare();
+        try {
+            walletParams = await params();
+        }
+        catch (err) {
+            await this.client.hideUI(['alert']);
+            throw err;
+        }
+        return this.removeDefaultParams(walletParams, await createTransferOperation(this.formatParameters(walletParams)));
     }
-    mapTransferTicketParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let walletParams;
-            yield this.client.showPrepare();
-            try {
-                walletParams = yield params();
-            }
-            catch (err) {
-                yield this.client.hideUI(['alert']);
-                throw err;
-            }
-            return this.removeDefaultParams(walletParams, yield createTransferTicketOperation(this.formatParameters(walletParams)));
-        });
+    async mapTransferTicketParamsToWalletParams(params) {
+        let walletParams;
+        await this.client.showPrepare();
+        try {
+            walletParams = await params();
+        }
+        catch (err) {
+            await this.client.hideUI(['alert']);
+            throw err;
+        }
+        return this.removeDefaultParams(walletParams, await createTransferTicketOperation(this.formatParameters(walletParams)));
     }
-    mapStakeParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let walletParams;
-            yield this.client.showPrepare();
-            try {
-                walletParams = yield params();
-            }
-            catch (err) {
-                yield this.client.hideUI(['alert']);
-                throw err;
-            }
-            return this.removeDefaultParams(walletParams, yield createTransferOperation(this.formatParameters(walletParams)));
-        });
+    async mapStakeParamsToWalletParams(params) {
+        let walletParams;
+        await this.client.showPrepare();
+        try {
+            walletParams = await params();
+        }
+        catch (err) {
+            await this.client.hideUI(['alert']);
+            throw err;
+        }
+        return this.removeDefaultParams(walletParams, await createTransferOperation(this.formatParameters(walletParams)));
     }
-    mapUnstakeParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let walletParams;
-            yield this.client.showPrepare();
-            try {
-                walletParams = yield params();
-            }
-            catch (err) {
-                yield this.client.hideUI(['alert']);
-                throw err;
-            }
-            return this.removeDefaultParams(walletParams, yield createTransferOperation(this.formatParameters(walletParams)));
-        });
+    async mapUnstakeParamsToWalletParams(params) {
+        let walletParams;
+        await this.client.showPrepare();
+        try {
+            walletParams = await params();
+        }
+        catch (err) {
+            await this.client.hideUI(['alert']);
+            throw err;
+        }
+        return this.removeDefaultParams(walletParams, await createTransferOperation(this.formatParameters(walletParams)));
     }
-    mapFinalizeUnstakeParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let walletParams;
-            yield this.client.showPrepare();
-            try {
-                walletParams = yield params();
-            }
-            catch (err) {
-                yield this.client.hideUI(['alert']);
-                throw err;
-            }
-            return this.removeDefaultParams(walletParams, yield createTransferOperation(this.formatParameters(walletParams)));
-        });
+    async mapFinalizeUnstakeParamsToWalletParams(params) {
+        let walletParams;
+        await this.client.showPrepare();
+        try {
+            walletParams = await params();
+        }
+        catch (err) {
+            await this.client.hideUI(['alert']);
+            throw err;
+        }
+        return this.removeDefaultParams(walletParams, await createTransferOperation(this.formatParameters(walletParams)));
     }
-    mapIncreasePaidStorageWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let walletParams;
-            yield this.client.showPrepare();
-            try {
-                walletParams = yield params();
-            }
-            catch (err) {
-                yield this.client.hideUI(['alert']);
-                throw err;
-            }
-            return this.removeDefaultParams(walletParams, yield createIncreasePaidStorageOperation(this.formatParameters(walletParams)));
-        });
+    async mapIncreasePaidStorageWalletParams(params) {
+        let walletParams;
+        await this.client.showPrepare();
+        try {
+            walletParams = await params();
+        }
+        catch (err) {
+            await this.client.hideUI(['alert']);
+            throw err;
+        }
+        return this.removeDefaultParams(walletParams, await createIncreasePaidStorageOperation(this.formatParameters(walletParams)));
     }
-    mapOriginateParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let walletParams;
-            yield this.client.showPrepare();
-            try {
-                walletParams = yield params();
-            }
-            catch (err) {
-                yield this.client.hideUI(['alert']);
-                throw err;
-            }
-            return this.removeDefaultParams(walletParams, yield createOriginationOperation(this.formatParameters(walletParams)));
-        });
+    async mapOriginateParamsToWalletParams(params) {
+        let walletParams;
+        await this.client.showPrepare();
+        try {
+            walletParams = await params();
+        }
+        catch (err) {
+            await this.client.hideUI(['alert']);
+            throw err;
+        }
+        return this.removeDefaultParams(walletParams, await createOriginationOperation(this.formatParameters(walletParams)));
     }
-    mapDelegateParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let walletParams;
-            yield this.client.showPrepare();
-            try {
-                walletParams = yield params();
-            }
-            catch (err) {
-                yield this.client.hideUI(['alert']);
-                throw err;
-            }
-            return this.removeDefaultParams(walletParams, yield createSetDelegateOperation(this.formatParameters(walletParams)));
-        });
+    async mapDelegateParamsToWalletParams(params) {
+        let walletParams;
+        await this.client.showPrepare();
+        try {
+            walletParams = await params();
+        }
+        catch (err) {
+            await this.client.hideUI(['alert']);
+            throw err;
+        }
+        return this.removeDefaultParams(walletParams, await createSetDelegateOperation(this.formatParameters(walletParams)));
     }
-    mapRegisterGlobalConstantParamsToWalletParams(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let walletParams;
-            yield this.client.showPrepare();
-            try {
-                walletParams = yield params();
-            }
-            catch (err) {
-                yield this.client.hideUI(['alert']);
-                throw err;
-            }
-            return this.removeDefaultParams(walletParams, yield createRegisterGlobalConstantOperation(this.formatParameters(walletParams)));
-        });
+    async mapRegisterGlobalConstantParamsToWalletParams(params) {
+        let walletParams;
+        await this.client.showPrepare();
+        try {
+            walletParams = await params();
+        }
+        catch (err) {
+            await this.client.hideUI(['alert']);
+            throw err;
+        }
+        return this.removeDefaultParams(walletParams, await createRegisterGlobalConstantOperation(this.formatParameters(walletParams)));
     }
     formatParameters(params) {
         if (params.fee) {
@@ -307,20 +252,18 @@ class BeaconWallet {
         }
         return operatedParams;
     }
-    sendOperations(params) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const account = yield this.client.getActiveAccount();
-            if (!account) {
-                throw new BeaconWalletNotInitialized();
-            }
-            const permissions = account.scopes;
-            this.validateRequiredScopesOrFail(permissions, [PermissionScope.OPERATION_REQUEST]);
-            const { transactionHash } = yield this.client.requestOperation({ operationDetails: params });
-            return transactionHash;
-        });
+    async sendOperations(params) {
+        const account = await this.client.getActiveAccount();
+        if (!account) {
+            throw new BeaconWalletNotInitialized();
+        }
+        const permissions = account.scopes;
+        this.validateRequiredScopesOrFail(permissions, [PermissionScope.OPERATION_REQUEST]);
+        const { transactionHash } = await this.client.requestOperation({ operationDetails: params });
+        return transactionHash;
     }
     /**
-     * @description Disconnect the wallet and remove all Beacon data from localStorage.
+     * Disconnect the wallet and remove all Beacon data from localStorage.
      *
      * This is the recommended way to end a user session (logout). It calls
      * `client.destroy()` under the hood, which clears the active account,
@@ -332,13 +275,11 @@ class BeaconWallet {
      *
      * For switching accounts without a full logout, use {@link clearActiveAccount} instead.
      */
-    disconnect() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.destroy();
-        });
+    async disconnect() {
+        await this.client.destroy();
     }
     /**
-     * @description Clear the active account without destroying the Beacon session.
+     * Clear the active account without destroying the Beacon session.
      *
      * This removes the active account reference from local storage but does
      * **not** clear other Beacon state such as the cached relay node
@@ -349,28 +290,24 @@ class BeaconWallet {
      *
      * @see {@link disconnect}
      */
-    clearActiveAccount() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.client.setActiveAccount();
-        });
+    async clearActiveAccount() {
+        await this.client.setActiveAccount();
     }
-    sign(bytes, watermark) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let bb = hex2buf(bytes);
-            if (typeof watermark !== 'undefined') {
-                bb = mergebuf(watermark, bb);
-            }
-            const watermarkedBytes = buf2hex(toBuffer(bb));
-            const signingType = this.getSigningType(watermark);
-            if (signingType !== SigningType.OPERATION) {
-                throw new UnsupportedActionError(`Taquito Beacon Wallet currently only supports signing operations, not ${signingType}`);
-            }
-            const { signature } = yield this.client.requestSignPayload({
-                payload: watermarkedBytes,
-                signingType,
-            });
-            return signature;
+    async sign(bytes, watermark) {
+        let bb = hex2buf(bytes);
+        if (typeof watermark !== 'undefined') {
+            bb = mergebuf(watermark, bb);
+        }
+        const watermarkedBytes = buf2hex(toBuffer(bb));
+        const signingType = this.getSigningType(watermark);
+        if (signingType !== SigningType.OPERATION) {
+            throw new UnsupportedActionError(`Taquito Beacon Wallet currently only supports signing operations, not ${signingType}`);
+        }
+        const { signature } = await this.client.requestSignPayload({
+            payload: watermarkedBytes,
+            signingType,
         });
+        return signature;
     }
     getSigningType(watermark) {
         if (!watermark || watermark.length === 0) {

package/dist/taquito-beacon-wallet.es6.js.map

@@ -1 +1 @@
-{"version":3,"file":"taquito-beacon-wallet.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"taquito-beacon-wallet.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}