@koralabs/kora-labs-common 2.6.0 → 3.0.0

package/lib/handles/interfaces.d.ts

@@ -197,12 +197,14 @@ export interface IPzDatum {
         [key: string]: string;
     };
 }
+export interface ISubHandleSettingsCreatorDefaults extends ICreatorDefaults {
+    bg_image: string;
+}
 export interface ISubHandleSettings {
     enabled?: BoolInt;
     tierPricing?: [number, number][];
     enablePz?: BoolInt;
-    creatorDefaults?: ICreatorDefaults;
-    creatorDefaultsBgImage?: string;
+    creatorDefaults?: ISubHandleSettingsCreatorDefaults;
 }
 export interface IVirtualSubHandleSettings extends ISubHandleSettings {
     expires_in_days?: number;

package/lib/utils/cbor/index.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" />
+export declare enum KeyType {
+    UTF8 = "utf8",
+    HEX = "hex"
+}
+declare class JsonToDatumObject {
+    json: any;
+    numericKeys: boolean;
+    constructor(json: any, numericKeys?: boolean);
+    getFormattedKey: (key: string) => number | Buffer;
+    getHexOrString: (key: string) => Buffer;
+    encodeCBOR: (encoder: any) => any;
+    keyIsNumeric: (key: any) => boolean;
+}
+export declare class DupeKey extends JsonToDatumObject {
+    key: string;
+    constructor(key: string);
+}
+export declare const encodeJsonToDatum: (json: any, numericKeys?: boolean) => Promise<string>;
+export declare const decodeCborToJson: ({ cborString, schema, defaultKeyType, forJson }: {
+    cborString: string;
+    schema?: any;
+    defaultKeyType?: KeyType | undefined;
+    forJson?: boolean | undefined;
+}) => Promise<any>;
+export {};

package/lib/utils/cbor/index.js

@@ -0,0 +1,335 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.decodeCborToJson = exports.encodeJsonToDatum = exports.DupeKey = exports.KeyType = void 0;
+const cbor = __importStar(require("cbor"));
+const boolean_1 = require("boolean");
+// The five ways to represent metadata/datum:
+// Json (cardano-cli can take this with --tx-out-datum-json-value)
+// TxMetadataJson ("Detailed Schema")
+// TxMetadataCbor
+// PlutusDataJson ("Schema Json")
+// PlutusDataCbor
+// Constructor vs Not
+// Sort of similar to:
+// const instance = new CustomObject(<json>)
+// vs
+// const obj = JSON.parse(<json>)
+var KeyType;
+(function (KeyType) {
+    KeyType["UTF8"] = "utf8";
+    KeyType["HEX"] = "hex";
+})(KeyType = exports.KeyType || (exports.KeyType = {}));
+class JsonToDatumObject {
+    constructor(json, numericKeys = false) {
+        this.getFormattedKey = (key) => {
+            if (key.startsWith('0x')) {
+                return Buffer.from(key.substring(2), 'hex');
+            }
+            if (this.keyIsNumeric(key)) {
+                return parseInt(key);
+            }
+            if (key.startsWith('~0x')) {
+                key = key.slice(1);
+            }
+            return Buffer.from(key);
+        };
+        this.getHexOrString = (key) => {
+            if (key.startsWith('0x')) {
+                return Buffer.from(key.substring(2), 'hex');
+            }
+            if (key.startsWith('~0x')) {
+                key = key.slice(1);
+            }
+            return Buffer.from(key);
+        };
+        this.encodeCBOR = (encoder) => {
+            var _a;
+            if (Array.isArray(this.json)) {
+                return cbor.Encoder.encodeIndefinite(encoder, this.json);
+            }
+            else if (typeof this.json === 'object') {
+                if (this.json !== null) {
+                    const fieldsMap = new Map();
+                    let tag = null;
+                    const keys = this.json instanceof Map ? this.json.keys() : Object.keys(this.json);
+                    for (let key of keys) {
+                        if (key instanceof DupeKey) {
+                            fieldsMap.set(key, this.json.get(key));
+                        }
+                        else {
+                            let split_key = parseInt((_a = key.split('_').at(1)) !== null && _a !== void 0 ? _a : '');
+                            if (key.startsWith('constructor_') &&
+                                !isNaN(split_key) &&
+                                [0, 1, 2, 3].includes(split_key)) {
+                                tag = 121 + split_key;
+                                return encoder.pushAny(new cbor.Tagged(tag, this.json[key]));
+                            }
+                            const bufferedKey = this.getFormattedKey(key);
+                            fieldsMap.set(bufferedKey, this.json[key]);
+                        }
+                    }
+                    return encoder.pushAny(fieldsMap);
+                }
+                else {
+                    return encoder.pushAny(Buffer.from('null'));
+                }
+            }
+            else if (Number.isInteger(this.json)) {
+                return encoder.pushAny(this.json);
+            }
+            else if (typeof this.json === 'string') {
+                // check for hex and if so, decode it
+                const bufferedString = this.getHexOrString(this.json);
+                return bufferedString.length > 64
+                    ? cbor.Encoder.encodeIndefinite(encoder, bufferedString, { chunkSize: 64 })
+                    : encoder.pushAny(bufferedString);
+            }
+            else if (typeof this.json === 'boolean') {
+                return encoder.pushAny(this.json ? 1 : 0);
+            }
+            else {
+                // anything else: convert to simple type - String.
+                // e.g. undefined, true, false, NaN, Infinity.
+                // Some of these can't be represented in JSON anyway.
+                // Floating point numbers: note there can be loss of precision when
+                // representing floats as decimal numbers
+                return encoder.pushAny(Buffer.from('' + this.json));
+            }
+        };
+        this.keyIsNumeric = (key) => {
+            return this.numericKeys && key !== null && key.length > 0 && !isNaN(key);
+        };
+        this.json = json;
+        this.numericKeys = numericKeys;
+        if (Array.isArray(this.json)) {
+            for (let i = 0; i < this.json.length; i++) {
+                this.json[i] = new JsonToDatumObject(this.json[i], numericKeys);
+            }
+        }
+        else if (typeof this.json === 'object') {
+            if (this.json !== null) {
+                Object.keys(this.json).map((key) => {
+                    this.json[key] = new JsonToDatumObject(this.json[key], numericKeys);
+                });
+            }
+        }
+    }
+}
+class DupeKey extends JsonToDatumObject {
+    constructor(key) {
+        super(key);
+        this.key = key;
+    }
+}
+exports.DupeKey = DupeKey;
+const encodeJsonToDatum = (json, numericKeys = false) => __awaiter(void 0, void 0, void 0, function* () {
+    const obj = new JsonToDatumObject(json, numericKeys);
+    const result = yield cbor.encodeAsync(obj, { chunkSize: 64 });
+    return result.toString('hex');
+});
+exports.encodeJsonToDatum = encodeJsonToDatum;
+const parseSchema = (key, schema, defaultKeyType, i) => {
+    let schemaValue;
+    if (Number.isInteger(key)) {
+        key = `${key}`;
+    }
+    let mapKey = Buffer.from(key).toString('utf8');
+    const hexKey = `0x${Buffer.from(key).toString('hex')}`;
+    // check schema to see if it matches
+    // key name match
+    let schemaKey = Object.keys(schema).find((k) => k === mapKey);
+    if (!schemaKey) {
+        schemaKey = Object.keys(schema).find((k) => k.replace('0x', '') === mapKey);
+        if (schemaKey || defaultKeyType == KeyType.HEX) {
+            mapKey = hexKey;
+        }
+    }
+    // index match
+    if (!schemaKey) {
+        schemaKey = Object.keys(schema).find((k) => k === `[${i}]`);
+    }
+    // dynamic match
+    if (!schemaKey) {
+        schemaKey = Object.keys(schema).find((k) => k.startsWith('<') && k.endsWith('>'));
+        if (schemaKey === '<hexstring>' || defaultKeyType == KeyType.HEX) {
+            mapKey = hexKey;
+        }
+    }
+    if (schemaKey) {
+        schemaValue = schema[schemaKey];
+    }
+    return {
+        mapKey,
+        schemaValue
+    };
+};
+const decodeObject = ({ val, constr = null, schema = {}, defaultKeyType = KeyType.UTF8, forJson = true }) => {
+    const isMap = val instanceof Map;
+    if (isMap) {
+        const obj = new Map();
+        let dupeKeys = false;
+        const keys = [...val.keys()];
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            let value = val.get(key);
+            const { mapKey, schemaValue } = parseSchema(key, schema, defaultKeyType, i);
+            if (obj.get(mapKey)) {
+                dupeKeys = true;
+                let newKey = `dupekey_str_${mapKey}_1`;
+                const currentKeyIndex = [...obj.keys()].filter((k) => (typeof k === 'string' && k.startsWith(`dupekey_str_${mapKey}`)) || k === mapKey).length - 1;
+                let oldKey = `dupekey_str_${mapKey}_${currentKeyIndex}`;
+                if (!forJson) {
+                    newKey = new DupeKey(mapKey);
+                    oldKey = new DupeKey(mapKey);
+                }
+                const prevValue = obj.get(mapKey);
+                obj.delete(mapKey);
+                obj.set(oldKey, prevValue);
+                obj.set(newKey, decodeObject({ val: value, constr, schema: schemaValue, defaultKeyType, forJson }));
+            }
+            else {
+                obj.set(mapKey, decodeObject({ val: value, constr, schema: schemaValue, defaultKeyType, forJson }));
+            }
+        }
+        if (dupeKeys) {
+            // convert keys that didnt get converted
+            if (forJson) {
+                [...obj.keys()].forEach((key) => {
+                    if (!key.startsWith('dupekey')) {
+                        const prevValue = obj.get(key);
+                        obj.delete(key);
+                        obj.set(`dupekey_str_${key}_0`, prevValue);
+                    }
+                });
+            }
+            else {
+                // if key is a string, replace with dedupe class
+                [...obj.keys()].forEach((key) => {
+                    if (!(key instanceof DupeKey)) {
+                        const prevValue = obj.get(key);
+                        obj.delete(key);
+                        obj.set(new DupeKey(key), prevValue);
+                    }
+                });
+            }
+        }
+        const finalObj = dupeKeys && !forJson ? obj : Object.fromEntries(obj);
+        if (constr != null) {
+            return { [`constructor_${constr}`]: finalObj };
+        }
+        else {
+            return finalObj;
+        }
+    }
+    else if (typeof val === 'object' && val.constructor === Object) {
+        const obj = {};
+        const keys = Object.keys(val);
+        for (let i = 0; i < keys.length; i++) {
+            const key = keys[i];
+            let value = val[key];
+            const { mapKey, schemaValue } = parseSchema(key, schema, defaultKeyType, i);
+            obj[mapKey] = decodeObject({ val: value, schema: schemaValue, defaultKeyType, forJson });
+        }
+        if (constr != null) {
+            return { [`constructor_${constr}`]: obj };
+        }
+        else {
+            return obj;
+        }
+    }
+    else if (Array.isArray(val)) {
+        const arr = [];
+        if (constr !== null && Object.keys(schema).some((k) => k === `constructor_${constr}`)) {
+            schema = schema[`constructor_${constr}`];
+        }
+        for (let i = 0; i < val.length; i++) {
+            const arrayVal = val[i];
+            let schemaValue;
+            let schemaKey;
+            // index match
+            if (!schemaKey) {
+                schemaKey = Object.keys(schema).find((k) => k === `[${i}]`);
+            }
+            // dynamic match
+            if (!schemaKey) {
+                schemaKey = Object.keys(schema).find((k) => k === '[all]');
+            }
+            if (schemaKey) {
+                schemaValue = schema[schemaKey];
+            }
+            arr.push(decodeObject({ val: arrayVal, schema: schemaValue, defaultKeyType, forJson }));
+        }
+        if (constr != null) {
+            return { [`constructor_${constr}`]: arr };
+        }
+        else {
+            return arr;
+        }
+    }
+    else if (Buffer.isBuffer(val)) {
+        if (schema === 'string' || schema === 'bool') {
+            const result = Buffer.from(val).toString('utf8');
+            if (schema === 'bool' && (0, boolean_1.isBooleanable)(result)) {
+                return (0, boolean_1.boolean)(result);
+            }
+            // Figure out if we want to add the ~ to the front of the hex string
+            // if (result.startsWith('0x')) {
+            //     return `~${result}`;
+            // }
+            return result;
+        }
+        return `0x${Buffer.from(val).toString('hex')}`;
+    }
+    else {
+        if (schema === 'bool' && (0, boolean_1.isBooleanable)(val)) {
+            return (0, boolean_1.boolean)(val);
+        }
+        return val;
+    }
+};
+const decodeCborToJson = ({ cborString, schema, defaultKeyType, forJson }) => __awaiter(void 0, void 0, void 0, function* () {
+    const decoded = yield cbor.decodeAll(Buffer.from(cborString, 'hex'), {
+        tags: {
+            121: (val) => ({ [`constructor_0`]: val }),
+            122: (val) => ({ [`constructor_1`]: val }),
+            123: (val) => ({ [`constructor_2`]: val }),
+            124: (val) => ({ [`constructor_3`]: val })
+        }
+    });
+    let [data] = decoded;
+    data = decodeObject({ val: data, schema, defaultKeyType, forJson });
+    return data;
+});
+exports.decodeCborToJson = decodeCborToJson;

package/lib/utils/cbor/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils/cbor/index.test.js

@@ -0,0 +1,532 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (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());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("./index");
+const handleData_1 = require("./schema/handleData");
+const designer_1 = require("./schema/designer");
+const portal_1 = require("./schema/portal");
+describe('CBOR tests', () => {
+    describe('Encode/decode Handle JSON and PlutusDataCbor', () => {
+        const plutusDataJson = {
+            constructor_0: [
+                {
+                    name: 'xar12345',
+                    image: 'ipfs://image_cid',
+                    mediaType: 'image/jpeg',
+                    og: true,
+                    og_number: 0,
+                    rarity: 'basic',
+                    length: 8,
+                    characters: 'characters,numbers',
+                    numeric_modifiers: '',
+                    version: 1
+                },
+                1,
+                {
+                    standard_image: 'ipfs://cid',
+                    bg_image: 'ipfs://cid',
+                    pfp_image: 'ipfs://cid',
+                    pfp_asset: '0x4da965a049dfd15ed1ee19fba6e2974a0b79fc416dd1796a1f97f5e1',
+                    bg_asset: '0x4da965a049dfd15ed1ee19fba6e2974a0b79fc416dd1796a1f97f5e1',
+                    portal: 'ipfs://cid',
+                    designer: 'ipfs://cid',
+                    socials: 'ipfs://cid',
+                    vendor: 'ipfs://cid',
+                    default: false,
+                    last_update_address: '0x00f749548d2cd66bb9adc5c508de3c9ff938d19f59e93aa623eb356c022b61a21becbc6b3199bab4f0f5eaabafcc50eb87ecf5cc843465d625',
+                    validated_by: '0x4da965a049dfd15ed1ee19fba6e2974a0b79fc416dd1796a1f97f5e1',
+                    trial: true
+                }
+            ]
+        };
+        const expectedCbor = 'd8799faa446e616d6548786172313233343545696d61676550697066733a2f2f696d6167655f636964496d65646961547970654a696d6167652f6a706567426f6701496f675f6e756d6265720046726172697479456261736963466c656e677468084a6368617261637465727352636861726163746572732c6e756d62657273516e756d657269635f6d6f64696669657273404776657273696f6e0101ad4e7374616e646172645f696d6167654a697066733a2f2f6369644862675f696d6167654a697066733a2f2f636964497066705f696d6167654a697066733a2f2f636964497066705f6173736574581c4da965a049dfd15ed1ee19fba6e2974a0b79fc416dd1796a1f97f5e14862675f6173736574581c4da965a049dfd15ed1ee19fba6e2974a0b79fc416dd1796a1f97f5e146706f7274616c4a697066733a2f2f6369644864657369676e65724a697066733a2f2f63696447736f6369616c734a697066733a2f2f6369644676656e646f724a697066733a2f2f6369644764656661756c7400536c6173745f7570646174655f61646472657373583900f749548d2cd66bb9adc5c508de3c9ff938d19f59e93aa623eb356c022b61a21becbc6b3199bab4f0f5eaabafcc50eb87ecf5cc843465d6254c76616c6964617465645f6279581c4da965a049dfd15ed1ee19fba6e2974a0b79fc416dd1796a1f97f5e145747269616c01ff';
+        it('Should convert from JSON to PlutusDataCbor', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)(plutusDataJson);
+            expect(encoded).toEqual(expectedCbor);
+        }));
+        it('Should convert from PlutusDataCbor to JSON', () => __awaiter(void 0, void 0, void 0, function* () {
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: expectedCbor, schema: handleData_1.handleDatumSchema });
+            expect(decoded).toEqual({
+                constructor_0: [
+                    {
+                        characters: 'characters,numbers',
+                        image: 'ipfs://image_cid',
+                        length: 8,
+                        mediaType: 'image/jpeg',
+                        name: 'xar12345',
+                        numeric_modifiers: '',
+                        og: true,
+                        og_number: 0,
+                        rarity: 'basic',
+                        version: 1
+                    },
+                    1,
+                    {
+                        bg_asset: '0x4da965a049dfd15ed1ee19fba6e2974a0b79fc416dd1796a1f97f5e1',
+                        bg_image: 'ipfs://cid',
+                        default: false,
+                        designer: 'ipfs://cid',
+                        last_update_address: '0x00f749548d2cd66bb9adc5c508de3c9ff938d19f59e93aa623eb356c022b61a21becbc6b3199bab4f0f5eaabafcc50eb87ecf5cc843465d625',
+                        pfp_asset: '0x4da965a049dfd15ed1ee19fba6e2974a0b79fc416dd1796a1f97f5e1',
+                        pfp_image: 'ipfs://cid',
+                        portal: 'ipfs://cid',
+                        socials: 'ipfs://cid',
+                        standard_image: 'ipfs://cid',
+                        trial: true,
+                        validated_by: '0x4da965a049dfd15ed1ee19fba6e2974a0b79fc416dd1796a1f97f5e1',
+                        vendor: 'ipfs://cid'
+                    }
+                ]
+            });
+        }));
+    });
+    describe('Encode/decode designer datum', () => {
+        const getJson = () => ({
+            font_shadow_color: '0x000000',
+            bg_color: '0x0a1fd3',
+            bg_border_color: '0x0a1fd3',
+            qr_link: 'https://handle.me/burrito',
+            socials: [{ display: 'taco', url: 'https://handle.me/taco' }],
+            pfp_border_color: '0x0a1fd3',
+            qr_inner_eye: 'rounded,#0a1fd3',
+            qr_outer_eye: 'square,#0a1fd3',
+            qr_dot: 'dot,#0a1fd3',
+            qr_bg_color: '0x22d1af',
+            pfp_zoom: 20,
+            pfp_offset: [124, 58],
+            font: 'Family Name,https://fonts.com/super_cool_font.woff',
+            font_color: '0x0a1fd3',
+            font_shadow_size: [12, 12, 8],
+            text_ribbon_colors: ['0x0a1fd3', '0x22d1af', '0x31bc23'],
+            text_ribbon_gradient: 'linear-45'
+        });
+        const cbor = 'b151666f6e745f736861646f775f636f6c6f72430000004862675f636f6c6f72430a1fd34f62675f626f726465725f636f6c6f72430a1fd34771725f6c696e6b581968747470733a2f2f68616e646c652e6d652f6275727269746f47736f6369616c739fa247646973706c6179447461636f4375726c5668747470733a2f2f68616e646c652e6d652f7461636fff507066705f626f726465725f636f6c6f72430a1fd34c71725f696e6e65725f6579654f726f756e6465642c233061316664334c71725f6f757465725f6579654e7371756172652c233061316664334671725f646f744b646f742c233061316664334b71725f62675f636f6c6f724322d1af487066705f7a6f6f6d144a7066705f6f66667365749f187c183aff44666f6e74583246616d696c79204e616d652c68747470733a2f2f666f6e74732e636f6d2f73757065725f636f6f6c5f666f6e742e776f66664a666f6e745f636f6c6f72430a1fd350666f6e745f736861646f775f73697a659f0c0c08ff52746578745f726962626f6e5f636f6c6f72739f430a1fd34322d1af4331bc23ff54746578745f726962626f6e5f6772616469656e74496c696e6561722d3435';
+        it('Should convert designer datum to cbor', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)(getJson());
+            expect(encoded).toEqual(cbor);
+        }));
+        it('Should convert cbor to designer datum', () => __awaiter(void 0, void 0, void 0, function* () {
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor, schema: designer_1.designerSchema });
+            expect(decoded).toEqual(getJson());
+        }));
+    });
+    describe('Encode/decode portal datum', () => {
+        const getJson = () => ({
+            type: 'redirect',
+            domain: 'https://handle.me',
+            default: true
+        });
+        const cbor = 'a3447479706548726564697265637446646f6d61696e5168747470733a2f2f68616e646c652e6d654764656661756c7401';
+        it('Should convert portal datum to cbor', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)(getJson());
+            expect(encoded).toEqual(cbor);
+        }));
+        it('Should convert cbor to portal datum', () => __awaiter(void 0, void 0, void 0, function* () {
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor, schema: portal_1.portalSchema });
+            expect(decoded).toEqual(getJson());
+        }));
+    });
+    describe('Encode/decode Standard JSON and PlutusDataCbor', () => {
+        const json = {
+            firstKey: 'string',
+            secondKey: {
+                firstList: [1, 3],
+                '0x222222': [{ thirdKey: '222222' }, { fourthKey: '0x333333' }, { fifthKey: 0 }]
+            }
+        };
+        const cbor = 'a24866697273744b657946737472696e67497365636f6e644b6579a24966697273744c6973749f0103ff432222229fa14874686972644b657946323232323232a149666f757274684b657943333333a14866696674684b657900ff';
+        it('Should convert from JSON to TxMetadataJson', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)(json);
+            expect(encoded).toEqual(cbor);
+        }));
+        it('Should decode from TxMetadataJson to JSON', () => __awaiter(void 0, void 0, void 0, function* () {
+            const schema = {
+                firstKey: 'string',
+                secondKey: {
+                    firstList: {
+                        '[0]': 'bool'
+                    },
+                    '<hexstring>': {
+                        '[0]': {
+                            thirdKey: 'string'
+                        },
+                        '[2]': {
+                            fifthKey: 'number'
+                        }
+                    }
+                }
+            };
+            const expectedJson = {
+                firstKey: 'string',
+                secondKey: {
+                    firstList: [true, 3],
+                    '0x222222': [{ thirdKey: '222222' }, { fourthKey: '0x333333' }, { fifthKey: 0 }]
+                }
+            };
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor, schema });
+            expect(decoded).toEqual(expectedJson);
+        }));
+    });
+    describe('Encode/decode personalization settings', () => {
+        const pzSettings = [
+            1500000,
+            '0x300b1c7993d1e2f33007ca24a00c977d9b187d57e77e0b8fc6b344b8',
+            3500000,
+            ['0x300b1c7993d1e2f33007ca24a00c977d9b187d57e77e0b8fc6b344b8'],
+            ['0x3ac54dace81eb69b2c974a1db2b89f2529fbf4da97c482decb32b6a5'],
+            ['0x151a82d0669a20bd77de1296eee5ef1259ce98ecd81bd7121825f9eb'],
+            '0x300b1c7993d1e2f33007ca24a00c977d9b187d57e77e0b8fc6b344b8'
+        ];
+        const pzCbor = '9f1a0016e360581c300b1c7993d1e2f33007ca24a00c977d9b187d57e77e0b8fc6b344b81a003567e09f581c300b1c7993d1e2f33007ca24a00c977d9b187d57e77e0b8fc6b344b8ff9f581c3ac54dace81eb69b2c974a1db2b89f2529fbf4da97c482decb32b6a5ff9f581c151a82d0669a20bd77de1296eee5ef1259ce98ecd81bd7121825f9ebff581c300b1c7993d1e2f33007ca24a00c977d9b187d57e77e0b8fc6b344b8ff';
+        it('Should encode personalization settings', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)(pzSettings);
+            expect(encoded).toEqual(pzCbor);
+        }));
+        it('Should decode personalization settings', () => __awaiter(void 0, void 0, void 0, function* () {
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: pzCbor });
+            expect(decoded).toEqual([
+                1500000,
+                '0x300b1c7993d1e2f33007ca24a00c977d9b187d57e77e0b8fc6b344b8',
+                3500000,
+                ['0x300b1c7993d1e2f33007ca24a00c977d9b187d57e77e0b8fc6b344b8'],
+                ['0x3ac54dace81eb69b2c974a1db2b89f2529fbf4da97c482decb32b6a5'],
+                ['0x151a82d0669a20bd77de1296eee5ef1259ce98ecd81bd7121825f9eb'],
+                '0x300b1c7993d1e2f33007ca24a00c977d9b187d57e77e0b8fc6b344b8'
+            ]);
+        }));
+    });
+    describe('Encode/decode hex colors', () => {
+        it('Should encode hex encoded values properly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)({
+                colors: ['0xffffff', '0x000000']
+            });
+            expect(encoded).toEqual('a146636f6c6f72739f43ffffff43000000ff');
+        }));
+        it('Should decode hex properly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const cbor = 'a166636f6c6f72738243ffffff43000000';
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor });
+            expect(decoded).toEqual({ colors: ['0xffffff', '0x000000'] });
+        }));
+    });
+    describe('Encode/decode nested constructors', () => {
+        it('Should encode multiple constructors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const json = [
+                {
+                    constructor_0: [
+                        {
+                            name: 'xar12345'
+                        },
+                        1,
+                        {
+                            constructor_1: [
+                                {
+                                    custom_image: {
+                                        constructor_2: [{ image: 'ipfs://cid' }]
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                },
+                {
+                    constructor_0: [
+                        {
+                            name: 'xar12345'
+                        },
+                        1,
+                        {
+                            constructor_1: [
+                                {
+                                    custom_image: {
+                                        constructor_2: [{ image: 'ipfs://cid' }]
+                                    }
+                                }
+                            ]
+                        }
+                    ]
+                }
+            ];
+            const encoded = yield (0, index_1.encodeJsonToDatum)(json);
+            expect(encoded).toEqual('9fd8799fa1446e616d6548786172313233343501d87a9fa14c637573746f6d5f696d616765d87b9fa145696d6167654a697066733a2f2f636964ffffffd8799fa1446e616d6548786172313233343501d87a9fa14c637573746f6d5f696d616765d87b9fa145696d6167654a697066733a2f2f636964ffffffff');
+        }));
+        it('Should decode nested constructors', () => __awaiter(void 0, void 0, void 0, function* () {
+            const cbor = '82d87983a1446e616d6548786172313233343501d87a81a14c637573746f6d5f696d616765d87b81a145696d6167654a697066733a2f2f636964d87983a1446e616d6548786172313233343501d87a81a14c637573746f6d5f696d616765d87b81a145696d6167654a697066733a2f2f636964';
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor });
+            expect(decoded).toEqual([
+                {
+                    constructor_0: [
+                        { name: '0x7861723132333435' },
+                        1,
+                        { constructor_1: [{ custom_image: { constructor_2: [{ image: '0x697066733a2f2f636964' }] } }] }
+                    ]
+                },
+                {
+                    constructor_0: [
+                        { name: '0x7861723132333435' },
+                        1,
+                        { constructor_1: [{ custom_image: { constructor_2: [{ image: '0x697066733a2f2f636964' }] } }] }
+                    ]
+                }
+            ]);
+        }));
+    });
+    describe('encodeJsonToDatum tests', () => {
+        it('Should encode policyIds correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const json = {
+                '0x5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6': {
+                    '': 0
+                },
+                '0x8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eb': {
+                    '': 0
+                }
+            };
+            const encoded = yield (0, index_1.encodeJsonToDatum)(json);
+            expect(encoded).toEqual('a2581c5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6a14000581c8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eba14000');
+        }));
+        it('Should encode nested arrays and objects correctly', () => __awaiter(void 0, void 0, void 0, function* () {
+            const json = [
+                {
+                    '0x5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6': {
+                        '': 0
+                    }
+                },
+                [
+                    {
+                        '0x8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eb': {
+                            '': 0
+                        }
+                    },
+                    {
+                        '0x444444': {
+                            '': 0
+                        }
+                    }
+                ]
+            ];
+            const encoded = yield (0, index_1.encodeJsonToDatum)(json);
+            expect(encoded).toEqual('9fa1581c5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6a140009fa1581c8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eba14000a143444444a14000ffff');
+        }));
+        it('Should encode really long string', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)({
+                colors: '012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890123456789'
+            });
+            expect(encoded).toEqual('a146636f6c6f72735f5840303132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930313233343536373839303132335840343536373839303132333435363738393031323334353637383930313233343536373839303132333435363738393031323334353637383930313233343536375638393031323334353637383930313233343536373839ff');
+        }));
+    });
+    describe('decodeJsonDatumToJson tests', () => {
+        it('Should decode cbor that is not a 12(1-4) tag', () => __awaiter(void 0, void 0, void 0, function* () {
+            const cbor = 'a2581c5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6a14000581c8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eba14000';
+            const schema = {
+                '<hexstring>': {
+                    '<hexstring>': 'number'
+                }
+            };
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor, schema });
+            expect(decoded).toEqual({
+                '0x5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6': { '0x': 0 },
+                '0x8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eb': { '0x': 0 }
+            });
+        }));
+        it('should use default key type', () => __awaiter(void 0, void 0, void 0, function* () {
+            const cbor = 'a2581c5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6a14000581c8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eba14000';
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor, defaultKeyType: index_1.KeyType.HEX });
+            expect(decoded).toEqual({
+                '0x5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6': { '0x': 0 },
+                '0x8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eb': { '0x': 0 }
+            });
+        }));
+        it('Should decode cbor that is an array of objects and not a 12(1-4) tag', () => __awaiter(void 0, void 0, void 0, function* () {
+            const cbor = '82a1581c5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6a1400082a1581c8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eba14000a143444444a14000';
+            const schema = {
+                '[0]': {
+                    '<hexstring>': {
+                        '<hexstring>': 'number'
+                    }
+                },
+                '[1]': {
+                    '[all]': {
+                        '<hexstring>': {
+                            '<hexstring>': 'number'
+                        }
+                    }
+                }
+            };
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor, schema });
+            expect(decoded).toEqual([
+                { '0x5ca7f4e1e708ddf1958b2b7e65134738ebba5d8c803bdbe50ea0f3c6': { '0x': 0 } },
+                [
+                    { '0x8ed30c080aba8eb431dabb802ea8dda3a131b0f49c72d2766b25b1eb': { '0x': 0 } },
+                    { '0x444444': { '0x': 0 } }
+                ]
+            ]);
+        }));
+    });
+    describe('Encode/decode numeric keys', () => {
+        const getJson = () => [
+            '0x008e4ac0583cfeb7a1bb3434f10afc8439aa4d5e7eac6e6f2822ce5b9dfc56a127f684fe6d2bb4eedaef9525a69f0fa08b5796599cb6eae25d',
+            '0x700401221efdbba348b80457d4f27b17db1b45ad510511a8756ff564b5',
+            [
+                [
+                    '0x001bc2805461636f2031',
+                    ['0x04507ca1f0757dce73d1c410fa2a47918582f1c52a0661a308b97a27f24897f4', 0],
+                    5000000,
+                    0,
+                    {}
+                ],
+                [
+                    '0x001bc2805461636f2032',
+                    ['0x39dbe8fd40bfee718b34a6464731ae02f0c89e153ec2ffc5ebc0c0c5476a0c9c', 0],
+                    0,
+                    0,
+                    {}
+                ],
+                [
+                    '0x001bc2805461636f2033',
+                    ['0x939db71ab742a955ed2cb6c359a8f36dca52749871656fc13683c77072a3bc0b', 0],
+                    10000000,
+                    0,
+                    {}
+                ],
+                [
+                    '0x001bc2805461636f2034',
+                    ['0xb5ee5636290985cf378cc2819346eeee06efa8c13ab044f426b59c52e8224a99', 0],
+                    5000000,
+                    1698956400000,
+                    {}
+                ],
+                [
+                    '0x001bc2805461636f2035',
+                    ['0x1928d9ad51fdd909e187d7babdba79052cddb3aced97d2a7a28b3f7881545f26', 0],
+                    10000000,
+                    1698966000716,
+                    {
+                        '0xf0ff48bbb7bbe9d59a40f1ce90e9e9d0ff5002ec48f232b49ca0fb9a': {
+                            '1': 5000000,
+                            '2': 2500000,
+                            '3': 1000000
+                        }
+                    }
+                ]
+            ],
+            {
+                collectionName: 'Tacos',
+                collectionImage: 'ipfs://bafybeicy7cvoqste36bjfxsm37xuofxgh7kj7ryal7tbwmbhqowm4kmxke',
+                royaltyPercentage: 0,
+                royaltyAddress: 'addr_test1qz8y4szc8nlt0gdmxs60zzhussu65n2706kxumegyt89h80u26sj0a5ylekjhd8wmthe2fdxnu86pz6hjeveedh2ufwsq9puqn',
+                lastEditingContractHash: '0x0401221efdbba348b80457d4f27b17db1b45ad510511a8756ff564b5',
+                mintingPolicyId: '0x931f6c1fd0374e2c08449986c946aef138e95c3e3ff8c30a37bd017b',
+                nsfw: 0
+            }
+        ];
+        const schema = {
+            '[2]': {
+                '[all]': {
+                    '[4]': {
+                        '<hexstring>': {
+                            '<string>': 'number'
+                        }
+                    }
+                }
+            },
+            '[3]': {
+                collectionName: 'string',
+                collectionImage: 'string',
+                royaltyAddress: 'string'
+            }
+        };
+        const cbor = '9f5839008e4ac0583cfeb7a1bb3434f10afc8439aa4d5e7eac6e6f2822ce5b9dfc56a127f684fe6d2bb4eedaef9525a69f0fa08b5796599cb6eae25d581d700401221efdbba348b80457d4f27b17db1b45ad510511a8756ff564b59f9f4a001bc2805461636f20319f582004507ca1f0757dce73d1c410fa2a47918582f1c52a0661a308b97a27f24897f400ff1a004c4b4000a0ff9f4a001bc2805461636f20329f582039dbe8fd40bfee718b34a6464731ae02f0c89e153ec2ffc5ebc0c0c5476a0c9c00ff0000a0ff9f4a001bc2805461636f20339f5820939db71ab742a955ed2cb6c359a8f36dca52749871656fc13683c77072a3bc0b00ff1a0098968000a0ff9f4a001bc2805461636f20349f5820b5ee5636290985cf378cc2819346eeee06efa8c13ab044f426b59c52e8224a9900ff1a004c4b401b0000018b91b15580a0ff9f4a001bc2805461636f20359f58201928d9ad51fdd909e187d7babdba79052cddb3aced97d2a7a28b3f7881545f2600ff1a009896801b0000018b9243d44ca1581cf0ff48bbb7bbe9d59a40f1ce90e9e9d0ff5002ec48f232b49ca0fb9aa3011a004c4b40021a002625a0031a000f4240ffffa74e636f6c6c656374696f6e4e616d65455461636f734f636f6c6c656374696f6e496d6167655f5840697066733a2f2f6261667962656963793763766f717374653336626a6678736d333778756f66786768376b6a377279616c377462776d6268716f776d346b6d78426b65ff51726f79616c747950657263656e74616765004e726f79616c7479416464726573735f5840616464725f7465737431717a387934737a63386e6c743067646d787336307a7a687573737536356e323730366b78756d656779743839683830753236736a3061582c35796c656b6a686438776d746865326664786e753836707a36686a657665656468327566777371397075716eff576c61737445646974696e67436f6e747261637448617368581c0401221efdbba348b80457d4f27b17db1b45ad510511a8756ff564b54f6d696e74696e67506f6c6963794964581c931f6c1fd0374e2c08449986c946aef138e95c3e3ff8c30a37bd017b446e73667700ff';
+        it('Should convert from JSON to TxMetadataJson with numberic keys', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)(getJson(), true);
+            expect(encoded).toEqual(cbor);
+        }));
+        it('Should convert cbor to portal datum', () => __awaiter(void 0, void 0, void 0, function* () {
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor, schema });
+            expect(decoded).toEqual(getJson());
+        }));
+    });
+    describe('Encode/deode 0x strings', () => {
+        const getJson = () => [
+            '~0x008e4ac0583cfeb7a1bb3434f10afc8439aa4d5e7eac6e6f2822ce5b9dfc56a127f684fe6d2bb4eedaef9525a69f0fa08b5796599cb6eae25d'
+        ];
+        const schema = {
+            '[all]': 'string'
+        };
+        const cbor = '9f5f584030783030386534616330353833636665623761316262333433346631306166633834333961613464356537656163366536663238323263653562396466633536583461313237663638346665366432626234656564616566393532356136396630666130386235373936353939636236656165323564ffff';
+        it('Should convert from JSON to TxMetadataJson with numberic keys', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)(getJson());
+            expect(encoded).toEqual(cbor);
+        }));
+        it('Should convert cbor to portal datum', () => __awaiter(void 0, void 0, void 0, function* () {
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor, schema });
+            expect(decoded).toEqual([
+                '0x008e4ac0583cfeb7a1bb3434f10afc8439aa4d5e7eac6e6f2822ce5b9dfc56a127f684fe6d2bb4eedaef9525a69f0fa08b5796599cb6eae25d'
+            ]);
+        }));
+    });
+    describe('Encode/decode duplicate keys', () => {
+        const dupeKeyMap = new Map();
+        dupeKeyMap.set(new index_1.DupeKey('a'), 'abc');
+        dupeKeyMap.set(new index_1.DupeKey('a'), 'def');
+        dupeKeyMap.set(new index_1.DupeKey('b'), 'ghi');
+        dupeKeyMap.set(new index_1.DupeKey('b'), 'jkl');
+        dupeKeyMap.set(new index_1.DupeKey('c'), 'mno');
+        const json = {
+            discounts: dupeKeyMap
+        };
+        const cbor = 'a149646973636f756e7473a54161636162634161636465664162636768694162636a6b6c4163636d6e6f';
+        it('Should encode duplicate keys', () => __awaiter(void 0, void 0, void 0, function* () {
+            const encoded = yield (0, index_1.encodeJsonToDatum)(json);
+            expect(encoded).toEqual(cbor);
+        }));
+        it('Should decode duplicate keys as Dedupe Map', () => __awaiter(void 0, void 0, void 0, function* () {
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor, forJson: false });
+            const expected = [
+                {
+                    key: 'a',
+                    value: 'abc'
+                },
+                {
+                    key: 'a',
+                    value: 'def'
+                },
+                {
+                    key: 'b',
+                    value: 'ghi'
+                },
+                {
+                    key: 'b',
+                    value: 'jkl'
+                },
+                {
+                    key: 'c',
+                    value: 'mno'
+                }
+            ];
+            expect([...decoded.discounts.entries()].map(([key, value]) => ({
+                key: key instanceof index_1.DupeKey ? key.key : key,
+                value
+            }))).toEqual(expected);
+        }));
+        it('Should decode duplicate keys for json', () => __awaiter(void 0, void 0, void 0, function* () {
+            const decoded = yield (0, index_1.decodeCborToJson)({ cborString: cbor });
+            const expected = {
+                discounts: {
+                    dupekey_str_a_0: 'abc',
+                    dupekey_str_a_1: 'def',
+                    dupekey_str_b_0: 'ghi',
+                    dupekey_str_b_1: 'jkl',
+                    dupekey_str_c_0: 'mno'
+                }
+            };
+            expect(decoded).toEqual(expected);
+        }));
+    });
+});

package/lib/utils/cbor/schema/designer.d.ts

@@ -0,0 +1,18 @@
+export declare const designerSchema: {
+    bg_image: string;
+    pfp_image: string;
+    svg_version: string;
+    qr_link: string;
+    qr_inner_eye: string;
+    qr_outer_eye: string;
+    qr_dot: string;
+    qr_image: string;
+    font: string;
+    socials: {
+        '[all]': {
+            display: string;
+            url: string;
+        };
+    };
+    text_ribbon_gradient: string;
+};

package/lib/utils/cbor/schema/designer.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.designerSchema = void 0;
+exports.designerSchema = {
+    bg_image: 'string',
+    pfp_image: 'string',
+    svg_version: 'string',
+    qr_link: 'string',
+    qr_inner_eye: 'string',
+    qr_outer_eye: 'string',
+    qr_dot: 'string',
+    qr_image: 'string',
+    font: 'string',
+    socials: {
+        '[all]': {
+            display: 'string',
+            url: 'string'
+        }
+    },
+    text_ribbon_gradient: 'string'
+};

package/lib/utils/cbor/schema/handleData.d.ts

@@ -0,0 +1,30 @@
+export declare const handleDatumSchema: {
+    constructor_0: {
+        '[0]': {
+            name: string;
+            image: string;
+            mediaType: string;
+            og: string;
+            rarity: string;
+            characters: string;
+            numeric_modifiers: string;
+        };
+        '[2]': {
+            standard_image: string;
+            bg_image: string;
+            pfp_image: string;
+            portal: string;
+            designer: string;
+            socials: string;
+            vendor: string;
+            default: string;
+            resolved_addresses: {
+                ada: string;
+                '<string>': string;
+            };
+            trial: string;
+            nsfw: string;
+            svg_version: string;
+        };
+    };
+};

package/lib/utils/cbor/schema/handleData.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDatumSchema = void 0;
+exports.handleDatumSchema = {
+    constructor_0: {
+        '[0]': {
+            name: 'string',
+            image: 'string',
+            mediaType: 'string',
+            og: 'bool',
+            rarity: 'string',
+            characters: 'string',
+            numeric_modifiers: 'string'
+        },
+        '[2]': {
+            standard_image: 'string',
+            bg_image: 'string',
+            pfp_image: 'string',
+            portal: 'string',
+            designer: 'string',
+            socials: 'string',
+            vendor: 'string',
+            default: 'bool',
+            resolved_addresses: {
+                ada: 'hex',
+                '<string>': 'string'
+            },
+            trial: 'bool',
+            nsfw: 'bool',
+            svg_version: 'string'
+        }
+    }
+};

package/lib/utils/cbor/schema/portal.d.ts

@@ -0,0 +1,8 @@
+export declare const portalSchema: {
+    type: string;
+    domain: string;
+    custom_settings: {
+        '[all]': string;
+    };
+    default: string;
+};

package/lib/utils/cbor/schema/portal.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.portalSchema = void 0;
+exports.portalSchema = {
+    type: 'string',
+    domain: 'string',
+    custom_settings: {
+        '[all]': 'string'
+    },
+    default: 'bool'
+};

package/lib/utils/cbor/schema/socials.d.ts

@@ -0,0 +1,6 @@
+export declare const socialsSchema: {
+    '[all]': {
+        display: string;
+        url: string;
+    };
+};

package/lib/utils/cbor/schema/socials.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.socialsSchema = void 0;
+exports.socialsSchema = {
+    '[all]': {
+        display: 'string',
+        url: 'string'
+    }
+};

package/lib/utils/cbor/schema/subHandleSettings.d.ts

@@ -0,0 +1,43 @@
+export declare const subHandleSettingsDatumSchema: {
+    nft: {
+        enabled: string;
+        tierPricing: {
+            '[all]': {
+                0: string;
+                1: string;
+            };
+        };
+        enablePz: string;
+        creatorDefaults: {
+            font: string;
+            text_ribbon_gradient: string;
+            force_creator_settings: string;
+            qr_inner_eye: string;
+            qr_outer_eye: string;
+            qr_dot: string;
+            bg_image: string;
+        };
+        creatorDefaultsBgImage: string;
+    };
+    virtual: {
+        expires_in_days: string;
+        enabled: string;
+        tierPricing: {
+            '[all]': {
+                0: string;
+                1: string;
+            };
+        };
+        enablePz: string;
+        creatorDefaults: {
+            font: string;
+            text_ribbon_gradient: string;
+            force_creator_settings: string;
+            qr_inner_eye: string;
+            qr_outer_eye: string;
+            qr_dot: string;
+            bg_image: string;
+        };
+        creatorDefaultsBgImage: string;
+    };
+};

package/lib/utils/cbor/schema/subHandleSettings.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.subHandleSettingsDatumSchema = void 0;
+const subHandleSettings = {
+    enabled: 'bool',
+    tierPricing: {
+        '[all]': {
+            ['0']: 'number',
+            ['1']: 'number'
+        }
+    },
+    enablePz: 'bool',
+    creatorDefaults: {
+        font: 'string',
+        text_ribbon_gradient: 'string',
+        force_creator_settings: 'bool',
+        qr_inner_eye: 'string',
+        qr_outer_eye: 'string',
+        qr_dot: 'string',
+        bg_image: 'string'
+    },
+    creatorDefaultsBgImage: 'string'
+};
+exports.subHandleSettingsDatumSchema = {
+    nft: subHandleSettings,
+    virtual: Object.assign(Object.assign({}, subHandleSettings), { expires_in_days: 'number' })
+};

package/lib/utils/index.d.ts

@@ -7,3 +7,4 @@ export declare const asyncForEach: <T, U>(array: T[], callback: (item: T, index:
 export declare const isNumeric: (n: string) => boolean;
 export declare const isNullEmptyOrUndefined: (value: any) => boolean;
 export declare const isAlphaNumeric: (str: string) => boolean;
+export { KeyType, encodeJsonToDatum, decodeCborToJson } from './cbor';

package/lib/utils/index.js

@@ -9,7 +9,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.isAlphaNumeric = exports.isNullEmptyOrUndefined = exports.isNumeric = exports.asyncForEach = exports.awaitForEach = exports.chunk = exports.toADA = exports.toLovelace = exports.delay = void 0;
+exports.decodeCborToJson = exports.encodeJsonToDatum = exports.KeyType = exports.isAlphaNumeric = exports.isNullEmptyOrUndefined = exports.isNumeric = exports.asyncForEach = exports.awaitForEach = exports.chunk = exports.toADA = exports.toLovelace = exports.delay = void 0;
 const delay = (ms) => {
     return new Promise((resolve) => setTimeout(resolve, ms));
 };
@@ -20,9 +20,7 @@ const toADA = (lovelaceAmount) => lovelaceAmount / 1000000;
 exports.toADA = toADA;
 const chunk = (input, size) => {
     return input.reduce((arr, item, idx) => {
-        return idx % size === 0
-            ? [...arr, [item]]
-            : [...arr.slice(0, -1), [...arr.slice(-1)[0], item]];
+        return idx % size === 0 ? [...arr, [item]] : [...arr.slice(0, -1), [...arr.slice(-1)[0], item]];
     }, []);
 };
 exports.chunk = chunk;
@@ -32,7 +30,7 @@ const awaitForEach = (array, callback) => __awaiter(void 0, void 0, void 0, func
     }
 });
 exports.awaitForEach = awaitForEach;
-// Used to execute Promises in order, but still async. 
+// Used to execute Promises in order, but still async.
 // Good for adding delay between API calls and you need the complete list of results when they all resolve
 const asyncForEach = (array, callback, delayInMilliseconds = 0) => __awaiter(void 0, void 0, void 0, function* () {
     const promises = [];
@@ -50,10 +48,18 @@ const isNumeric = (n) => {
 };
 exports.isNumeric = isNumeric;
 const isNullEmptyOrUndefined = (value) => {
-    return value == undefined || value == null || value == '' || JSON.stringify(value) === '{}' || JSON.stringify(value) === '[]';
+    return (value == undefined ||
+        value == null ||
+        value == '' ||
+        JSON.stringify(value) === '{}' ||
+        JSON.stringify(value) === '[]');
 };
 exports.isNullEmptyOrUndefined = isNullEmptyOrUndefined;
 const isAlphaNumeric = (str) => {
     return /^[a-zA-Z0-9]+$/.test(str);
 };
 exports.isAlphaNumeric = isAlphaNumeric;
+var cbor_1 = require("./cbor");
+Object.defineProperty(exports, "KeyType", { enumerable: true, get: function () { return cbor_1.KeyType; } });
+Object.defineProperty(exports, "encodeJsonToDatum", { enumerable: true, get: function () { return cbor_1.encodeJsonToDatum; } });
+Object.defineProperty(exports, "decodeCborToJson", { enumerable: true, get: function () { return cbor_1.decodeCborToJson; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@koralabs/kora-labs-common",
-  "version": "2.6.0",
+  "version": "3.0.0",
   "description": "Kora Labs Common Utilities",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -30,6 +30,8 @@
     "typescript": "^4.7.3"
   },
   "dependencies": {
+    "boolean": "^3.2.0",
+    "cbor": "^9.0.2",
     "pluralize": "^8.0.0"
   },
   "files": [