@taquito/tzip12 24.2.0-beta.1 → 24.3.0-beta.0

package/dist/taquito-tzip12.umd.js

@@ -1,290 +1,241 @@
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@taquito/michelson-encoder'), require('@taquito/tzip16'), require('@taquito/utils'), require('@taquito/core')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@taquito/michelson-encoder', '@taquito/tzip16', '@taquito/utils', '@taquito/core'], factory) :
-    (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoTzip12 = {}, global.michelsonEncoder, global.tzip16, global.utils, global.taquitoCore));
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@taquito/michelson-encoder'), require('@taquito/tzip16'), require('@taquito/utils'), require('@taquito/core')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@taquito/michelson-encoder', '@taquito/tzip16', '@taquito/utils', '@taquito/core'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.taquitoTzip12 = {}, global.michelsonEncoder, global.tzip16, global.utils, global.taquitoCore));
 })(this, (function (exports, michelsonEncoder, tzip16, utils, core) { 'use strict';
 
-    /******************************************************************************
-    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
+   *  Error that indicates the metadata not being found on the contract
+   */
+  class TokenMetadataNotFound extends core.TaquitoError {
+      constructor(address) {
+          super();
+          this.address = address;
+          this.name = 'TokenMetadataNotFound';
+          this.message = `No token metadata was found for the contract: ${address}`;
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates the token ID not being found
+   */
+  class TokenIdNotFound extends core.TaquitoError {
+      constructor(tokenId) {
+          super(`Could not find token metadata for the token ID: ${tokenId}`);
+          this.tokenId = tokenId;
+          this.name = 'TokenIdNotFound';
+      }
+  }
+  /**
+   *  @category Error
+   *  Error that indicates that the token metadata is invalid (not compliant with the TZIP-12 standard)
+   */
+  class InvalidTokenMetadata extends core.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.';
+      }
+  }
 
-    /**
-     *  @category Error
-     *  @description Error that indicates the metadata not being found on the contract
-     */
-    class TokenMetadataNotFound extends core.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 core.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 core.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 tzip16.Tzip16ContractAbstraction(this.contractAbstraction, this.context);
+      }
+      /**
+       * 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)
+       */
+      async getContractMetadata() {
+          try {
+              const contractMetadata = await this._tzip16ContractAbstraction.getMetadata();
+              return contractMetadata.metadata;
+          }
+          catch (err) {
+              // The contract is not compliant with Tzip-016. There is no contract metadata.
+          }
+      }
+      /**
+       * 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
+       */
+      async isTzip12Compliant() {
+          let isCompliant = false;
+          const metadata = await this.getContractMetadata();
+          if (metadata) {
+              const tzip12Interface = metadata.interfaces?.filter((x) => {
+                  return x.substring(0, 8) === 'TZIP-012';
+              });
+              isCompliant = tzip12Interface && tzip12Interface.length !== 0 ? true : false;
+          }
+          return isCompliant;
+      }
+      /**
+       * 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}
+       */
+      async getTokenMetadata(tokenId) {
+          const tokenMetadata = await this.retrieveTokenMetadataFromView(tokenId);
+          return !tokenMetadata ? this.retrieveTokenMetadataFromBigMap(tokenId) : tokenMetadata;
+      }
+      async retrieveTokenMetadataFromView(tokenId) {
+          if (await this.getContractMetadata()) {
+              const views = await 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;
+      }
+      async executeTokenMetadataView(tokenMetadataView, tokenId) {
+          const tokenMetadata = await tokenMetadataView.executeView(tokenId);
+          const tokenMap = Object.values(tokenMetadata)[1];
+          if (!michelsonEncoder.MichelsonMap.isMichelsonMap(tokenMap)) {
+              throw new TokenMetadataNotFound(this.contractAbstraction.address);
+          }
+          const metadataFromUri = await this.fetchTokenMetadataFromUri(tokenMap);
+          return this.formatMetadataToken(tokenId, tokenMap, metadataFromUri);
+      }
+      async fetchTokenMetadataFromUri(tokenMetadata) {
+          const uri = tokenMetadata.get('');
+          if (uri) {
+              try {
+                  const metadataFromUri = await this.context.metadataProvider.provideMetadata(this.contractAbstraction, utils.bytesToString(uri), this.context);
+                  return metadataFromUri.metadata;
+              }
+              catch (e) {
+                  if (e.name === 'InvalidUriError') {
+                      console.warn(`The URI ${utils.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(utils.bytesToString(metadataTokenMap.get(keyTokenMetadata))),
+                  });
+              }
+              else if (!(keyTokenMetadata === '')) {
+                  Object.assign(tokenMetadataDecoded, {
+                      // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                      [keyTokenMetadata]: utils.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;
+      }
+      async retrieveTokenMetadataFromBigMap(tokenId) {
+          const bigmapTokenMetadataId = await this.findTokenMetadataBigMap();
+          let pairNatMap;
+          try {
+              pairNatMap = await this.context.contract.getBigMapKeyByID(bigmapTokenMetadataId['int'].toString(), tokenId.toString(), new michelsonEncoder.Schema(tokenMetadataBigMapType));
+          }
+          catch (err) {
+              throw new TokenIdNotFound(tokenId);
+          }
+          const michelsonMap = pairNatMap['token_info'];
+          if (!michelsonEncoder.MichelsonMap.isMichelsonMap(michelsonMap)) {
+              throw new TokenIdNotFound(tokenId);
+          }
+          const metadataFromUri = await this.fetchTokenMetadataFromUri(michelsonMap);
+          return this.formatMetadataToken(tokenId, michelsonMap, metadataFromUri);
+      }
+      async findTokenMetadataBigMap() {
+          const tokenMetadataBigMapId = this.contractAbstraction.schema.FindFirstInTopLevelPair(await this.context.readProvider.getStorage(this.contractAbstraction.address, 'head'), tokenMetadataBigMapType);
+          if (!tokenMetadataBigMapId || !tokenMetadataBigMapId.int) {
+              throw new TokenMetadataNotFound(this.contractAbstraction.address);
+          }
+          return { int: tokenMetadataBigMapId.int };
+      }
+  }
 
-    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 tzip16.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 (!michelsonEncoder.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, utils.bytesToString(uri), this.context);
-                        return metadataFromUri.metadata;
-                    }
-                    catch (e) {
-                        if (e.name === 'InvalidUriError') {
-                            console.warn(`The URI ${utils.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(utils.bytesToString(metadataTokenMap.get(keyTokenMetadata))),
-                    });
-                }
-                else if (!(keyTokenMetadata === '')) {
-                    Object.assign(tokenMetadataDecoded, {
-                        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                        [keyTokenMetadata]: utils.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 michelsonEncoder.Schema(tokenMetadataBigMapType));
-                }
-                catch (err) {
-                    throw new TokenIdNotFound(tokenId);
-                }
-                const michelsonMap = pairNatMap['token_info'];
-                if (!michelsonEncoder.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];
+          },
+      });
+  }
 
-    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 tzip16.MetadataProvider(tzip16.DEFAULT_HANDLERS);
+      }
+      configureContext(context) {
+          Object.assign(context, { metadataProvider: this._metadataProvider });
+      }
+  }
 
-    // The same default metadataProvider is used for tzip16 and tzip12
-    class Tzip12Module {
-        constructor(metadataProvider) {
-            this._metadataProvider = metadataProvider ? metadataProvider : new tzip16.MetadataProvider(tzip16.DEFAULT_HANDLERS);
-        }
-        configureContext(context) {
-            Object.assign(context, { metadataProvider: this._metadataProvider });
-        }
-    }
+  // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
+  const VERSION = {
+      "commitHash": "27675679db6515e8b092195ef5c58c2c0ea5f5c8",
+      "version": "24.3.0-beta.0"
+  };
 
-    // IMPORTANT: THIS FILE IS AUTO GENERATED! DO NOT MANUALLY EDIT!
-    const VERSION = {
-        "commitHash": "3f0dac2d1edb047928bcbe89db422d4de60f007e",
-        "version": "24.2.0-beta.1"
-    };
-
-    exports.InvalidTokenMetadata = InvalidTokenMetadata;
-    exports.TokenIdNotFound = TokenIdNotFound;
-    exports.TokenMetadataNotFound = TokenMetadataNotFound;
-    exports.Tzip12ContractAbstraction = Tzip12ContractAbstraction;
-    exports.Tzip12Module = Tzip12Module;
-    exports.VERSION = VERSION;
-    exports.tzip12 = tzip12;
+  exports.InvalidTokenMetadata = InvalidTokenMetadata;
+  exports.TokenIdNotFound = TokenIdNotFound;
+  exports.TokenMetadataNotFound = TokenMetadataNotFound;
+  exports.Tzip12ContractAbstraction = Tzip12ContractAbstraction;
+  exports.Tzip12Module = Tzip12Module;
+  exports.VERSION = VERSION;
+  exports.tzip12 = tzip12;
 
 }));
 //# sourceMappingURL=taquito-tzip12.umd.js.map

package/dist/taquito-tzip12.umd.js.map

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

package/dist/types/errors.d.ts

@@ -2,7 +2,7 @@ import { TaquitoError } from '@taquito/core';
 import BigNumber from 'bignumber.js';
 /**
  *  @category Error
- *  @description Error that indicates the metadata not being found on the contract
+ *  Error that indicates the metadata not being found on the contract
  */
 export declare class TokenMetadataNotFound extends TaquitoError {
     readonly address: string;
@@ -10,7 +10,7 @@ export declare class TokenMetadataNotFound extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates the token ID not being found
+ *  Error that indicates the token ID not being found
  */
 export declare class TokenIdNotFound extends TaquitoError {
     readonly tokenId: BigNumber;
@@ -18,7 +18,7 @@ export declare class TokenIdNotFound extends TaquitoError {
 }
 /**
  *  @category Error
- *  @description Error that indicates that the token metadata is invalid (not compliant with the TZIP-12 standard)
+ *  Error that indicates that the token metadata is invalid (not compliant with the TZIP-12 standard)
  */
 export declare class InvalidTokenMetadata extends TaquitoError {
     readonly invalidMetadata: any;

package/dist/types/tzip12-contract-abstraction.d.ts

@@ -13,18 +13,18 @@ export declare class Tzip12ContractAbstraction {
     private _tzip16ContractAbstraction;
     constructor(contractAbstraction: ContractAbstraction<ContractProvider | Wallet>, context: MetadataContext);
     /**
-     * @description Fetches the contract metadata (according to the Tzip-016 standard)
+     * 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)
      */
     private getContractMetadata;
     /**
-     * @description The Tzip-016 "interfaces" field MUST be present in the contract metadata. It should contain "TZIP-012[version-info]"
+     * 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(): Promise<boolean>;
     /**
-     * @description Fetches the token metadata for a specified token ID.
+     * 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

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@taquito/tzip12",
-  "version": "24.2.0-beta.1",
-  "description": "Tzip12",
+  "version": "24.3.0-beta.0",
+  "description": "TZIP-12 token metadata support for Taquito.",
   "keywords": [
+    "taquito",
     "tezos",
-    "blockchain",
+    "typescript",
     "tzip12"
   ],
   "main": "dist/taquito-tzip12.umd.js",
@@ -17,14 +18,23 @@
   "publishConfig": {
     "access": "public"
   },
-  "author": "Roxane Letourneau <roxane@ecadlabs.com>",
+  "author": "ECAD Labs Inc <info@ecadlabs.com>",
+  "contributors": [
+    "Roxane Letourneau <roxane@ecadlabs.com>",
+    "Davis Sawali <davis.sawali@ecadlabs.com>",
+    "Jev Björsell (jevonearth)"
+  ],
+  "homepage": "https://taquito.io/",
   "repository": {
     "type": "git",
-    "url": ""
+    "url": "git+https://github.com/ecadlabs/taquito.git"
+  },
+  "bugs": {
+    "url": "https://github.com/ecadlabs/taquito/issues"
   },
   "license": "Apache-2.0",
   "engines": {
-    "node": ">=20"
+    "node": ">=22"
   },
   "scripts": {
     "lint": "eslint --ext .js,.ts .",
@@ -62,10 +72,10 @@
     ]
   },
   "dependencies": {
-    "@taquito/core": "^24.2.0-beta.1",
-    "@taquito/michelson-encoder": "^24.2.0-beta.1",
-    "@taquito/taquito": "^24.2.0-beta.1",
-    "@taquito/tzip16": "^24.2.0-beta.1"
+    "@taquito/core": "^24.3.0-beta.0",
+    "@taquito/michelson-encoder": "^24.3.0-beta.0",
+    "@taquito/taquito": "^24.3.0-beta.0",
+    "@taquito/tzip16": "^24.3.0-beta.0"
   },
   "devDependencies": {
     "@types/bluebird": "^3.5.42",
@@ -93,7 +103,7 @@
     "ts-jest": "^29.2.3",
     "ts-node": "^10.9.2",
     "ts-toolbelt": "^9.6.0",
-    "typescript": "~5.5.4"
+    "typescript": "^5.9.3"
   },
-  "gitHead": "96cefc251b1f16b14f9dedfb2eecda3dbeb2a829"
+  "gitHead": "551e35aeff7d6dcde1c72284238c0ed3c3aae77e"
 }