@arcblock/nft 1.28.8 → 1.29.0

package/lib/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/lib/enum.cjs

@@ -0,0 +1,24 @@
+
+//#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
+exports.NFTStatus = NFTStatus;
+exports.NFTType = NFTType;

package/lib/enum.d.cts

@@ -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/lib/factory.cjs

@@ -0,0 +1,319 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_issuer = require('./issuer.cjs');
+const require_recipient = require('./recipient.cjs');
+const require_package = require('./package.cjs');
+let _arcblock_did_util = require("@arcblock/did-util");
+let _arcblock_vc = require("@arcblock/vc");
+let _ocap_client = require("@ocap/client");
+_ocap_client = require_rolldown_runtime.__toESM(_ocap_client);
+let _ocap_util = require("@ocap/util");
+let _ocap_wallet = require("@ocap/wallet");
+let debug = require("debug");
+debug = require_rolldown_runtime.__toESM(debug);
+let json_stable_stringify = require("json-stable-stringify");
+json_stable_stringify = require_rolldown_runtime.__toESM(json_stable_stringify);
+let lodash_cloneDeep = require("lodash/cloneDeep");
+lodash_cloneDeep = require_rolldown_runtime.__toESM(lodash_cloneDeep);
+let lodash_get = require("lodash/get");
+lodash_get = require_rolldown_runtime.__toESM(lodash_get);
+let lodash_isDate = require("lodash/isDate");
+lodash_isDate = require_rolldown_runtime.__toESM(lodash_isDate);
+let lodash_isNumber = require("lodash/isNumber");
+lodash_isNumber = require_rolldown_runtime.__toESM(lodash_isNumber);
+
+//#region src/factory.ts
+const debug$1 = (0, debug.default)(require_package.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 ((0, _ocap_wallet.isValid)(wallet) === false) throw new Error("NFTFactory requires valid wallet issuer");
+		this.chainHost = chainHost;
+		this.client = new _ocap_client.default(chainHost);
+		this.wallet = wallet;
+		this.issuer = new require_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 (!(0, lodash_isDate.default)(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 require_recipient.default)) throw new Error(`Invalid recipient field when creating ${type} asset`);
+		const vc = await (0, _arcblock_vc.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$1("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] || !(0, lodash_isNumber.default)(data[x])) throw new Error(`Invalid number field ${x} when creating coupon asset`);
+		});
+		timeFields.forEach((x) => {
+			if (!(0, lodash_isDate.default)(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 (0, _arcblock_vc.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$1("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 (0, _arcblock_vc.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 (0, _arcblock_vc.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 = (0, _ocap_util.toBase58)(await this.wallet.sign((0, json_stable_stringify.default)(payload)));
+		const asset = {
+			moniker: (0, lodash_get.default)(payload, "data.name") || (0, lodash_get.default)(payload, "credentialSubject.name") || "signed_asset",
+			readonly: false,
+			transferrable: true,
+			data: {
+				typeUrl: "vc",
+				value: payload
+			},
+			...attributes
+		};
+		asset.address = (0, _arcblock_did_util.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 (!(0, lodash_isDate.default)(new Date(data[x]))) throw new Error(`Invalid date field ${x} when creating certificate`);
+		});
+		if (!(data.recipient instanceof require_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 (0, _arcblock_vc.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$1("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 = (0, lodash_cloneDeep.default)(asset.data.value);
+			delete vc.signature;
+			return vc;
+		}
+		return null;
+	}
+};
+var factory_default = NFTFactory;
+
+//#endregion
+exports.default = factory_default;

package/lib/factory.d.cts

@@ -0,0 +1,141 @@
+import NFTIssuer from "./issuer.cjs";
+
+//#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/lib/index.cjs

@@ -0,0 +1,10 @@
+const require_enum = require('./enum.cjs');
+const require_issuer = require('./issuer.cjs');
+const require_recipient = require('./recipient.cjs');
+const require_factory = require('./factory.cjs');
+
+exports.NFTFactory = require_factory.default;
+exports.NFTIssuer = require_issuer.default;
+exports.NFTRecipient = require_recipient.default;
+exports.NFTStatus = require_enum.NFTStatus;
+exports.NFTType = require_enum.NFTType;

package/lib/index.d.cts

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

package/lib/issuer.cjs

@@ -0,0 +1,38 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _ocap_util = require("@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: (0, _ocap_util.toBase58)(this.wallet.publicKey),
+			...this.attributes
+		};
+	}
+};
+var issuer_default = NFTIssuer;
+
+//#endregion
+exports.default = issuer_default;

package/lib/issuer.d.cts

@@ -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/lib/package.cjs

@@ -0,0 +1,11 @@
+
+//#region package.json
+var name = "@arcblock/nft";
+
+//#endregion
+Object.defineProperty(exports, 'name', {
+  enumerable: true,
+  get: function () {
+    return name;
+  }
+});

package/lib/recipient.cjs

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+let _ocap_util = require("@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: (0, _ocap_util.toBase58)(this.wallet.publicKey),
+			...this.attributes
+		};
+	}
+};
+var recipient_default = NFTRecipient;
+
+//#endregion
+exports.default = recipient_default;