@alephium/web3 0.14.0 → 0.14.1

package/dist/src/token/nft.d.ts

@@ -1,10 +1,24 @@
+import 'cross-fetch/polyfill';
 export interface NFTMetadata {
     name: string;
-    description: string;
+    description?: string;
     image: string;
+    attributes?: [
+        {
+            trait_type: string;
+            value: string | number | boolean;
+        }
+    ];
 }
 export interface NFTCollectionMetadata {
     name: string;
     description: string;
     image: string;
 }
+export declare const validNFTMetadataFields: string[];
+export declare const validNFTMetadataAttributesFields: string[];
+export declare const validNFTMetadataAttributeTypes: string[];
+export declare const validNFTCollectionMetadataFields: string[];
+export declare function validateNFTMetadata(metadata: any): NFTMetadata;
+export declare function validateNFTCollectionMetadata(metadata: any): NFTCollectionMetadata;
+export declare function validateEnumerableNFTBaseUri(nftBaseUri: string, maxSupply: number): Promise<NFTMetadata[]>;

package/dist/src/token/nft.js

@@ -17,3 +17,103 @@ You should have received a copy of the GNU Lesser General Public License
 along with the library. If not, see <http://www.gnu.org/licenses/>.
 */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateEnumerableNFTBaseUri = exports.validateNFTCollectionMetadata = exports.validateNFTMetadata = exports.validNFTCollectionMetadataFields = exports.validNFTMetadataAttributeTypes = exports.validNFTMetadataAttributesFields = exports.validNFTMetadataFields = void 0;
+// JSON Schema for the NFT metadata, which is pointed to by the value
+// returned from the `getTokenUri` method of the NFT contract
+require("cross-fetch/polyfill");
+exports.validNFTMetadataFields = ['name', 'description', 'image', 'attributes'];
+exports.validNFTMetadataAttributesFields = ['trait_type', 'value'];
+exports.validNFTMetadataAttributeTypes = ['string', 'number', 'boolean'];
+exports.validNFTCollectionMetadataFields = ['name', 'description', 'image'];
+function validateNFTMetadata(metadata) {
+    Object.keys(metadata).forEach((key) => {
+        if (!exports.validNFTMetadataFields.includes(key)) {
+            throw new Error(`Invalid field ${key}, only ${exports.validNFTMetadataFields} are allowed`);
+        }
+    });
+    const name = validateNonEmptyString(metadata, 'name');
+    const description = validateNonEmptyStringIfExists(metadata, 'description');
+    const image = validateNonEmptyString(metadata, 'image');
+    const attributes = validateNFTMetadataAttributes(metadata['attributes']);
+    return { name, description, image, attributes };
+}
+exports.validateNFTMetadata = validateNFTMetadata;
+function validateNFTCollectionMetadata(metadata) {
+    Object.keys(metadata).forEach((key) => {
+        if (!exports.validNFTCollectionMetadataFields.includes(key)) {
+            throw new Error(`Invalid field ${key}, only ${exports.validNFTCollectionMetadataFields} are allowed`);
+        }
+    });
+    const name = validateNonEmptyString(metadata, 'name');
+    const description = validateNonEmptyString(metadata, 'description');
+    const image = validateNonEmptyString(metadata, 'image');
+    return { name, description, image };
+}
+exports.validateNFTCollectionMetadata = validateNFTCollectionMetadata;
+async function validateEnumerableNFTBaseUri(nftBaseUri, maxSupply) {
+    if (isInteger(maxSupply) && maxSupply > 0) {
+        const nftMetadataz = [];
+        for (let i = 0; i < maxSupply; i++) {
+            const nftMetadata = await fetchNFTMetadata(nftBaseUri, i);
+            const validatedNFTMetadata = validateNFTMetadata(nftMetadata);
+            nftMetadataz.push(validatedNFTMetadata);
+        }
+        return nftMetadataz;
+    }
+    else {
+        throw new Error('maxSupply should be a positive integer');
+    }
+}
+exports.validateEnumerableNFTBaseUri = validateEnumerableNFTBaseUri;
+function validateNFTMetadataAttributes(attributes) {
+    if (!!attributes) {
+        if (!Array.isArray(attributes)) {
+            throw new Error(`Field 'attributes' should be an array`);
+        }
+        attributes.forEach((item) => {
+            if (typeof item !== 'object') {
+                throw new Error(`Field 'attributes' should be an array of objects`);
+            }
+            Object.keys(item).forEach((key) => {
+                if (!exports.validNFTMetadataAttributesFields.includes(key)) {
+                    throw new Error(`Invalid field ${key} for attributes, only ${exports.validNFTMetadataAttributesFields} are allowed`);
+                }
+            });
+            validateNonEmptyString(item, 'trait_type');
+            validateNonEmptyAttributeValue(item, 'value');
+        });
+    }
+    return attributes;
+}
+function validateNonEmptyString(obj, field) {
+    const value = obj[`${field}`];
+    if (!(typeof value === 'string' && value !== '')) {
+        throw new Error(`JSON field '${field}' is not a non empty string`);
+    }
+    return value;
+}
+function validateNonEmptyStringIfExists(obj, field) {
+    const value = obj[`${field}`];
+    if (value !== undefined && !(typeof value === 'string' && value !== '')) {
+        throw new Error(`JSON field '${field}' is not a non empty string`);
+    }
+    return value;
+}
+function validateNonEmptyAttributeValue(obj, field) {
+    const value = obj[`${field}`];
+    if (!((typeof value === 'string' && value !== '') || typeof value === 'number' || typeof value === 'boolean')) {
+        throw new Error(`Attribute value should be a non empty string, number or boolean`);
+    }
+    return value;
+}
+async function fetchNFTMetadata(nftBaseUri, index) {
+    try {
+        return await (await fetch(`${nftBaseUri}${index}`)).json();
+    }
+    catch (e) {
+        throw new Error(`Error fetching NFT metadata from ${nftBaseUri}${index}: ${e}`);
+    }
+}
+function isInteger(num) {
+    return num === parseInt(num.toString(), 10);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alephium/web3",
-  "version": "0.14.0",
+  "version": "0.14.1",
   "description": "A JS/TS library to interact with the Alephium platform",
   "license": "GPL",
   "main": "dist/src/index.js",

package/src/token/nft.ts

@@ -18,10 +18,19 @@ along with the library. If not, see <http://www.gnu.org/licenses/>.
 
 // JSON Schema for the NFT metadata, which is pointed to by the value
 // returned from the `getTokenUri` method of the NFT contract
+
+import 'cross-fetch/polyfill'
+
 export interface NFTMetadata {
   name: string
-  description: string
+  description?: string
   image: string
+  attributes?: [
+    {
+      trait_type: string
+      value: string | number | boolean
+    }
+  ]
 }
 
 // JSON Schema for the NFT Collection metadata, which is pointed to by
@@ -32,3 +41,117 @@ export interface NFTCollectionMetadata {
   description: string
   image: string
 }
+
+export const validNFTMetadataFields = ['name', 'description', 'image', 'attributes']
+export const validNFTMetadataAttributesFields = ['trait_type', 'value']
+export const validNFTMetadataAttributeTypes = ['string', 'number', 'boolean']
+export const validNFTCollectionMetadataFields = ['name', 'description', 'image']
+
+export function validateNFTMetadata(metadata: any): NFTMetadata {
+  Object.keys(metadata).forEach((key) => {
+    if (!validNFTMetadataFields.includes(key)) {
+      throw new Error(`Invalid field ${key}, only ${validNFTMetadataFields} are allowed`)
+    }
+  })
+
+  const name = validateNonEmptyString(metadata, 'name')
+  const description = validateNonEmptyStringIfExists(metadata, 'description')
+  const image = validateNonEmptyString(metadata, 'image')
+  const attributes = validateNFTMetadataAttributes(metadata['attributes'])
+
+  return { name, description, image, attributes }
+}
+
+export function validateNFTCollectionMetadata(metadata: any): NFTCollectionMetadata {
+  Object.keys(metadata).forEach((key) => {
+    if (!validNFTCollectionMetadataFields.includes(key)) {
+      throw new Error(`Invalid field ${key}, only ${validNFTCollectionMetadataFields} are allowed`)
+    }
+  })
+
+  const name = validateNonEmptyString(metadata, 'name')
+  const description = validateNonEmptyString(metadata, 'description')
+  const image = validateNonEmptyString(metadata, 'image')
+
+  return { name, description, image }
+}
+
+export async function validateEnumerableNFTBaseUri(nftBaseUri: string, maxSupply: number): Promise<NFTMetadata[]> {
+  if (isInteger(maxSupply) && maxSupply > 0) {
+    const nftMetadataz: NFTMetadata[] = []
+
+    for (let i = 0; i < maxSupply; i++) {
+      const nftMetadata = await fetchNFTMetadata(nftBaseUri, i)
+      const validatedNFTMetadata = validateNFTMetadata(nftMetadata)
+      nftMetadataz.push(validatedNFTMetadata)
+    }
+
+    return nftMetadataz
+  } else {
+    throw new Error('maxSupply should be a positive integer')
+  }
+}
+
+function validateNFTMetadataAttributes(attributes: any): NFTMetadata['attributes'] {
+  if (!!attributes) {
+    if (!Array.isArray(attributes)) {
+      throw new Error(`Field 'attributes' should be an array`)
+    }
+
+    attributes.forEach((item) => {
+      if (typeof item !== 'object') {
+        throw new Error(`Field 'attributes' should be an array of objects`)
+      }
+
+      Object.keys(item).forEach((key) => {
+        if (!validNFTMetadataAttributesFields.includes(key)) {
+          throw new Error(`Invalid field ${key} for attributes, only ${validNFTMetadataAttributesFields} are allowed`)
+        }
+      })
+
+      validateNonEmptyString(item, 'trait_type')
+      validateNonEmptyAttributeValue(item, 'value')
+    })
+  }
+
+  return attributes as NFTMetadata['attributes']
+}
+
+function validateNonEmptyString(obj: object, field: string): string {
+  const value = obj[`${field}`]
+  if (!(typeof value === 'string' && value !== '')) {
+    throw new Error(`JSON field '${field}' is not a non empty string`)
+  }
+
+  return value
+}
+
+function validateNonEmptyStringIfExists(obj: object, field: string): string {
+  const value = obj[`${field}`]
+  if (value !== undefined && !(typeof value === 'string' && value !== '')) {
+    throw new Error(`JSON field '${field}' is not a non empty string`)
+  }
+
+  return value
+}
+
+function validateNonEmptyAttributeValue(obj: object, field: string): string | number | boolean {
+  const value = obj[`${field}`]
+  if (!((typeof value === 'string' && value !== '') || typeof value === 'number' || typeof value === 'boolean')) {
+    throw new Error(`Attribute value should be a non empty string, number or boolean`)
+  }
+
+  return value
+}
+
+async function fetchNFTMetadata(nftBaseUri: string, index: number) {
+  try {
+    return await (await fetch(`${nftBaseUri}${index}`)).json()
+  } catch (e) {
+    throw new Error(`Error fetching NFT metadata from ${nftBaseUri}${index}: ${e}`)
+  }
+}
+
+function isInteger(num: number) {
+  return num === parseInt(num.toString(), 10)
+}