zkcloudworker 0.15.0 → 0.15.2

package/lib/ts/src/mina/nft/types.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFTUpdateProof = exports.NFTImmutableState = exports.NFTState = exports.CollectionData = exports.NFTData = exports.MintSignatureData = exports.MintParams = exports.Storage = void 0;
+const o1js_1 = require("o1js");
+class Storage extends (0, o1js_1.Struct)({
+    url: o1js_1.Provable.Array(o1js_1.Field, 2),
+}) {
+    constructor(value) {
+        super(value);
+    }
+    static assertEquals(a, b) {
+        a.url[0].assertEquals(b.url[0]);
+        a.url[1].assertEquals(b.url[1]);
+    }
+    static equals(a, b) {
+        return a.url[0].equals(b.url[0]).and(a.url[1].equals(b.url[1]));
+    }
+    static fromURL(url) {
+        const fields = o1js_1.Encoding.stringToFields(url);
+        if (fields.length !== 2)
+            throw new Error("Invalid URL");
+        return new Storage({ url: [fields[0], fields[1]] });
+    }
+    toURL() {
+        return o1js_1.Encoding.stringFromFields(this.url);
+    }
+}
+exports.Storage = Storage;
+class NFTImmutableState extends (0, o1js_1.Struct)({
+    creator: o1js_1.PublicKey, // readonly
+    canChangeOwner: o1js_1.Bool, // readonly
+    canChangeMetadata: o1js_1.Bool, // readonly
+    canChangePrice: o1js_1.Bool, // readonly
+    canChangeStorage: o1js_1.Bool, // readonly
+    canChangeName: o1js_1.Bool, // readonly
+    canChangeMetadataVerificationKeyHash: o1js_1.Bool, // readonly
+    canPause: o1js_1.Bool, // readonly
+    address: o1js_1.PublicKey, // readonly
+    tokenId: o1js_1.Field, // readonly
+}) {
+    static assertEqual(a, b) {
+        a.creator.assertEquals(b.creator);
+        a.canChangeOwner.assertEquals(b.canChangeOwner);
+        a.canChangeMetadata.assertEquals(b.canChangeMetadata);
+        a.canChangePrice.assertEquals(b.canChangePrice);
+        a.canChangeStorage.assertEquals(b.canChangeStorage);
+        a.canChangeName.assertEquals(b.canChangeName);
+        a.canChangeMetadataVerificationKeyHash.assertEquals(b.canChangeMetadataVerificationKeyHash);
+        a.canPause.assertEquals(b.canPause);
+        a.address.assertEquals(b.address);
+        a.tokenId.assertEquals(b.tokenId);
+    }
+}
+exports.NFTImmutableState = NFTImmutableState;
+class NFTState extends (0, o1js_1.Struct)({
+    immutableState: NFTImmutableState,
+    name: o1js_1.Field,
+    metadata: o1js_1.Field,
+    storage: Storage,
+    owner: o1js_1.PublicKey,
+    price: o1js_1.UInt64,
+    version: o1js_1.UInt32,
+    isPaused: o1js_1.Bool,
+}) {
+    static assertEqual(a, b) {
+        NFTImmutableState.assertEqual(a.immutableState, b.immutableState);
+        a.name.assertEquals(b.name);
+        a.metadata.assertEquals(b.metadata);
+        Storage.assertEquals(a.storage, b.storage);
+        a.owner.assertEquals(b.owner);
+        a.price.assertEquals(b.price);
+        a.version.assertEquals(b.version);
+        a.isPaused.assertEquals(b.isPaused);
+    }
+}
+exports.NFTState = NFTState;
+class NFTUpdateProof extends o1js_1.DynamicProof {
+}
+exports.NFTUpdateProof = NFTUpdateProof;
+NFTUpdateProof.publicInputType = NFTState;
+NFTUpdateProof.publicOutputType = NFTState;
+NFTUpdateProof.maxProofsVerified = 2;
+NFTUpdateProof.featureFlags = o1js_1.FeatureFlags.allMaybe;
+class NFTData extends (0, o1js_1.Struct)({
+    price: o1js_1.UInt64,
+    version: o1js_1.UInt32,
+    canChangeOwner: o1js_1.Bool, // readonly
+    canChangeMetadata: o1js_1.Bool, // readonly
+    canChangePrice: o1js_1.Bool, // readonly
+    canChangeStorage: o1js_1.Bool, // readonly
+    canChangeName: o1js_1.Bool, // readonly
+    canChangeMetadataVerificationKeyHash: o1js_1.Bool, // readonly
+    canPause: o1js_1.Bool, // readonly
+    isPaused: o1js_1.Bool,
+    // what else?
+}) {
+    new(params = {}) {
+        const { price, version, canChangeOwner, canChangeMetadata, canChangePrice, canChangeStorage, canChangeName, canChangeMetadataVerificationKeyHash, canPause, isPaused, } = params;
+        return new NFTData({
+            price: o1js_1.UInt64.from(price ?? 0),
+            version: o1js_1.UInt32.from(version ?? 0),
+            canChangeOwner: (0, o1js_1.Bool)(canChangeOwner ?? true),
+            canChangeMetadata: (0, o1js_1.Bool)(canChangeMetadata ?? false),
+            canChangePrice: (0, o1js_1.Bool)(canChangePrice ?? true),
+            canChangeStorage: (0, o1js_1.Bool)(canChangeStorage ?? false),
+            canChangeName: (0, o1js_1.Bool)(canChangeName ?? false),
+            canChangeMetadataVerificationKeyHash: (0, o1js_1.Bool)(canChangeMetadataVerificationKeyHash ?? false),
+            canPause: (0, o1js_1.Bool)(canPause ?? false),
+            isPaused: (0, o1js_1.Bool)(isPaused ?? false),
+        });
+    }
+    pack() {
+        const price = this.price.value.toBits(64);
+        const version = this.version.value.toBits(32);
+        return o1js_1.Field.fromBits([
+            ...price,
+            ...version,
+            this.canChangeOwner,
+            this.canChangeMetadata,
+            this.canChangePrice,
+            this.canChangeStorage,
+            this.canChangeName,
+            this.canChangeMetadataVerificationKeyHash,
+            this.canPause,
+            this.isPaused,
+        ]);
+    }
+    static unpack(packed) {
+        const bits = packed.toBits(64 + 32 + 8);
+        const price = o1js_1.UInt64.Unsafe.fromField(o1js_1.Field.fromBits(bits.slice(0, 64)));
+        const version = o1js_1.UInt32.Unsafe.fromField(o1js_1.Field.fromBits(bits.slice(64, 64 + 32)));
+        const canChangeOwner = bits[64 + 32];
+        const canChangeMetadata = bits[64 + 32 + 1];
+        const canChangePrice = bits[64 + 32 + 2];
+        const canChangeStorage = bits[64 + 32 + 3];
+        const canChangeName = bits[64 + 32 + 4];
+        const canChangeMetadataVerificationKeyHash = bits[64 + 32 + 5];
+        const canPause = bits[64 + 32 + 6];
+        const isPaused = bits[64 + 32 + 7];
+        return new NFTData({
+            price,
+            version,
+            canChangeOwner,
+            canChangeMetadata,
+            canChangePrice,
+            canChangeStorage,
+            canChangeName,
+            canChangeMetadataVerificationKeyHash,
+            canPause,
+            isPaused,
+        });
+    }
+}
+exports.NFTData = NFTData;
+class CollectionData extends (0, o1js_1.Struct)({
+    requireTransferApproval: o1js_1.Bool,
+    requireUpdateApproval: o1js_1.Bool,
+    requireSaleApproval: o1js_1.Bool,
+    requireBuyApproval: o1js_1.Bool,
+    requireMintApproval: o1js_1.Bool,
+    canMint: o1js_1.Bool,
+    canPause: o1js_1.Bool,
+    canResume: o1js_1.Bool,
+    canChangeName: o1js_1.Bool,
+    canChangeCreator: o1js_1.Bool,
+    canChangeBaseUri: o1js_1.Bool,
+    canChangeSaleCommission: o1js_1.Bool,
+    isPaused: o1js_1.Bool,
+}) {
+    pack() {
+        return o1js_1.Field.fromBits([
+            this.requireTransferApproval,
+            this.requireUpdateApproval,
+            this.requireSaleApproval,
+            this.requireMintApproval,
+            this.requireBuyApproval,
+            this.canMint,
+            this.canChangeName,
+            this.canChangeCreator,
+            this.canChangeBaseUri,
+            this.canChangeSaleCommission,
+            this.canPause,
+            this.canResume,
+            this.isPaused,
+        ]);
+    }
+    static unpack(packed) {
+        const bits = packed.toBits(13);
+        return new CollectionData({
+            requireTransferApproval: bits[0],
+            requireUpdateApproval: bits[1],
+            requireSaleApproval: bits[2],
+            requireMintApproval: bits[3],
+            requireBuyApproval: bits[4],
+            canMint: bits[5],
+            canChangeName: bits[6],
+            canChangeCreator: bits[7],
+            canChangeBaseUri: bits[8],
+            canChangeSaleCommission: bits[9],
+            canPause: bits[10],
+            canResume: bits[11],
+            isPaused: bits[12],
+        });
+    }
+}
+exports.CollectionData = CollectionData;
+class MintParams extends (0, o1js_1.Struct)({
+    name: o1js_1.Field,
+    address: o1js_1.PublicKey,
+    tokenId: o1js_1.Field,
+    owner: o1js_1.PublicKey,
+    data: NFTData,
+    fee: o1js_1.UInt64,
+    metadata: o1js_1.Field,
+    storage: Storage,
+    metadataVerificationKey: o1js_1.VerificationKey,
+    nftVerificationKey: o1js_1.VerificationKey,
+    expiry: o1js_1.UInt32,
+}) {
+}
+exports.MintParams = MintParams;
+class MintSignatureData extends (0, o1js_1.Struct)({
+    name: o1js_1.Field,
+    address: o1js_1.PublicKey,
+    tokenId: o1js_1.Field,
+    owner: o1js_1.PublicKey,
+    packedData: o1js_1.Field,
+    fee: o1js_1.UInt64,
+    metadata: o1js_1.Field,
+    storage: Storage,
+    metadataVerificationKeyHash: o1js_1.Field,
+    nftVerificationKeyHash: o1js_1.Field,
+    expiry: o1js_1.UInt32,
+}) {
+}
+exports.MintSignatureData = MintSignatureData;

package/lib/ts/src/mina/nft/whitelist-admin.d.ts

@@ -0,0 +1,21 @@
+import { DeployArgs, PublicKey, SmartContract, State, VerificationKey, UInt64, Field } from "o1js";
+import { MintParams, NFTState, NFTAdminBase, Storage } from "./types";
+export interface NFTWhitelistedAdminDeployProps extends Exclude<DeployArgs, undefined> {
+    admin: PublicKey;
+    whitelist: Field;
+    storage: Storage;
+}
+export declare class NFTWhitelistedAdmin extends SmartContract implements NFTAdminBase {
+    admin: State<PublicKey>;
+    whitelist: State<import("o1js/dist/node/lib/provable/field").Field>;
+    storage: State<Storage>;
+    deploy(props: NFTWhitelistedAdminDeployProps): Promise<void>;
+    isWhitelisted(address: PublicKey, amount: UInt64): Promise<import("o1js/dist/node/lib/provable/bool").Bool>;
+    updateVerificationKey(vk: VerificationKey): Promise<void>;
+    canMint(params: MintParams): Promise<import("o1js/dist/node/lib/provable/bool").Bool>;
+    canUpdate(input: NFTState, output: NFTState): Promise<import("o1js/dist/node/lib/provable/bool").Bool>;
+    canTransfer(address: PublicKey, from: PublicKey, to: PublicKey): Promise<import("o1js/dist/node/lib/provable/bool").Bool>;
+    canSell(address: PublicKey, seller: PublicKey, price: UInt64): Promise<import("o1js/dist/node/lib/provable/bool").Bool>;
+    canBuy(address: PublicKey, seller: PublicKey, buyer: PublicKey, price: UInt64): Promise<import("o1js/dist/node/lib/provable/bool").Bool>;
+    updateMerkleMapRoot(root: Field): Promise<void>;
+}

package/lib/ts/src/mina/nft/whitelist-admin.js

@@ -0,0 +1,131 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NFTWhitelistedAdmin = void 0;
+const o1js_1 = require("o1js");
+const whitelist_1 = require("./whitelist");
+const types_1 = require("./types");
+class NFTWhitelistedAdmin extends o1js_1.SmartContract {
+    constructor() {
+        super(...arguments);
+        this.admin = (0, o1js_1.State)();
+        this.whitelist = (0, o1js_1.State)();
+        this.storage = (0, o1js_1.State)();
+    }
+    async deploy(props) {
+        await super.deploy(props);
+        this.admin.set(props.admin);
+        this.whitelist.set(props.whitelist);
+        this.storage.set(props.storage);
+        this.account.permissions.set({
+            ...o1js_1.Permissions.default(),
+            setVerificationKey: o1js_1.Permissions.VerificationKey.impossibleDuringCurrentVersion(),
+            setPermissions: o1js_1.Permissions.impossible(),
+        });
+    }
+    async isWhitelisted(address, amount) {
+        const whitelist = this.whitelist.getAndRequireEquals();
+        const storage = this.storage.getAndRequireEquals();
+        const map = await o1js_1.Provable.witnessAsync(whitelist_1.Whitelist, async () => {
+            return await (0, whitelist_1.loadWhitelist)(storage);
+        });
+        map.root.assertEquals(whitelist);
+        const key = o1js_1.Poseidon.hash(address.toFields());
+        map.assertIncluded(key, "Address not whitelisted");
+        const value = map.get(key);
+        value.assertLessThanOrEqual((0, o1js_1.Field)(o1js_1.UInt64.MAXINT().value));
+        const maxAmount = o1js_1.UInt64.Unsafe.fromField(value);
+        return (0, o1js_1.Bool)(amount.lessThanOrEqual(maxAmount));
+    }
+    async updateVerificationKey(vk) {
+        const sender = this.sender.getAndRequireSignature();
+        this.admin.getAndRequireEquals().assertEquals(sender);
+        this.account.verificationKey.set(vk);
+    }
+    async canMint(params) {
+        return await this.isWhitelisted(params.owner, o1js_1.UInt64.from(0));
+    }
+    async canUpdate(input, output) {
+        return await this.isWhitelisted(output.owner, o1js_1.UInt64.from(0));
+    }
+    async canTransfer(address, from, to) {
+        return await this.isWhitelisted(to, o1js_1.UInt64.from(0));
+    }
+    async canSell(address, seller, price) {
+        return await this.isWhitelisted(address, price);
+    }
+    async canBuy(address, seller, buyer, price) {
+        return (await this.isWhitelisted(buyer, price)).and(await this.isWhitelisted(seller, price));
+    }
+    async updateMerkleMapRoot(root) {
+        const sender = this.sender.getAndRequireSignature();
+        this.admin.getAndRequireEquals().assertEquals(sender);
+        this.whitelist.set(root);
+    }
+}
+exports.NFTWhitelistedAdmin = NFTWhitelistedAdmin;
+__decorate([
+    (0, o1js_1.state)(o1js_1.PublicKey),
+    __metadata("design:type", Object)
+], NFTWhitelistedAdmin.prototype, "admin", void 0);
+__decorate([
+    (0, o1js_1.state)(o1js_1.Field),
+    __metadata("design:type", Object)
+], NFTWhitelistedAdmin.prototype, "whitelist", void 0);
+__decorate([
+    (0, o1js_1.state)(types_1.Storage),
+    __metadata("design:type", Object)
+], NFTWhitelistedAdmin.prototype, "storage", void 0);
+__decorate([
+    o1js_1.method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [o1js_1.VerificationKey]),
+    __metadata("design:returntype", Promise)
+], NFTWhitelistedAdmin.prototype, "updateVerificationKey", null);
+__decorate([
+    o1js_1.method.returns(o1js_1.Bool),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [types_1.MintParams]),
+    __metadata("design:returntype", Promise)
+], NFTWhitelistedAdmin.prototype, "canMint", null);
+__decorate([
+    o1js_1.method.returns(o1js_1.Bool),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [types_1.NFTState, types_1.NFTState]),
+    __metadata("design:returntype", Promise)
+], NFTWhitelistedAdmin.prototype, "canUpdate", null);
+__decorate([
+    o1js_1.method.returns(o1js_1.Bool),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [o1js_1.PublicKey, o1js_1.PublicKey, o1js_1.PublicKey]),
+    __metadata("design:returntype", Promise)
+], NFTWhitelistedAdmin.prototype, "canTransfer", null);
+__decorate([
+    o1js_1.method.returns(o1js_1.Bool),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [o1js_1.PublicKey, o1js_1.PublicKey, o1js_1.UInt64]),
+    __metadata("design:returntype", Promise)
+], NFTWhitelistedAdmin.prototype, "canSell", null);
+__decorate([
+    o1js_1.method.returns(o1js_1.Bool),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [o1js_1.PublicKey,
+        o1js_1.PublicKey,
+        o1js_1.PublicKey,
+        o1js_1.UInt64]),
+    __metadata("design:returntype", Promise)
+], NFTWhitelistedAdmin.prototype, "canBuy", null);
+__decorate([
+    o1js_1.method,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [o1js_1.Field]),
+    __metadata("design:returntype", Promise)
+], NFTWhitelistedAdmin.prototype, "updateMerkleMapRoot", null);

package/lib/ts/src/mina/nft/whitelist.d.ts

@@ -0,0 +1,20 @@
+import { Storage } from "./types";
+declare const IndexedMerkleMap: typeof import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMap;
+declare const Whitelist_base: typeof import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase;
+export declare class Whitelist extends Whitelist_base {
+}
+export declare function loadWhitelist(storage: Storage): Promise<Whitelist>;
+interface IndexedMapSerialized {
+    height: number;
+    root: string;
+    length: string;
+    nodes: string;
+    sortedLeaves: string;
+}
+export declare function serializeWhitelist(map: Whitelist): string;
+export declare function deserializeWhitelist(params: {
+    serializedIndexedMap: string;
+    type?: ReturnType<typeof IndexedMerkleMap>;
+}): InstanceType<ReturnType<typeof IndexedMerkleMap>> | undefined;
+export declare function parseIndexedMapSerialized(serializedMap: string): IndexedMapSerialized;
+export {};

package/lib/ts/src/mina/nft/whitelist.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Whitelist = void 0;
+exports.loadWhitelist = loadWhitelist;
+exports.serializeWhitelist = serializeWhitelist;
+exports.deserializeWhitelist = deserializeWhitelist;
+exports.parseIndexedMapSerialized = parseIndexedMapSerialized;
+const o1js_1 = require("o1js");
+const cloud_1 = require("../../cloud");
+const { IndexedMerkleMap } = o1js_1.Experimental;
+class Whitelist extends IndexedMerkleMap(10) {
+}
+exports.Whitelist = Whitelist;
+async function loadWhitelist(storage) {
+    const url = "https://gateway.pinata.cloud/ipfs/" + storage.toURL();
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error("Failed to fetch whitelist");
+    }
+    const json = await response.text();
+    const map = deserializeWhitelist({
+        serializedIndexedMap: json,
+        type: Whitelist,
+    });
+    if (!map) {
+        throw new Error("Failed to deserialize whitelist");
+    }
+    return map;
+}
+function serializeWhitelist(map) {
+    const serializedMap = JSON.stringify({
+        height: map.height,
+        root: map.root.toJSON(),
+        length: map.length.toJSON(),
+        nodes: JSON.stringify(map.data.get().nodes, (_, v) => typeof v === "bigint" ? "n" + (0, cloud_1.bigintToBase64)(v) : v),
+        sortedLeaves: JSON.stringify(map.data
+            .get()
+            .sortedLeaves.map((v) => [
+            (0, cloud_1.bigintToBase64)(v.key),
+            (0, cloud_1.bigintToBase64)(v.nextKey),
+            (0, cloud_1.bigintToBase64)(v.value),
+            (0, cloud_1.bigintToBase64)(BigInt(v.index)),
+        ])),
+    }, null, 2);
+    return serializedMap;
+}
+function deserializeWhitelist(params) {
+    try {
+        const { serializedIndexedMap, type } = params;
+        const json = parseIndexedMapSerialized(serializedIndexedMap);
+        return deserializeIndexedMapInternal({
+            json,
+            type: type ?? IndexedMerkleMap(json.height),
+        });
+    }
+    catch (error) {
+        console.error("Error deserializing map:", error?.message ?? error);
+        return undefined;
+    }
+}
+function parseIndexedMapSerialized(serializedMap) {
+    const json = JSON.parse(serializedMap);
+    if (json.height === undefined ||
+        json.root === undefined ||
+        json.length === undefined ||
+        json.nodes === undefined ||
+        json.sortedLeaves === undefined)
+        throw new Error("wrong IndexedMerkleMap json format");
+    if (typeof json.height !== "number")
+        throw new Error("wrong IndexedMerkleMap height format");
+    if (typeof json.root !== "string")
+        throw new Error("wrong IndexedMerkleMap root format");
+    if (typeof json.length !== "string")
+        throw new Error("wrong IndexedMerkleMap length format");
+    if (typeof json.nodes !== "string")
+        throw new Error("wrong IndexedMerkleMap nodes format");
+    if (typeof json.sortedLeaves !== "string")
+        throw new Error("wrong IndexedMerkleMap sortedLeaves format");
+    return json;
+}
+function deserializeIndexedMapInternal(params) {
+    const { json, type } = params;
+    const map = new type();
+    if (json.height !== map.height) {
+        throw new Error("wrong IndexedMap height");
+    }
+    const nodes = JSON.parse(json.nodes, (_, v) => {
+        // Check if the value is a string that represents a BigInt
+        if (typeof v === "string" && v[0] === "n") {
+            // Remove the first 'n' and convert the string to a BigInt
+            return (0, cloud_1.bigintFromBase64)(v.slice(1));
+        }
+        return v;
+    });
+    const sortedLeaves = JSON.parse(json.sortedLeaves).map((row) => {
+        return {
+            key: (0, cloud_1.bigintFromBase64)(row[0]),
+            nextKey: (0, cloud_1.bigintFromBase64)(row[1]),
+            value: (0, cloud_1.bigintFromBase64)(row[2]),
+            index: Number((0, cloud_1.bigintFromBase64)(row[3])),
+        };
+    });
+    map.root = o1js_1.Field.fromJSON(json.root);
+    map.length = o1js_1.Field.fromJSON(json.length);
+    map.data.updateAsProver(() => {
+        return {
+            nodes: nodes.map((row) => [...row]),
+            sortedLeaves: [...sortedLeaves],
+        };
+    });
+    return map;
+}