@arcblock/validator 1.18.166 → 1.19.0

package/esm/extension/bn.d.ts

@@ -0,0 +1,96 @@
+import { Root, AnySchema } from 'joi';
+import BN from 'bn.js';
+export interface BNSchema extends AnySchema {
+    min(threshold: any): this;
+    gte(threshold: any): this;
+    max(threshold: any): this;
+    lte(threshold: any): this;
+    greater(threshold: any): this;
+    gt(threshold: any): this;
+    less(threshold: any): this;
+    lt(threshold: any): this;
+    positive(): this;
+    negative(): this;
+}
+export declare function BNExtension(root: Root): {
+    type: string;
+    base: AnySchema<any>;
+    messages: {
+        'bn.nan': string;
+        'bn.max': string;
+        'bn.min': string;
+        'bn.less': string;
+        'bn.greater': string;
+        'bn.positive': string;
+        'bn.negative': string;
+    };
+    prepare(value: any, helpers: any): {
+        value: BN;
+        errors?: undefined;
+    } | {
+        errors: any;
+        value?: undefined;
+    };
+    coerce(value: BN): {
+        value: string;
+    };
+    validate(value: any): {
+        value: any;
+    };
+    rules: {
+        gt: {
+            args: ({
+                name: string;
+                ref: boolean;
+                assert: (v: any) => v is BN;
+                message: string;
+                normalize: (v: any) => BN;
+            } | {
+                name: string;
+                assert: (v: any) => v is boolean;
+                message: string;
+                ref?: undefined;
+                normalize?: undefined;
+            })[];
+            validate(value: any, helpers: any, args: any): any;
+        };
+        lt: {
+            args: ({
+                name: string;
+                ref: boolean;
+                assert: (v: any) => v is BN;
+                message: string;
+                normalize: (v: any) => BN;
+            } | {
+                name: string;
+                assert: (v: any) => v is boolean;
+                message: string;
+                ref?: undefined;
+                normalize?: undefined;
+            })[];
+            validate(value: any, helpers: any, args: any): any;
+        };
+        min: {
+            alias: string;
+            method(threshold: any): BNSchema;
+        };
+        max: {
+            alias: string;
+            method(threshold: any): BNSchema;
+        };
+        greater: {
+            alias: string;
+            method(threshold: any): BNSchema;
+        };
+        less: {
+            alias: string;
+            method(threshold: any): BNSchema;
+        };
+        positive: {
+            method(): BNSchema;
+        };
+        negative: {
+            method(): BNSchema;
+        };
+    };
+};

package/esm/extension/bn.js

@@ -0,0 +1,130 @@
+import BN from 'bn.js';
+export function BNExtension(root) {
+    return {
+        type: 'BN',
+        base: root.any(),
+        messages: {
+            'bn.nan': '{{#label}} is not a big number',
+            'bn.max': '{{#label}} needs to be less than or equal to "{{#threshold}}"',
+            'bn.min': '{{#label}} needs to be greater than or equal to "{{#threshold}}"',
+            'bn.less': '{{#label}} needs to be less than "{{#threshold}}"',
+            'bn.greater': '{{#label}} needs to be greater than "{{#threshold}}"',
+            'bn.positive': '{{#label}} needs to be positive',
+            'bn.negative': '{{#label}} needs to be negative',
+        },
+        prepare(value, helpers) {
+            try {
+                return { value: new BN(value) };
+            }
+            catch (err) {
+                return { errors: helpers.error('bn.nan') };
+            }
+        },
+        coerce(value) {
+            return { value: value.toString(10) };
+        },
+        validate(value) {
+            return { value };
+        },
+        rules: {
+            gt: {
+                args: [
+                    {
+                        name: 'threshold',
+                        ref: true,
+                        assert: (v) => BN.isBN(v),
+                        message: 'must be a big number',
+                        normalize: (v) => new BN(v),
+                    },
+                    {
+                        name: 'equal',
+                        assert: (v) => typeof v === 'boolean',
+                        message: 'must be a boolean',
+                    },
+                ],
+                // The rule return structure is different from the root
+                // eslint-disable-next-line consistent-return
+                validate(value, helpers, args) {
+                    const v = new BN(value);
+                    if (args.equal && v.lt(args.threshold)) {
+                        return helpers.error('bn.min', args);
+                    }
+                    if (!args.equal && v.lte(args.threshold)) {
+                        return helpers.error('bn.greater', args);
+                    }
+                    // must return value when valid
+                    return value;
+                },
+            },
+            lt: {
+                args: [
+                    {
+                        name: 'threshold',
+                        ref: true,
+                        assert: (v) => BN.isBN(v),
+                        message: 'must be a big number',
+                        normalize: (v) => new BN(v),
+                    },
+                    {
+                        name: 'equal',
+                        assert: (v) => typeof v === 'boolean',
+                        message: 'must be a boolean',
+                    },
+                ],
+                // The rule return structure is different from the root
+                // eslint-disable-next-line consistent-return
+                validate(value, helpers, args) {
+                    const v = new BN(value);
+                    if (args.equal && v.gt(args.threshold)) {
+                        return helpers.error('bn.max', args);
+                    }
+                    if (!args.equal && v.gte(args.threshold)) {
+                        return helpers.error('bn.less', args);
+                    }
+                    // must return value when valid
+                    return value;
+                },
+            },
+            min: {
+                alias: 'gte',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'gt', args: { threshold, equal: true } });
+                },
+            },
+            max: {
+                alias: 'lte',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'lt', args: { threshold, equal: true } });
+                },
+            },
+            greater: {
+                alias: 'gt',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'gt', args: { threshold, equal: false } });
+                },
+            },
+            less: {
+                alias: 'lt',
+                method(threshold) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'lt', args: { threshold, equal: false } });
+                },
+            },
+            positive: {
+                method() {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'gt', args: { threshold: 0, equal: false } });
+                },
+            },
+            negative: {
+                method() {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'lt', args: { threshold: 0, equal: false } });
+                },
+            },
+        },
+    };
+}

package/esm/extension/did.d.ts

@@ -0,0 +1,77 @@
+import { Root, StringSchema } from 'joi';
+import { KeyType, HashType, RoleType } from '@ocap/mcrypto';
+import { DIDTypeShortcut } from '@arcblock/did';
+export interface DIDSchema extends StringSchema {
+    wallet(type: DIDTypeShortcut): this;
+    pk(type: KeyType): this;
+    hash(type: HashType): this;
+    role(type: RoleType): this;
+    prefix(str?: string): this;
+}
+export declare function DIDExtension(root: Root): {
+    type: string;
+    base: StringSchema<string>;
+    messages: {
+        'did.empty': string;
+        'did.invalid': string;
+        'did.wallet': string;
+        'did.pk': string;
+        'did.hash': string;
+        'did.role': string;
+        'did.prefix': string;
+    };
+    validate(value: any, helpers: any): {
+        errors: any;
+        value?: undefined;
+    } | {
+        value: string;
+        errors?: undefined;
+    };
+    rules: {
+        type: {
+            args: ({
+                name: string;
+                ref: boolean;
+                assert: (v: string) => boolean;
+                message: string;
+            } | {
+                name: string;
+                assert: (v: string) => boolean;
+                message: string;
+                ref?: undefined;
+            })[];
+            validate(value: string, helpers: any, args: any): any;
+        };
+        pk: {
+            method(type: KeyType): DIDSchema;
+        };
+        hash: {
+            method(type: HashType): DIDSchema;
+        };
+        role: {
+            method(type: RoleType): DIDSchema;
+        };
+        wallet: {
+            method(type: DIDTypeShortcut): DIDSchema;
+            args: {
+                name: string;
+                ref: boolean;
+                assert: (v: any) => boolean;
+                message: string;
+                normalize: (v: any) => any;
+            }[];
+            validate(value: any, helpers: any, args?: any): any;
+        };
+        prefix: {
+            method(str?: string): DIDSchema;
+            args: {
+                name: string;
+                ref: boolean;
+                assert: (v: any) => boolean;
+                message: string;
+                normalize: (v: any) => any;
+            }[];
+            validate(value: any, helpers: any, args?: any): any;
+        };
+    };
+};

package/esm/extension/did.js

@@ -0,0 +1,136 @@
+import isEqual from 'lodash/isEqual';
+import { types } from '@ocap/mcrypto';
+import { isValid, toTypeInfo, toTypeInfoStr, DID_PREFIX, DID_TYPE_ARCBLOCK, DID_TYPE_ETHEREUM, DID_TYPE_PASSKEY, toAddress, } from '@arcblock/did';
+const ruleTypes = {
+    pk: Object.keys(types.KeyType),
+    hash: Object.keys(types.HashType),
+    role: Object.keys(types.RoleType),
+};
+export function DIDExtension(root) {
+    return {
+        type: 'DID',
+        base: root.string().trim(),
+        messages: {
+            'did.empty': 'Expect {{#label}} to be non-empty string, got "{{#value}}"',
+            'did.invalid': 'Expect {{#label}} to be valid did, got "{{#value}}"',
+            'did.wallet': 'Expect wallet type of {{#label}} to be "{{#expected}}" wallet, got "{{#actual}}"',
+            'did.pk': 'Expect pk type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
+            'did.hash': 'Expect hash type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
+            'did.role': 'Expect role type of {{#label}} to be "{{#expected}}", got "{{#actual}}"',
+            'did.prefix': 'Expect prefix of {{#label}} to be "{{#expected}}"',
+        },
+        validate(value, helpers) {
+            if (!value || typeof value !== 'string') {
+                return { errors: helpers.error('did.empty', { value }) };
+            }
+            if (isValid(value) === false) {
+                return { errors: helpers.error('did.invalid', { value }) };
+            }
+            return { value };
+        },
+        rules: {
+            type: {
+                args: [
+                    {
+                        name: 'key',
+                        ref: true,
+                        assert: (v) => Object.keys(ruleTypes).includes(v),
+                        message: `must be one of ${Object.keys(ruleTypes).join(', ')}`,
+                    },
+                    {
+                        name: 'expected',
+                        // @ts-ignore
+                        assert: (v) => Object.keys(ruleTypes).some((x) => ruleTypes[x].includes(v)),
+                        message: 'must be valid type',
+                    },
+                ],
+                // The rule return structure is different from the root
+                // eslint-disable-next-line consistent-return
+                validate(value, helpers, args) {
+                    const typeStr = toTypeInfoStr(value);
+                    if (args.key === 'pk' && typeStr.pk !== args.expected) {
+                        return helpers.error('did.pk', { ...args, actual: typeStr.pk });
+                    }
+                    if (args.key === 'hash' && typeStr.hash !== args.expected) {
+                        return helpers.error('did.hash', { ...args, actual: typeStr.hash });
+                    }
+                    if (args.key === 'role' && typeStr.role !== args.expected) {
+                        return helpers.error('did.role', { ...args, actual: typeStr.role });
+                    }
+                    return value;
+                },
+            },
+            pk: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'pk', expected: type } });
+                },
+            },
+            hash: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'hash', expected: type } });
+                },
+            },
+            role: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'type', args: { key: 'role', expected: type } });
+                },
+            },
+            wallet: {
+                method(type) {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'wallet', args: { type } });
+                },
+                args: [
+                    {
+                        name: 'type',
+                        ref: true,
+                        assert: (v) => ['arcblock', 'ethereum', 'default', 'eth', 'passkey'].includes(v),
+                        message: 'must be a string',
+                        normalize: (v) => v.trim(),
+                    },
+                ],
+                validate(value, helpers, args = {}) {
+                    const type = toTypeInfo(value);
+                    const typeStr = toTypeInfoStr(value);
+                    if (['ethereum', 'eth'].includes(args.type) && isEqual(type, DID_TYPE_ETHEREUM) === false) {
+                        return helpers.error('did.wallet', { expected: args.type, actual: JSON.stringify(typeStr) });
+                    }
+                    if (['arcblock', 'default'].includes(args.type) && isEqual(type, DID_TYPE_ARCBLOCK) === false) {
+                        return helpers.error('did.wallet', { expected: args.type, actual: JSON.stringify(typeStr) });
+                    }
+                    if (['passkey'].includes(args.type) && isEqual(type, DID_TYPE_PASSKEY) === false) {
+                        return helpers.error('did.wallet', { expected: args.type, actual: JSON.stringify(typeStr) });
+                    }
+                    return value;
+                },
+            },
+            prefix: {
+                method(str = '') {
+                    // @ts-ignore
+                    return this.$_addRule({ name: 'prefix', args: { str } });
+                },
+                args: [
+                    {
+                        name: 'str',
+                        ref: true,
+                        assert: (v) => ['', DID_PREFIX].includes(v),
+                        message: 'must be a string',
+                        normalize: (v) => v.trim(),
+                    },
+                ],
+                validate(value, helpers, args = {}) {
+                    if (args.str && value.startsWith(args.str) === false) {
+                        return helpers.error('did.prefix', { expected: args.str });
+                    }
+                    if (!args.str && toAddress(value) !== value) {
+                        return helpers.error('did.prefix', { expected: args.str });
+                    }
+                    return value;
+                },
+            },
+        },
+    };
+}

package/esm/index.d.ts

@@ -0,0 +1,51 @@
+import BaseJoi, { Root } from 'joi';
+import { BNSchema } from './extension/bn';
+import { DIDSchema } from './extension/did';
+export interface ExtendedRoot extends Root {
+    DID(): DIDSchema;
+    BN(): BNSchema;
+}
+export declare const Joi: ExtendedRoot;
+export declare const schemas: {
+    context: BaseJoi.ObjectSchema<any>;
+    tokenInput: BaseJoi.ObjectSchema<any>;
+    multiInput: BaseJoi.ArraySchema<any[]>;
+    multiSig: BaseJoi.ArraySchema<any[]>;
+    foreignToken: BaseJoi.ObjectSchema<any>;
+    variableInput: BaseJoi.ObjectSchema<any>;
+    nftDisplay: BaseJoi.ObjectSchema<any>;
+    nftEndpoint: BaseJoi.ObjectSchema<any>;
+    nftIssuer: BaseJoi.ObjectSchema<any>;
+    tokenHolder: BaseJoi.AlternativesSchema<any>;
+    assetProps: {
+        address: DIDSchema;
+        moniker: BaseJoi.StringSchema<string>;
+        data: BaseJoi.AnySchema<any>;
+        readonly: BaseJoi.BooleanSchema<boolean>;
+        transferrable: BaseJoi.BooleanSchema<boolean>;
+        ttl: BaseJoi.NumberSchema<number>;
+        parent: DIDSchema;
+        issuer: DIDSchema;
+        endpoint: BaseJoi.ObjectSchema<any>;
+        display: BaseJoi.ObjectSchema<any>;
+        tags: BaseJoi.ArraySchema<any[]>;
+    };
+    assetSchema: BaseJoi.ObjectSchema<any>;
+    factoryProps: {
+        address: DIDSchema;
+        name: BaseJoi.StringSchema<string>;
+        description: BaseJoi.StringSchema<string>;
+        settlement: BaseJoi.StringSchema<string>;
+        limit: BaseJoi.NumberSchema<number>;
+        trustedIssuers: BaseJoi.ArraySchema<any[]>;
+        data: BaseJoi.AnySchema<any>;
+        display: BaseJoi.ObjectSchema<any>;
+        input: BaseJoi.ObjectSchema<any>;
+        output: BaseJoi.ObjectSchema<any>;
+        hooks: BaseJoi.ArraySchema<any[]>;
+    };
+    factorySchema: BaseJoi.ObjectSchema<any>;
+};
+export declare const patterns: {
+    txHash: RegExp;
+};

package/esm/index.js

@@ -0,0 +1,133 @@
+import BaseJoi from 'joi';
+import { BNExtension } from './extension/bn';
+import { DIDExtension } from './extension/did';
+export const Joi = BaseJoi.extend(DIDExtension).extend(BNExtension);
+const txHash = /^(0x)?([A-Fa-f0-9]{64})$/;
+const context = Joi.object({
+    genesisTime: Joi.date().iso().required().raw(),
+    genesisTx: Joi.string().regex(txHash).required().allow(''),
+    renaissanceTime: Joi.date().iso().required().raw(),
+    renaissanceTx: Joi.string().regex(txHash).required().allow(''),
+});
+const tokenInput = Joi.object({
+    address: Joi.DID().prefix().role('ROLE_TOKEN').required(),
+    value: Joi.BN().positive().required(),
+});
+const variableInput = Joi.object({
+    name: Joi.string().min(1).max(256).required(),
+    value: Joi.string().min(1).max(1024).required(),
+    description: Joi.string().min(1).max(256).optional().allow(''),
+    required: Joi.boolean().optional().default(false),
+});
+const tokenHolder = Joi.alternatives().try(Joi.DID().prefix().role('ROLE_ACCOUNT'), Joi.DID().prefix().role('ROLE_APPLICATION'), Joi.DID().prefix().role('ROLE_BLOCKLET'), Joi.DID().prefix().wallet('ethereum'), Joi.DID().prefix().wallet('passkey'));
+const multiInput = Joi.array().items(Joi.object({
+    owner: tokenHolder.required(),
+    tokensList: Joi.array().items(tokenInput).default([]),
+    assetsList: Joi.array().items(Joi.DID().prefix().role('ROLE_ASSET')).default([]),
+}));
+const multiSig = Joi.array().items({
+    signer: Joi.DID().prefix().required(),
+    pk: Joi.any().required(),
+    signature: Joi.any().required(),
+    delegator: Joi.DID().prefix().valid('').optional(),
+    data: Joi.any().optional(),
+});
+const foreignToken = Joi.object({
+    type: Joi.string().min(1).max(32).required(),
+    contractAddress: Joi.DID().prefix().wallet('ethereum').required(),
+    chainType: Joi.string().min(1).max(32).required(),
+    chainName: Joi.string().min(1).max(32).required(),
+    chainId: Joi.number().positive().required(),
+});
+const nftDisplay = Joi.object({
+    type: Joi.string().valid('svg', 'url', 'uri').required(),
+    content: Joi.string()
+        .when('type', { is: 'uri', then: Joi.string().max(20480).dataUri().required() }) // 20kb
+        .when('type', { is: 'url', then: Joi.string().max(2048).uri({ scheme: ['http', 'https'] }).required() }), // prettier-ignore
+});
+const nftEndpoint = Joi.object({
+    id: Joi.string().max(2048).uri({ scheme: ['http', 'https'] }).required(), // prettier-ignore
+    scope: Joi.string().valid('public', 'private').default('public'),
+});
+const nftIssuer = Joi.object({
+    id: Joi.DID().prefix().required(),
+    pk: Joi.string().required(),
+    name: Joi.string().min(1).max(256).required(),
+});
+const assetProps = {
+    address: Joi.DID().prefix().role('ROLE_ASSET').required(),
+    moniker: Joi.string().min(2).max(255).required(),
+    data: Joi.any().required(),
+    readonly: Joi.boolean().default(false),
+    transferrable: Joi.boolean().default(false),
+    ttl: Joi.number().min(0).default(0),
+    parent: Joi.DID().prefix().optional().allow(''),
+    issuer: Joi.DID().prefix().optional().allow(''),
+    endpoint: nftEndpoint.optional().allow(null).default(null),
+    display: nftDisplay.optional().allow(null).default(null),
+    tags: Joi.array().items(Joi.string().min(1).max(64)).max(4).optional(),
+};
+const factoryProps = {
+    address: Joi.DID().prefix().role('ROLE_FACTORY').required(),
+    name: Joi.string().min(2).max(255).required(),
+    description: Joi.string().min(2).max(255).required(),
+    settlement: Joi.string().valid('instant', 'periodic').default('instant'),
+    limit: Joi.number().integer().min(0).default(0),
+    trustedIssuers: Joi.array().items(Joi.DID().prefix()).max(8).optional(),
+    data: Joi.any().optional().allow(null).default(null),
+    display: nftDisplay.optional().allow(null).default(null),
+    input: Joi.object({
+        value: Joi.BN().positive().min('0').default('0'),
+        tokens: Joi.array().items(tokenInput).max(8).optional(),
+        assets: Joi.array()
+            .items(Joi.alternatives().try(Joi.DID().prefix().role('ROLE_ASSET'), Joi.DID().prefix().role('ROLE_FACTORY')))
+            .max(8)
+            .optional(),
+        variables: Joi.array()
+            .items(Joi.object({
+            name: Joi.string().min(1).max(255).required(),
+            description: Joi.string().max(255).optional().allow(''),
+            required: Joi.boolean().required(),
+        }))
+            .optional(),
+    }),
+    output: Joi.object({
+        moniker: Joi.string().min(2).max(255).required(),
+        data: Joi.any().required(),
+        readonly: Joi.boolean().default(false),
+        transferrable: Joi.boolean().default(false),
+        ttl: Joi.number().min(0).default(0),
+        parent: Joi.string().max(255).required(), // should be template
+        issuer: Joi.string().max(255).required(), // should be template
+        endpoint: nftEndpoint.optional(),
+        display: nftDisplay.optional(),
+        tags: Joi.array().items(Joi.string().min(1).max(64)).max(4).optional(),
+    }),
+    hooks: Joi.array()
+        .items(Joi.object({
+        name: Joi.string().valid('mint', 'postMint', 'preMint').required(),
+        type: Joi.string().valid('url', 'contract').required(),
+        hook: Joi.string().min(1).max(4096).required(), // due to amazon qldb limit, 32 transfers
+        compiled: Joi.array().items(Joi.object()).optional(),
+    }))
+        .optional(),
+};
+export const schemas = {
+    context,
+    tokenInput,
+    multiInput,
+    multiSig,
+    foreignToken,
+    variableInput,
+    nftDisplay,
+    nftEndpoint,
+    nftIssuer,
+    tokenHolder,
+    assetProps,
+    assetSchema: Joi.object(assetProps).options({ stripUnknown: true, noDefaults: false }),
+    factoryProps,
+    factorySchema: Joi.object(factoryProps).options({ stripUnknown: true, noDefaults: false }),
+};
+export const patterns = {
+    txHash,
+};

package/lib/extension/bn.d.ts

@@ -42,12 +42,12 @@ export declare function BNExtension(root: Root): {
             args: ({
                 name: string;
                 ref: boolean;
-                assert: (v: any) => boolean;
+                assert: (v: any) => v is BN;
                 message: string;
                 normalize: (v: any) => BN;
             } | {
                 name: string;
-                assert: (v: any) => boolean;
+                assert: (v: any) => v is boolean;
                 message: string;
                 ref?: undefined;
                 normalize?: undefined;
@@ -58,12 +58,12 @@ export declare function BNExtension(root: Root): {
             args: ({
                 name: string;
                 ref: boolean;
-                assert: (v: any) => boolean;
+                assert: (v: any) => v is BN;
                 message: string;
                 normalize: (v: any) => BN;
             } | {
                 name: string;
-                assert: (v: any) => boolean;
+                assert: (v: any) => v is boolean;
                 message: string;
                 ref?: undefined;
                 normalize?: undefined;

package/lib/extension/bn.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BNExtension = void 0;
+exports.BNExtension = BNExtension;
 const bn_js_1 = __importDefault(require("bn.js"));
 function BNExtension(root) {
     return {
@@ -134,4 +134,3 @@ function BNExtension(root) {
         },
     };
 }
-exports.BNExtension = BNExtension;

package/lib/extension/did.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DIDExtension = void 0;
+exports.DIDExtension = DIDExtension;
 const isEqual_1 = __importDefault(require("lodash/isEqual"));
 const mcrypto_1 = require("@ocap/mcrypto");
 const did_1 = require("@arcblock/did");
@@ -93,7 +93,7 @@ function DIDExtension(root) {
                     {
                         name: 'type',
                         ref: true,
-                        assert: (v) => ['arcblock', 'ethereum', 'default', 'eth'].includes(v),
+                        assert: (v) => ['arcblock', 'ethereum', 'default', 'eth', 'passkey'].includes(v),
                         message: 'must be a string',
                         normalize: (v) => v.trim(),
                     },
@@ -107,6 +107,9 @@ function DIDExtension(root) {
                     if (['arcblock', 'default'].includes(args.type) && (0, isEqual_1.default)(type, did_1.DID_TYPE_ARCBLOCK) === false) {
                         return helpers.error('did.wallet', { expected: args.type, actual: JSON.stringify(typeStr) });
                     }
+                    if (['passkey'].includes(args.type) && (0, isEqual_1.default)(type, did_1.DID_TYPE_PASSKEY) === false) {
+                        return helpers.error('did.wallet', { expected: args.type, actual: JSON.stringify(typeStr) });
+                    }
                     return value;
                 },
             },
@@ -137,4 +140,3 @@ function DIDExtension(root) {
         },
     };
 }
-exports.DIDExtension = DIDExtension;

package/lib/index.js

@@ -25,7 +25,7 @@ const variableInput = exports.Joi.object({
     description: exports.Joi.string().min(1).max(256).optional().allow(''),
     required: exports.Joi.boolean().optional().default(false),
 });
-const tokenHolder = exports.Joi.alternatives().try(exports.Joi.DID().prefix().role('ROLE_ACCOUNT'), exports.Joi.DID().prefix().role('ROLE_APPLICATION'), exports.Joi.DID().prefix().role('ROLE_BLOCKLET'), exports.Joi.DID().prefix().wallet('ethereum'));
+const tokenHolder = exports.Joi.alternatives().try(exports.Joi.DID().prefix().role('ROLE_ACCOUNT'), exports.Joi.DID().prefix().role('ROLE_APPLICATION'), exports.Joi.DID().prefix().role('ROLE_BLOCKLET'), exports.Joi.DID().prefix().wallet('ethereum'), exports.Joi.DID().prefix().wallet('passkey'));
 const multiInput = exports.Joi.array().items(exports.Joi.object({
     owner: tokenHolder.required(),
     tokensList: exports.Joi.array().items(tokenInput).default([]),
@@ -52,7 +52,7 @@ const nftDisplay = exports.Joi.object({
         .when('type', { is: 'url', then: exports.Joi.string().max(2048).uri({ scheme: ['http', 'https'] }).required() }), // prettier-ignore
 });
 const nftEndpoint = exports.Joi.object({
-    id: exports.Joi.string().max(2048).uri({ scheme: ['http', 'https'] }).required(),
+    id: exports.Joi.string().max(2048).uri({ scheme: ['http', 'https'] }).required(), // prettier-ignore
     scope: exports.Joi.string().valid('public', 'private').default('public'),
 });
 const nftIssuer = exports.Joi.object({
@@ -103,8 +103,8 @@ const factoryProps = {
         readonly: exports.Joi.boolean().default(false),
         transferrable: exports.Joi.boolean().default(false),
         ttl: exports.Joi.number().min(0).default(0),
-        parent: exports.Joi.string().max(255).required(),
-        issuer: exports.Joi.string().max(255).required(),
+        parent: exports.Joi.string().max(255).required(), // should be template
+        issuer: exports.Joi.string().max(255).required(), // should be template
         endpoint: nftEndpoint.optional(),
         display: nftDisplay.optional(),
         tags: exports.Joi.array().items(exports.Joi.string().min(1).max(64)).max(4).optional(),
@@ -113,7 +113,7 @@ const factoryProps = {
         .items(exports.Joi.object({
         name: exports.Joi.string().valid('mint', 'postMint', 'preMint').required(),
         type: exports.Joi.string().valid('url', 'contract').required(),
-        hook: exports.Joi.string().min(1).max(4096).required(),
+        hook: exports.Joi.string().min(1).max(4096).required(), // due to amazon qldb limit, 32 transfers
         compiled: exports.Joi.array().items(exports.Joi.object()).optional(),
     }))
         .optional(),

package/package.json

@@ -3,27 +3,38 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "1.18.166",
+  "version": "1.19.0",
   "description": "",
-  "main": "lib/index.js",
-  "typings": "lib/index.d.ts",
+  "main": "./lib/index.js",
+  "module": "./lib/index.js",
+  "types": "./esm/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./esm/index.js",
+      "require": "./lib/index.js",
+      "default": "./esm/index.js"
+    }
+  },
   "files": [
-    "lib"
+    "lib",
+    "esm"
   ],
   "scripts": {
     "lint": "eslint tests src",
     "lint:fix": "eslint --fix tests src",
     "test": "jest --forceExit --detectOpenHandles",
     "coverage": "npm run test -- --coverage",
-    "clean": "rm -fr lib",
+    "clean": "rm -fr lib esm",
     "prebuild": "npm run clean",
     "build:watch": "npm run build -- -w",
-    "build": "tsc"
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build": "npm run build:cjs && npm run build:esm"
   },
   "dependencies": {
-    "@arcblock/did": "1.18.166",
-    "@ocap/mcrypto": "1.18.166",
-    "@ocap/util": "1.18.166",
+    "@arcblock/did": "1.19.0",
+    "@ocap/mcrypto": "1.19.0",
+    "@ocap/util": "1.19.0",
     "bn.js": "5.2.1",
     "joi": "^17.7.0",
     "lodash": "^4.17.21"
@@ -32,15 +43,15 @@
     "bn.js": "5.2.1"
   },
   "devDependencies": {
-    "@arcblock/eslint-config-ts": "0.2.3",
-    "eslint": "^8.25.0",
+    "@arcblock/eslint-config-ts": "0.3.3",
+    "eslint": "^8.57.0",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "type-fest": "^3.1.0",
-    "typescript": "^4.8.4"
+    "typescript": "^5.6.2"
   },
   "keywords": [],
   "author": "wangshijun <wangshijun2010@gmail.com> (http://github.com/wangshijun)",
   "license": "MIT",
-  "gitHead": "58c8356b3b8c238728560e4c3fef6ed1704d3ac4"
+  "gitHead": "1b6fac03988fb18507c8ef4c21de282762005f87"
 }