@arcblock/nft 1.28.9 → 1.29.0

package/README.md

@@ -1,6 +1,5 @@
 ![nft](https://www.arcblock.io/.netlify/functions/badge/?text=nft)
 
-[![styled with prettier](https://img.shields.io/badge/styled_with-prettier-ff69b4.svg)](https://github.com/prettier/prettier)
 [![docs](https://img.shields.io/badge/powered%20by-arcblock-green.svg)](https://docs.arcblock.io)
 [![Gitter](https://badges.gitter.im/ArcBlock/community.svg)](https://gitter.im/ArcBlock/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
 

package/esm/enum.d.mts

@@ -0,0 +1,23 @@
+//#region src/enum.d.ts
+declare const NFTType: Readonly<{
+  readonly ticket: 0;
+  readonly coupon: 1;
+  readonly certificate: 2;
+  readonly badge: 3;
+  readonly license: 4;
+  readonly giftcard: 5;
+  readonly passport: 6;
+  readonly idcard: 7;
+  readonly receipt: 8;
+  readonly other: 127;
+}>;
+declare const NFTStatus: Readonly<{
+  readonly normal: 0;
+  readonly consumed: 1;
+  readonly invalid: 2;
+  readonly expired: 3;
+}>;
+type NFTTypeKey = keyof typeof NFTType;
+type NFTStatusKey = keyof typeof NFTStatus;
+//#endregion
+export { NFTStatus, NFTStatusKey, NFTType, NFTTypeKey };

package/esm/enum.mjs

@@ -0,0 +1,22 @@
+//#region src/enum.ts
+const NFTType = Object.freeze({
+	ticket: 0,
+	coupon: 1,
+	certificate: 2,
+	badge: 3,
+	license: 4,
+	giftcard: 5,
+	passport: 6,
+	idcard: 7,
+	receipt: 8,
+	other: 127
+});
+const NFTStatus = Object.freeze({
+	normal: 0,
+	consumed: 1,
+	invalid: 2,
+	expired: 3
+});
+
+//#endregion
+export { NFTStatus, NFTType };

package/esm/factory.d.mts

@@ -0,0 +1,141 @@
+import NFTIssuer from "./issuer.mjs";
+
+//#region src/factory.d.ts
+interface WalletObject {
+  address: string;
+  publicKey: Uint8Array | string;
+  sign: (data: string) => Promise<Uint8Array | string>;
+}
+interface IssuerParams {
+  name: string;
+  url?: string;
+  logo?: string;
+}
+interface NFTFactoryParams {
+  chainHost: string;
+  wallet: WalletObject;
+  issuer: IssuerParams;
+}
+interface DisplayObject {
+  type?: string;
+  content?: string;
+}
+interface AssetData {
+  typeUrl: string;
+  value: Record<string, unknown>;
+}
+interface Asset {
+  address?: string;
+  moniker: string;
+  readonly: boolean;
+  transferrable: boolean;
+  data: AssetData;
+  [key: string]: unknown;
+}
+interface CreateParams {
+  display?: string | DisplayObject;
+  data?: Record<string, unknown>;
+  attributes?: Record<string, unknown>;
+}
+/**
+ * Used to create standard asset on forge powered blockchain
+ * All assets are signed assets, eg, the asset data are self approvable
+ */
+declare class NFTFactory {
+  chainHost: string;
+  client: unknown;
+  wallet: WalletObject;
+  issuer: NFTIssuer;
+  /**
+   * Creates an instance of NFTFactory.
+   * @param params - Factory parameters
+   * @param params.chainHost - on which chain to create wallet
+   * @param params.wallet - issuer wallet
+   * @param params.issuer - issuer attributes, such as name, url and logo
+   */
+  constructor({
+    chainHost,
+    wallet,
+    issuer
+  }: NFTFactoryParams);
+  /**
+   * Create a ticket
+   *
+   * @param params - Ticket parameters
+   * @param params.display - display of the ticket { type, content }
+   * @param params.data - asset payload
+   * @param params.attributes - asset attributes
+   * @returns Promise resolving to [asset, hash]
+   */
+  createTicket({
+    display,
+    data,
+    attributes
+  }: CreateParams): Promise<[Asset, string]>;
+  /**
+   * Create a coupon asset
+   *
+   * @param params - Coupon parameters
+   * @param params.display - display of the coupon { type, content }
+   * @param params.data - asset payload
+   * @param params.attributes - asset attributes
+   * @returns Promise resolving to [asset, hash]
+   */
+  createCoupon({
+    display,
+    data,
+    attributes
+  }: CreateParams): Promise<[Asset, string]>;
+  /**
+   * Create a certificate asset
+   *
+   * @param params - Certificate parameters
+   * @param params.display - display of the certificate { type, content }
+   * @param params.data - asset payload
+   * @param params.attributes - asset attributes
+   * @returns Promise resolving to [asset, hash]
+   */
+  createCertificate({
+    display,
+    data,
+    attributes
+  }: CreateParams): Promise<[Asset, string]>;
+  /**
+   * Create a badge
+   *
+   * @param params - Badge parameters
+   * @param params.display - display of the badge { type, content }
+   * @param params.data - asset payload
+   * @param params.attributes - asset attributes
+   * @returns Promise resolving to [asset, hash]
+   */
+  createBadge({
+    display,
+    data,
+    attributes
+  }: CreateParams): Promise<[Asset, string]>;
+  /**
+   * Create a passport
+   *
+   * @param params - Passport parameters
+   * @param params.display - display of the passport { type, content }
+   * @param params.data - asset payload
+   * @param params.attributes - asset attributes
+   * @returns Promise resolving to [asset, hash]
+   */
+  createPassport({
+    display,
+    data,
+    attributes
+  }: CreateParams): Promise<[Asset, string]>;
+  createSignedAsset(payload: Record<string, unknown>, attributes: Record<string, unknown>): Promise<[Asset, string]>;
+  _createDisplay(display: string | DisplayObject): DisplayObject;
+  _createCert({
+    display,
+    data,
+    attributes
+  }: CreateParams): Promise<[Asset, string]>;
+  getVCBody(asset: Asset): Record<string, unknown> | null;
+}
+//#endregion
+export { NFTFactory as default };

package/esm/factory.mjs

@@ -0,0 +1,310 @@
+import issuer_default from "./issuer.mjs";
+import recipient_default from "./recipient.mjs";
+import { name } from "./package.mjs";
+import { toAssetAddress } from "@arcblock/did-util";
+import { create } from "@arcblock/vc";
+import Client from "@ocap/client";
+import { toBase58 } from "@ocap/util";
+import { isValid } from "@ocap/wallet";
+import Debug from "debug";
+import stringify from "json-stable-stringify";
+import cloneDeep from "lodash/cloneDeep.js";
+import get from "lodash/get.js";
+import isDate from "lodash/isDate.js";
+import isNumber from "lodash/isNumber.js";
+
+//#region src/factory.ts
+const debug = Debug(name);
+/**
+* Used to create standard asset on forge powered blockchain
+* All assets are signed assets, eg, the asset data are self approvable
+*/
+var NFTFactory = class {
+	/**
+	* Creates an instance of NFTFactory.
+	* @param params - Factory parameters
+	* @param params.chainHost - on which chain to create wallet
+	* @param params.wallet - issuer wallet
+	* @param params.issuer - issuer attributes, such as name, url and logo
+	*/
+	constructor({ chainHost, wallet, issuer }) {
+		if (!chainHost) throw new Error("NFTFactory requires valid chain host");
+		if (isValid(wallet) === false) throw new Error("NFTFactory requires valid wallet issuer");
+		this.chainHost = chainHost;
+		this.client = new Client(chainHost);
+		this.wallet = wallet;
+		this.issuer = new issuer_default({
+			wallet,
+			...issuer
+		});
+	}
+	/**
+	* Create a ticket
+	*
+	* @param params - Ticket parameters
+	* @param params.display - display of the ticket { type, content }
+	* @param params.data - asset payload
+	* @param params.attributes - asset attributes
+	* @returns Promise resolving to [asset, hash]
+	*/
+	async createTicket({ display = "", data = {}, attributes = {} }) {
+		const requiredFields = [
+			"name",
+			"description",
+			"location"
+		];
+		const timeFields = ["startTime", "endTime"];
+		requiredFields.forEach((x) => {
+			if (!data[x]) throw new Error(`Missing required field ${x} when creating ticket asset`);
+		});
+		timeFields.forEach((x) => {
+			if (!isDate(new Date(data[x]))) throw new Error(`Invalid date field ${x} when creating ticket asset`);
+		});
+		const { name: name$1, description, location, recipient, type, startTime, endTime, display: innerDisplay = "", issuanceDate } = data;
+		if (!(recipient instanceof recipient_default)) throw new Error(`Invalid recipient field when creating ${type} asset`);
+		const vc = await create({
+			type: [
+				type,
+				"NFTTicket",
+				"VerifiableCredential"
+			].filter(Boolean),
+			issuer: {
+				wallet: this.wallet,
+				name: this.issuer.attributes.name
+			},
+			subject: {
+				id: recipient.wallet.address,
+				name: name$1,
+				description,
+				location,
+				display: this._createDisplay(display || innerDisplay),
+				startTime: new Date(startTime),
+				endTime: new Date(endTime)
+			},
+			issuanceDate: issuanceDate || /* @__PURE__ */ new Date(),
+			expirationDate: new Date(endTime)
+		});
+		debug("createTicket.vc", vc);
+		return this.createSignedAsset(vc, attributes);
+	}
+	/**
+	* Create a coupon asset
+	*
+	* @param params - Coupon parameters
+	* @param params.display - display of the coupon { type, content }
+	* @param params.data - asset payload
+	* @param params.attributes - asset attributes
+	* @returns Promise resolving to [asset, hash]
+	*/
+	async createCoupon({ display = "", data = {}, attributes = {} }) {
+		const requiredFields = ["name", "description"];
+		const numberFields = [
+			"ratio",
+			"amount",
+			"minAmount"
+		];
+		const timeFields = ["startTime", "expireTime"];
+		requiredFields.forEach((x) => {
+			if (!data[x]) throw new Error(`Missing required field ${x} when creating coupon asset`);
+		});
+		numberFields.forEach((x) => {
+			if (!data[x] || !isNumber(data[x])) throw new Error(`Invalid number field ${x} when creating coupon asset`);
+		});
+		timeFields.forEach((x) => {
+			if (!isDate(new Date(data[x]))) throw new Error(`Invalid date field ${x} when creating coupon asset`);
+		});
+		const { name: name$1, description, ratio, amount, location, minAmount, expireTime, type, recipient, display: innerDisplay = "", issuanceDate, endpoint, endpointScope } = data;
+		const vc = await create({
+			type: [
+				type,
+				"NFTCoupon",
+				"VerifiableCredential"
+			].filter(Boolean),
+			issuer: {
+				wallet: this.issuer.wallet,
+				name: this.issuer.attributes.name
+			},
+			subject: {
+				id: recipient.wallet.address,
+				name: name$1,
+				description,
+				location,
+				ratio,
+				amount,
+				minAmount,
+				display: this._createDisplay(display || innerDisplay)
+			},
+			endpoint,
+			endpointScope,
+			issuanceDate: issuanceDate || /* @__PURE__ */ new Date(),
+			expirationDate: new Date(expireTime)
+		});
+		debug("createTicket.coupon", vc);
+		return this.createSignedAsset(vc, attributes);
+	}
+	/**
+	* Create a certificate asset
+	*
+	* @param params - Certificate parameters
+	* @param params.display - display of the certificate { type, content }
+	* @param params.data - asset payload
+	* @param params.attributes - asset attributes
+	* @returns Promise resolving to [asset, hash]
+	*/
+	createCertificate({ display = "", data = {}, attributes = {} }) {
+		return this._createCert({
+			data,
+			display,
+			attributes
+		});
+	}
+	/**
+	* Create a badge
+	*
+	* @param params - Badge parameters
+	* @param params.display - display of the badge { type, content }
+	* @param params.data - asset payload
+	* @param params.attributes - asset attributes
+	* @returns Promise resolving to [asset, hash]
+	*/
+	async createBadge({ display = "", data = {}, attributes = {} }) {
+		const { name: name$1, recipient, description, display: innerDisplay = "", type, endpoint, endpointScope } = data;
+		const vc = await create({
+			type: [
+				type,
+				"NFTBadge",
+				"VerifiableCredential"
+			].filter(Boolean),
+			issuer: {
+				wallet: this.wallet,
+				name: this.issuer.attributes.name
+			},
+			subject: {
+				id: recipient.wallet.address,
+				name: name$1,
+				description,
+				display: this._createDisplay(display || innerDisplay)
+			},
+			endpoint,
+			endpointScope
+		});
+		return this.createSignedAsset(vc, attributes);
+	}
+	/**
+	* Create a passport
+	*
+	* @param params - Passport parameters
+	* @param params.display - display of the passport { type, content }
+	* @param params.data - asset payload
+	* @param params.attributes - asset attributes
+	* @returns Promise resolving to [asset, hash]
+	*/
+	async createPassport({ display = "", data = {}, attributes = {} }) {
+		const { recipient, passport, display: innerDisplay = "", type, endpoint, endpointScope } = data;
+		const passportData = passport;
+		if (!passportData || !passportData.name || !passportData.title) throw new Error("NFTPassport requires valid passport object: which must have a name and a title");
+		const vc = await create({
+			type: [
+				type,
+				"NFTPassport",
+				"VerifiableCredential"
+			].filter(Boolean),
+			issuer: {
+				wallet: this.wallet,
+				name: this.issuer.attributes.name
+			},
+			subject: {
+				id: recipient.wallet.address,
+				passport,
+				display: this._createDisplay(display || innerDisplay)
+			},
+			endpoint,
+			endpointScope
+		});
+		return this.createSignedAsset(vc, attributes);
+	}
+	async createSignedAsset(payload, attributes) {
+		payload.signature = toBase58(await this.wallet.sign(stringify(payload)));
+		const asset = {
+			moniker: get(payload, "data.name") || get(payload, "credentialSubject.name") || "signed_asset",
+			readonly: false,
+			transferrable: true,
+			data: {
+				typeUrl: "vc",
+				value: payload
+			},
+			...attributes
+		};
+		asset.address = toAssetAddress(asset);
+		return [asset, await this.client.sendCreateAssetTx({
+			tx: { itx: asset },
+			wallet: this.wallet
+		})];
+	}
+	_createDisplay(display) {
+		if (display) {
+			if (typeof display === "string") return {
+				type: "svg_gzipped",
+				content: display
+			};
+			return display;
+		}
+		return {};
+	}
+	async _createCert({ display = "", data = {}, attributes = {} }) {
+		const requiredFields = [
+			"name",
+			"description",
+			"reason",
+			"logoUrl"
+		];
+		const timeFields = ["issueTime", "expireTime"];
+		requiredFields.forEach((x) => {
+			if (!data[x]) throw new Error(`Missing required field ${x} when creating certificate`);
+		});
+		timeFields.forEach((x) => {
+			if (!isDate(new Date(data[x]))) throw new Error(`Invalid date field ${x} when creating certificate`);
+		});
+		if (!(data.recipient instanceof recipient_default)) throw new Error("Invalid recipient field when creating certificate");
+		const { name: name$1, description, reason, logoUrl, recipient, type, expireTime, display: innerDisplay = "", issuanceDate, endpoint, endpointScope } = data;
+		const vc = await create({
+			type: [
+				type,
+				"NFTCertificate",
+				"VerifiableCredential"
+			].filter(Boolean),
+			issuer: {
+				wallet: this.wallet,
+				name: this.issuer.attributes.name
+			},
+			subject: {
+				id: recipient.wallet.address,
+				name: name$1,
+				description,
+				reason,
+				logoUrl,
+				display: this._createDisplay(display || innerDisplay)
+			},
+			endpoint,
+			endpointScope,
+			issuanceDate: issuanceDate || /* @__PURE__ */ new Date(),
+			expirationDate: +new Date(expireTime)
+		});
+		debug("createCert.vc", vc);
+		return this.createSignedAsset(vc, attributes);
+	}
+	getVCBody(asset) {
+		if (!asset.data) return null;
+		if (!asset.data.typeUrl) return null;
+		if (asset.data.typeUrl === "vc") {
+			const vc = cloneDeep(asset.data.value);
+			delete vc.signature;
+			return vc;
+		}
+		return null;
+	}
+};
+var factory_default = NFTFactory;
+
+//#endregion
+export { factory_default as default };

package/esm/index.d.mts

@@ -0,0 +1,5 @@
+import { NFTStatus, NFTStatusKey, NFTType, NFTTypeKey } from "./enum.mjs";
+import NFTIssuer from "./issuer.mjs";
+import NFTFactory from "./factory.mjs";
+import NFTRecipient from "./recipient.mjs";
+export { NFTFactory, NFTIssuer, NFTRecipient, NFTStatus, type NFTStatusKey, NFTType, type NFTTypeKey };

package/esm/index.mjs

@@ -0,0 +1,6 @@
+import { NFTStatus, NFTType } from "./enum.mjs";
+import issuer_default from "./issuer.mjs";
+import recipient_default from "./recipient.mjs";
+import factory_default from "./factory.mjs";
+
+export { factory_default as NFTFactory, issuer_default as NFTIssuer, recipient_default as NFTRecipient, NFTStatus, NFTType };

package/esm/issuer.d.mts

@@ -0,0 +1,44 @@
+//#region src/issuer.d.ts
+interface IssuerAttributes {
+  name: string;
+  url?: string;
+  logo?: string;
+}
+interface WalletObject {
+  address: string;
+  publicKey: Uint8Array | string;
+}
+interface NFTIssuerParams extends IssuerAttributes {
+  wallet: WalletObject;
+}
+/**
+ * Represents an NFT issuer with wallet and metadata
+ */
+declare class NFTIssuer {
+  wallet: WalletObject;
+  attributes: IssuerAttributes;
+  /**
+   * Creates an instance of NFTIssuer.
+   *
+   * @param params - Issuer parameters
+   * @param params.wallet - wallet object
+   * @param params.name - issuer name
+   * @param params.url - issuer website
+   * @param params.logo - issuer logo image url or logo base64
+   */
+  constructor({
+    wallet,
+    name,
+    url,
+    logo
+  }: NFTIssuerParams);
+  toJSON(): {
+    name: string;
+    url?: string;
+    logo?: string;
+    did: string;
+    pk: any;
+  };
+}
+//#endregion
+export { NFTIssuer as default };

package/esm/issuer.mjs

@@ -0,0 +1,36 @@
+import { toBase58 } from "@ocap/util";
+
+//#region src/issuer.ts
+/**
+* Represents an NFT issuer with wallet and metadata
+*/
+var NFTIssuer = class {
+	/**
+	* Creates an instance of NFTIssuer.
+	*
+	* @param params - Issuer parameters
+	* @param params.wallet - wallet object
+	* @param params.name - issuer name
+	* @param params.url - issuer website
+	* @param params.logo - issuer logo image url or logo base64
+	*/
+	constructor({ wallet, name, url, logo }) {
+		this.wallet = wallet;
+		this.attributes = {
+			name,
+			url,
+			logo
+		};
+	}
+	toJSON() {
+		return {
+			did: this.wallet.address,
+			pk: toBase58(this.wallet.publicKey),
+			...this.attributes
+		};
+	}
+};
+var issuer_default = NFTIssuer;
+
+//#endregion
+export { issuer_default as default };

package/esm/package.mjs

@@ -0,0 +1,5 @@
+//#region package.json
+var name = "@arcblock/nft";
+
+//#endregion
+export { name };

package/esm/recipient.d.mts

@@ -0,0 +1,40 @@
+//#region src/recipient.d.ts
+interface RecipientAttributes {
+  name: string;
+  location?: string;
+}
+interface WalletObject {
+  address: string;
+  publicKey: Uint8Array | string;
+}
+interface NFTRecipientParams extends RecipientAttributes {
+  wallet: WalletObject;
+}
+/**
+ * Represents an NFT recipient with wallet and metadata
+ */
+declare class NFTRecipient {
+  wallet: WalletObject;
+  attributes: RecipientAttributes;
+  /**
+   * Creates an instance of NFTRecipient.
+   *
+   * @param params - Recipient parameters
+   * @param params.wallet - wallet object
+   * @param params.name - recipient name
+   * @param params.location - recipient location
+   */
+  constructor({
+    wallet,
+    name,
+    location
+  }: NFTRecipientParams);
+  toJSON(): {
+    name: string;
+    location?: string;
+    did: string;
+    pk: any;
+  };
+}
+//#endregion
+export { NFTRecipient as default };

package/esm/recipient.mjs

@@ -0,0 +1,34 @@
+import { toBase58 } from "@ocap/util";
+
+//#region src/recipient.ts
+/**
+* Represents an NFT recipient with wallet and metadata
+*/
+var NFTRecipient = class {
+	/**
+	* Creates an instance of NFTRecipient.
+	*
+	* @param params - Recipient parameters
+	* @param params.wallet - wallet object
+	* @param params.name - recipient name
+	* @param params.location - recipient location
+	*/
+	constructor({ wallet, name, location }) {
+		this.wallet = wallet;
+		this.attributes = {
+			name,
+			location
+		};
+	}
+	toJSON() {
+		return {
+			did: this.wallet.address,
+			pk: toBase58(this.wallet.publicKey),
+			...this.attributes
+		};
+	}
+};
+var recipient_default = NFTRecipient;
+
+//#endregion
+export { recipient_default as default };