@tezos-x/octez.js-tzip12 0.9.0

package/README.md

@@ -0,0 +1,65 @@
+# octez.js TZIP-012 package
+
+*Documentation can be found [here](https://octez.js.io/docs/tzip12)*
+*TypeDoc style documentation is available on-line [here](https://octez.js.io/typedoc/modules/_octez.js_tzip12.html)*
+
+**Maintained by [Nomadic Labs](https://www.nomadic-labs.com/).**
+
+`@tezos-x/octez.js-tzip12` is an npm package that provides developers with TZIP-12 functionality for octez.js. The package allows retrieving metadata associated with tokens of FA2 contracts.
+
+## General Information
+
+There are two scenarios to obtain the metadata of a token:
+1. The metadata can be obtained from executing an off-chain view named `token_metadata` present in the contract metadata
+2. or from a big map named `token_metadata` in the contract storage. 
+
+The `getTokenMetadata` method of the `Tzip12ContractAbstraction` class will find the token metadata with precedence for the off-chain view, if there is one, as specified in the standard. Please refer to the following link for complete documentation on [TZIP-012#Token Metadata](https://gitlab.com/tezos/tzip/-/blob/master/proposals/tzip-12/tzip-12.md#token-metadata).
+
+## Install
+
+The package can be used to extend the well-known octez.js contract abstraction. The `@tezos-x/octez.js-tzip12` and the `@tezos-x/octez.js` packages need to be installed as follows:
+
+```
+npm i --save @tezos-x/octez.js-tzip12
+npm i --save @tezos-x/octez.js
+```
+
+## Usage
+
+**Create an instance of the `Tzip12Module` and add it as an extension to the `TezosToolkit`**
+
+The constructor of the `Tzip12Module` takes an optional `MetadataProvider` as a parameter. When none is passed, the default `MetadataProvider` of octez.js is instantiated, and the default handlers (`HttpHandler,` `IpfsHandler,` and `TezosStorageHandler`) are used. The `MetadataProvider` can be customized by the user if needed.
+
+**Use the `tzip12` function to extend a contract abstraction**
+
+```ts
+import { TezosToolkit } from '@tezos-x/octez.js';
+import { Tzip12Module, tzip12 } from '@tezos-x/octez.js-tzip12';
+import BigNumber from 'bignumber.js';
+
+const Tezos = new TezosToolkit('https://YOUR_PREFERRED_RPC_URL');
+Tezos.addExtension(new Tzip12Module());
+
+const contract = await Tezos.contract.at("contractAddress", tzip12)
+
+// get the token metadata
+await contract.tzip12().getTokenMetadata(BigNumber(1));
+```
+
+The `getTokenMetadata` method takes a BigNumber as a parameter that represents the token_id and returns an object matching this interface:
+```
+interface TokenMetadata {
+    token_id: BigNumber,
+    decimals: number
+    name?: string,
+    symbol?: string,
+}
+```
+
+## Additional info
+
+See the top-level [https://github.com/trilitech/octez.js](https://github.com/trilitech/octez.js) file for details on reporting issues, contributing and versioning.
+
+## Disclaimer
+
+THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/dist/lib/composer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tzip12 = tzip12;
+const tzip12_contract_abstraction_1 = require("./tzip12-contract-abstraction");
+const ABSTRACTION_KEY = Symbol('Tzip12ContractAbstractionObjectKey');
+function tzip12(abs, context) {
+    return Object.assign(abs, {
+        // namespace tzip12
+        tzip12() {
+            if (!this[ABSTRACTION_KEY]) {
+                this[ABSTRACTION_KEY] = new tzip12_contract_abstraction_1.Tzip12ContractAbstraction(this, context);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return this[ABSTRACTION_KEY];
+        },
+    });
+}

package/dist/lib/errors.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InvalidTokenMetadata = exports.TokenIdNotFound = exports.TokenMetadataNotFound = void 0;
+const octez_js_core_1 = require("@tezos-x/octez.js-core");
+/**
+ *  @category Error
+ *  @description Error that indicates the metadata not being found on the contract
+ */
+class TokenMetadataNotFound extends octez_js_core_1.TaquitoError {
+    constructor(address) {
+        super();
+        this.address = address;
+        this.name = 'TokenMetadataNotFound';
+        this.message = `No token metadata was found for the contract: ${address}`;
+    }
+}
+exports.TokenMetadataNotFound = TokenMetadataNotFound;
+/**
+ *  @category Error
+ *  @description Error that indicates the token ID not being found
+ */
+class TokenIdNotFound extends octez_js_core_1.TaquitoError {
+    constructor(tokenId) {
+        super(`Could not find token metadata for the token ID: ${tokenId}`);
+        this.tokenId = tokenId;
+        this.name = 'TokenIdNotFound';
+    }
+}
+exports.TokenIdNotFound = TokenIdNotFound;
+/**
+ *  @category Error
+ *  @description Error that indicates that the token metadata is invalid (not compliant with the TZIP-12 standard)
+ */
+class InvalidTokenMetadata extends octez_js_core_1.TaquitoError {
+    constructor(invalidMetadata) {
+        super();
+        this.invalidMetadata = invalidMetadata;
+        this.name = 'InvalidTokenMetadata';
+        this.message =
+            'Non-compliance with the TZIP-012 standard. The required property `decimals` is missing.';
+    }
+}
+exports.InvalidTokenMetadata = InvalidTokenMetadata;

package/dist/lib/octez.js-tzip12.js

@@ -0,0 +1,27 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+/**
+ * @packageDocumentation
+ * @module @tezos-x/octez.js-tzip12
+ */
+__exportStar(require("./tzip12-contract-abstraction"), exports);
+__exportStar(require("./composer"), exports);
+__exportStar(require("./errors"), exports);
+__exportStar(require("./tzip12-extension"), exports);
+var version_1 = require("./version");
+Object.defineProperty(exports, "VERSION", { enumerable: true, get: function () { return version_1.VERSION; } });

package/dist/lib/tzip12-contract-abstraction.js

@@ -0,0 +1,191 @@
+"use strict";
+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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tzip12ContractAbstraction = void 0;
+const octez_js_michelson_encoder_1 = require("@tezos-x/octez.js-michelson-encoder");
+const octez_js_tzip16_1 = require("@tezos-x/octez.js-tzip16");
+const octez_js_utils_1 = require("@tezos-x/octez.js-utils");
+const errors_1 = require("./errors");
+const tokenMetadataBigMapType = {
+    prim: 'big_map',
+    args: [
+        { prim: 'nat' },
+        {
+            prim: 'pair',
+            args: [
+                { prim: 'nat', annots: ['%token_id'] },
+                { prim: 'map', args: [{ prim: 'string' }, { prim: 'bytes' }], annots: ['%token_info'] },
+            ],
+        },
+    ],
+    annots: ['%token_metadata'],
+};
+class Tzip12ContractAbstraction {
+    constructor(contractAbstraction, context) {
+        this.contractAbstraction = contractAbstraction;
+        this.context = context;
+        this._tzip16ContractAbstraction = new octez_js_tzip16_1.Tzip16ContractAbstraction(this.contractAbstraction, this.context);
+    }
+    /**
+     * @description Fetches the contract metadata (according to the Tzip-016 standard)
+     * @returns An object containing the metadata, the uri, an optional integrity check result and an optional sha256 hash
+     * or `Undefined` if the contract has no metadata (non-compliant with Tzip-016)
+     */
+    getContractMetadata() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const contractMetadata = yield this._tzip16ContractAbstraction.getMetadata();
+                return contractMetadata.metadata;
+            }
+            catch (err) {
+                // The contract is not compliant with Tzip-016. There is no contract metadata.
+            }
+        });
+    }
+    /**
+     * @description The Tzip-016 "interfaces" field MUST be present in the contract metadata. It should contain "TZIP-012[version-info]"
+     * @returns True if "interfaces" field is present and contains "TZIP-012", false otherwise
+     */
+    isTzip12Compliant() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let isCompliant = false;
+            const metadata = yield this.getContractMetadata();
+            if (metadata) {
+                const tzip12Interface = (_a = metadata.interfaces) === null || _a === void 0 ? void 0 : _a.filter((x) => {
+                    return x.substring(0, 8) === 'TZIP-012';
+                });
+                isCompliant = tzip12Interface && tzip12Interface.length !== 0 ? true : false;
+            }
+            return isCompliant;
+        });
+    }
+    /**
+     * @description Fetches the token metadata for a specified token ID.
+     * The function first tries to find a `token_metadata` view in the contract metadata and to execute it with the token ID.
+     * If there is no view, the function tries to find a `token_metadata` bigmap in the top-level pairs of the storage.
+     * @param tokenId The ID of the token for which we want to retrieve token metadata
+     * @returns An object of type `TokenMetadata`
+     * @throws {@link TokenIdNotFound, TokenMetadataNotFound, InvalidTokenMetadata}
+     */
+    getTokenMetadata(tokenId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenMetadata = yield this.retrieveTokenMetadataFromView(tokenId);
+            return !tokenMetadata ? this.retrieveTokenMetadataFromBigMap(tokenId) : tokenMetadata;
+        });
+    }
+    retrieveTokenMetadataFromView(tokenId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.getContractMetadata()) {
+                const views = yield this._tzip16ContractAbstraction.metadataViews();
+                if (views && this.hasTokenMetadataView(views)) {
+                    return this.executeTokenMetadataView(views['token_metadata'](), tokenId);
+                }
+            }
+        });
+    }
+    hasTokenMetadataView(views) {
+        for (const view of Object.keys(views)) {
+            if (view === 'token_metadata') {
+                return true;
+            }
+        }
+        return false;
+    }
+    executeTokenMetadataView(tokenMetadataView, tokenId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenMetadata = yield tokenMetadataView.executeView(tokenId);
+            const tokenMap = Object.values(tokenMetadata)[1];
+            if (!octez_js_michelson_encoder_1.MichelsonMap.isMichelsonMap(tokenMap)) {
+                throw new errors_1.TokenMetadataNotFound(this.contractAbstraction.address);
+            }
+            const metadataFromUri = yield this.fetchTokenMetadataFromUri(tokenMap);
+            return this.formatMetadataToken(tokenId, tokenMap, metadataFromUri);
+        });
+    }
+    fetchTokenMetadataFromUri(tokenMetadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uri = tokenMetadata.get('');
+            if (uri) {
+                try {
+                    const metadataFromUri = yield this.context.metadataProvider.provideMetadata(this.contractAbstraction, (0, octez_js_utils_1.bytesToString)(uri), this.context);
+                    return metadataFromUri.metadata;
+                }
+                catch (e) {
+                    if (e.name === 'InvalidUriError') {
+                        console.warn(`The URI ${(0, octez_js_utils_1.bytesToString)(uri)} is present in the token metadata, but is invalid.`);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+        });
+    }
+    formatMetadataToken(tokenId, metadataTokenMap, metadataFromUri) {
+        const tokenMetadataDecoded = {
+            token_id: tokenId,
+        };
+        for (const keyTokenMetadata of metadataTokenMap.keys()) {
+            if (keyTokenMetadata === 'decimals') {
+                Object.assign(tokenMetadataDecoded, {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    [keyTokenMetadata]: Number((0, octez_js_utils_1.bytesToString)(metadataTokenMap.get(keyTokenMetadata))),
+                });
+            }
+            else if (!(keyTokenMetadata === '')) {
+                Object.assign(tokenMetadataDecoded, {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    [keyTokenMetadata]: (0, octez_js_utils_1.bytesToString)(metadataTokenMap.get(keyTokenMetadata)),
+                });
+            }
+        }
+        // if an URI is present, add the fetched properties to the object
+        // if a property is in the URI and the map, prevalence is accorded to value from the URI
+        if (metadataFromUri) {
+            for (const property in metadataFromUri) {
+                Object.assign(tokenMetadataDecoded, { [property]: metadataFromUri[property] });
+            }
+        }
+        if (!('decimals' in tokenMetadataDecoded)) {
+            throw new errors_1.InvalidTokenMetadata(tokenMetadataDecoded);
+        }
+        return tokenMetadataDecoded;
+    }
+    retrieveTokenMetadataFromBigMap(tokenId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bigmapTokenMetadataId = yield this.findTokenMetadataBigMap();
+            let pairNatMap;
+            try {
+                pairNatMap = yield this.context.contract.getBigMapKeyByID(bigmapTokenMetadataId['int'].toString(), tokenId.toString(), new octez_js_michelson_encoder_1.Schema(tokenMetadataBigMapType));
+            }
+            catch (err) {
+                throw new errors_1.TokenIdNotFound(tokenId);
+            }
+            const michelsonMap = pairNatMap['token_info'];
+            if (!octez_js_michelson_encoder_1.MichelsonMap.isMichelsonMap(michelsonMap)) {
+                throw new errors_1.TokenIdNotFound(tokenId);
+            }
+            const metadataFromUri = yield this.fetchTokenMetadataFromUri(michelsonMap);
+            return this.formatMetadataToken(tokenId, michelsonMap, metadataFromUri);
+        });
+    }
+    findTokenMetadataBigMap() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenMetadataBigMapId = this.contractAbstraction.schema.FindFirstInTopLevelPair(yield this.context.readProvider.getStorage(this.contractAbstraction.address, 'head'), tokenMetadataBigMapType);
+            if (!tokenMetadataBigMapId || !tokenMetadataBigMapId.int) {
+                throw new errors_1.TokenMetadataNotFound(this.contractAbstraction.address);
+            }
+            return { int: tokenMetadataBigMapId.int };
+        });
+    }
+}
+exports.Tzip12ContractAbstraction = Tzip12ContractAbstraction;

package/dist/lib/tzip12-extension.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Tzip12Module = void 0;
+const octez_js_tzip16_1 = require("@tezos-x/octez.js-tzip16");
+// The same default metadataProvider is used for tzip16 and tzip12
+class Tzip12Module {
+    constructor(metadataProvider) {
+        this._metadataProvider = metadataProvider ? metadataProvider : new octez_js_tzip16_1.MetadataProvider(octez_js_tzip16_1.DEFAULT_HANDLERS);
+    }
+    configureContext(context) {
+        Object.assign(context, { metadataProvider: this._metadataProvider });
+    }
+}
+exports.Tzip12Module = Tzip12Module;

package/dist/lib/version.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
+exports.VERSION = {
+    "commitHash": "f798e97ba998acc2cc5310278d812448591bd312",
+    "version": "24.0.2"
+};

package/dist/octez.js-tzip12.es6.js

@@ -0,0 +1,281 @@
+import { MichelsonMap, Schema } from '@tezos-x/octez.js-michelson-encoder';
+import { Tzip16ContractAbstraction, MetadataProvider, DEFAULT_HANDLERS } from '@tezos-x/octez.js-tzip16';
+import { bytesToString } from '@tezos-x/octez.js-utils';
+import { TaquitoError } from '@tezos-x/octez.js-core';
+
+/******************************************************************************
+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 metadata not being found on the contract
+ */
+class TokenMetadataNotFound extends TaquitoError {
+    constructor(address) {
+        super();
+        this.address = address;
+        this.name = 'TokenMetadataNotFound';
+        this.message = `No token metadata was found for the contract: ${address}`;
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates the token ID not being found
+ */
+class TokenIdNotFound extends TaquitoError {
+    constructor(tokenId) {
+        super(`Could not find token metadata for the token ID: ${tokenId}`);
+        this.tokenId = tokenId;
+        this.name = 'TokenIdNotFound';
+    }
+}
+/**
+ *  @category Error
+ *  @description Error that indicates that the token metadata is invalid (not compliant with the TZIP-12 standard)
+ */
+class InvalidTokenMetadata extends TaquitoError {
+    constructor(invalidMetadata) {
+        super();
+        this.invalidMetadata = invalidMetadata;
+        this.name = 'InvalidTokenMetadata';
+        this.message =
+            'Non-compliance with the TZIP-012 standard. The required property `decimals` is missing.';
+    }
+}
+
+const tokenMetadataBigMapType = {
+    prim: 'big_map',
+    args: [
+        { prim: 'nat' },
+        {
+            prim: 'pair',
+            args: [
+                { prim: 'nat', annots: ['%token_id'] },
+                { prim: 'map', args: [{ prim: 'string' }, { prim: 'bytes' }], annots: ['%token_info'] },
+            ],
+        },
+    ],
+    annots: ['%token_metadata'],
+};
+class Tzip12ContractAbstraction {
+    constructor(contractAbstraction, context) {
+        this.contractAbstraction = contractAbstraction;
+        this.context = context;
+        this._tzip16ContractAbstraction = new Tzip16ContractAbstraction(this.contractAbstraction, this.context);
+    }
+    /**
+     * @description Fetches the contract metadata (according to the Tzip-016 standard)
+     * @returns An object containing the metadata, the uri, an optional integrity check result and an optional sha256 hash
+     * or `Undefined` if the contract has no metadata (non-compliant with Tzip-016)
+     */
+    getContractMetadata() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const contractMetadata = yield this._tzip16ContractAbstraction.getMetadata();
+                return contractMetadata.metadata;
+            }
+            catch (err) {
+                // The contract is not compliant with Tzip-016. There is no contract metadata.
+            }
+        });
+    }
+    /**
+     * @description The Tzip-016 "interfaces" field MUST be present in the contract metadata. It should contain "TZIP-012[version-info]"
+     * @returns True if "interfaces" field is present and contains "TZIP-012", false otherwise
+     */
+    isTzip12Compliant() {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            let isCompliant = false;
+            const metadata = yield this.getContractMetadata();
+            if (metadata) {
+                const tzip12Interface = (_a = metadata.interfaces) === null || _a === void 0 ? void 0 : _a.filter((x) => {
+                    return x.substring(0, 8) === 'TZIP-012';
+                });
+                isCompliant = tzip12Interface && tzip12Interface.length !== 0 ? true : false;
+            }
+            return isCompliant;
+        });
+    }
+    /**
+     * @description Fetches the token metadata for a specified token ID.
+     * The function first tries to find a `token_metadata` view in the contract metadata and to execute it with the token ID.
+     * If there is no view, the function tries to find a `token_metadata` bigmap in the top-level pairs of the storage.
+     * @param tokenId The ID of the token for which we want to retrieve token metadata
+     * @returns An object of type `TokenMetadata`
+     * @throws {@link TokenIdNotFound, TokenMetadataNotFound, InvalidTokenMetadata}
+     */
+    getTokenMetadata(tokenId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenMetadata = yield this.retrieveTokenMetadataFromView(tokenId);
+            return !tokenMetadata ? this.retrieveTokenMetadataFromBigMap(tokenId) : tokenMetadata;
+        });
+    }
+    retrieveTokenMetadataFromView(tokenId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (yield this.getContractMetadata()) {
+                const views = yield this._tzip16ContractAbstraction.metadataViews();
+                if (views && this.hasTokenMetadataView(views)) {
+                    return this.executeTokenMetadataView(views['token_metadata'](), tokenId);
+                }
+            }
+        });
+    }
+    hasTokenMetadataView(views) {
+        for (const view of Object.keys(views)) {
+            if (view === 'token_metadata') {
+                return true;
+            }
+        }
+        return false;
+    }
+    executeTokenMetadataView(tokenMetadataView, tokenId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenMetadata = yield tokenMetadataView.executeView(tokenId);
+            const tokenMap = Object.values(tokenMetadata)[1];
+            if (!MichelsonMap.isMichelsonMap(tokenMap)) {
+                throw new TokenMetadataNotFound(this.contractAbstraction.address);
+            }
+            const metadataFromUri = yield this.fetchTokenMetadataFromUri(tokenMap);
+            return this.formatMetadataToken(tokenId, tokenMap, metadataFromUri);
+        });
+    }
+    fetchTokenMetadataFromUri(tokenMetadata) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const uri = tokenMetadata.get('');
+            if (uri) {
+                try {
+                    const metadataFromUri = yield this.context.metadataProvider.provideMetadata(this.contractAbstraction, bytesToString(uri), this.context);
+                    return metadataFromUri.metadata;
+                }
+                catch (e) {
+                    if (e.name === 'InvalidUriError') {
+                        console.warn(`The URI ${bytesToString(uri)} is present in the token metadata, but is invalid.`);
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+        });
+    }
+    formatMetadataToken(tokenId, metadataTokenMap, metadataFromUri) {
+        const tokenMetadataDecoded = {
+            token_id: tokenId,
+        };
+        for (const keyTokenMetadata of metadataTokenMap.keys()) {
+            if (keyTokenMetadata === 'decimals') {
+                Object.assign(tokenMetadataDecoded, {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    [keyTokenMetadata]: Number(bytesToString(metadataTokenMap.get(keyTokenMetadata))),
+                });
+            }
+            else if (!(keyTokenMetadata === '')) {
+                Object.assign(tokenMetadataDecoded, {
+                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    [keyTokenMetadata]: bytesToString(metadataTokenMap.get(keyTokenMetadata)),
+                });
+            }
+        }
+        // if an URI is present, add the fetched properties to the object
+        // if a property is in the URI and the map, prevalence is accorded to value from the URI
+        if (metadataFromUri) {
+            for (const property in metadataFromUri) {
+                Object.assign(tokenMetadataDecoded, { [property]: metadataFromUri[property] });
+            }
+        }
+        if (!('decimals' in tokenMetadataDecoded)) {
+            throw new InvalidTokenMetadata(tokenMetadataDecoded);
+        }
+        return tokenMetadataDecoded;
+    }
+    retrieveTokenMetadataFromBigMap(tokenId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const bigmapTokenMetadataId = yield this.findTokenMetadataBigMap();
+            let pairNatMap;
+            try {
+                pairNatMap = yield this.context.contract.getBigMapKeyByID(bigmapTokenMetadataId['int'].toString(), tokenId.toString(), new Schema(tokenMetadataBigMapType));
+            }
+            catch (err) {
+                throw new TokenIdNotFound(tokenId);
+            }
+            const michelsonMap = pairNatMap['token_info'];
+            if (!MichelsonMap.isMichelsonMap(michelsonMap)) {
+                throw new TokenIdNotFound(tokenId);
+            }
+            const metadataFromUri = yield this.fetchTokenMetadataFromUri(michelsonMap);
+            return this.formatMetadataToken(tokenId, michelsonMap, metadataFromUri);
+        });
+    }
+    findTokenMetadataBigMap() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tokenMetadataBigMapId = this.contractAbstraction.schema.FindFirstInTopLevelPair(yield this.context.readProvider.getStorage(this.contractAbstraction.address, 'head'), tokenMetadataBigMapType);
+            if (!tokenMetadataBigMapId || !tokenMetadataBigMapId.int) {
+                throw new TokenMetadataNotFound(this.contractAbstraction.address);
+            }
+            return { int: tokenMetadataBigMapId.int };
+        });
+    }
+}
+
+const ABSTRACTION_KEY = Symbol('Tzip12ContractAbstractionObjectKey');
+function tzip12(abs, context) {
+    return Object.assign(abs, {
+        // namespace tzip12
+        tzip12() {
+            if (!this[ABSTRACTION_KEY]) {
+                this[ABSTRACTION_KEY] = new Tzip12ContractAbstraction(this, context);
+            }
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            return this[ABSTRACTION_KEY];
+        },
+    });
+}
+
+// The same default metadataProvider is used for tzip16 and tzip12
+class Tzip12Module {
+    constructor(metadataProvider) {
+        this._metadataProvider = metadataProvider ? metadataProvider : new MetadataProvider(DEFAULT_HANDLERS);
+    }
+    configureContext(context) {
+        Object.assign(context, { metadataProvider: this._metadataProvider });
+    }
+}
+
+// IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
+const VERSION = {
+    "commitHash": "f798e97ba998acc2cc5310278d812448591bd312",
+    "version": "24.0.2"
+};
+
+export { InvalidTokenMetadata, TokenIdNotFound, TokenMetadataNotFound, Tzip12ContractAbstraction, Tzip12Module, VERSION, tzip12 };
+//# sourceMappingURL=octez.js-tzip12.es6.js.map

package/dist/octez.js-tzip12.es6.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"octez.js-tzip12.es6.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}