zkcloudworker 0.17.5 → 0.17.7

package/lib/ts/src/mina/index.d.ts

@@ -4,3 +4,4 @@ export * from "./local/local";
 export * from "./verification";
 export * from "./token";
 export * from "./transactions";
+export * from "./storage";

package/lib/ts/src/mina/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./local/local"), exports);
 __exportStar(require("./verification"), exports);
 __exportStar(require("./token"), exports);
 __exportStar(require("./transactions"), exports);
+__exportStar(require("./storage"), exports);

package/lib/ts/src/mina/storage/ipfs.js

@@ -3,6 +3,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.createIpfsURL = createIpfsURL;
 function createIpfsURL(params) {
     let { hash, gateway, apiToken } = params;
+    gateway ??=
+        process.env.PINATA_IPFS_GATEWAY ??
+            process.env.NEXT_PUBLIC_PINATA_IPFS_GATEWAY ??
+            process.env.REACT_APP_PINATA_IPFS_GATEWAY;
+    apiToken ??=
+        process.env.PINATA_GATEWAY_TOKEN ??
+            process.env.NEXT_PUBLIC_PINATA_GATEWAY_TOKEN ??
+            process.env.REACT_APP_PINATA_GATEWAY_TOKEN;
     if (!gateway) {
         gateway = "https://gateway.pinata.cloud/ipfs/";
     }

package/lib/ts/src/mina/storage/pinata.d.ts

@@ -1,6 +1,6 @@
 export declare function pinJSON(params: {
     data: string | object;
-    name: string;
+    name?: string;
     keyvalues?: object;
-    auth: string;
+    auth?: string;
 }): Promise<string | undefined>;

package/lib/ts/src/mina/storage/pinata.js

@@ -2,7 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.pinJSON = pinJSON;
 async function pinJSON(params) {
-    const { data, name, keyvalues, auth } = params;
+    const { data, name = "data.json", keyvalues = [{ key: "library", value: "zkcloudworker" }], } = params;
+    const auth = params.auth ??
+        process.env.PINATA_JWT ??
+        process.env.NEXT_PUBLIC_PINATA_JWT ??
+        process.env.REACT_APP_PINATA_JWT;
     try {
         const pinataData = {
             pinataOptions: {

package/lib/ts/src/mina/token/index.d.ts

@@ -2,3 +2,4 @@ export * from "./FungibleToken";
 export * from "./FungibleTokenAdmin";
 export * from "./api";
 export * from "./vk";
+export * from "./whitelist";

package/lib/ts/src/mina/token/index.js

@@ -18,3 +18,4 @@ __exportStar(require("./FungibleToken"), exports);
 __exportStar(require("./FungibleTokenAdmin"), exports);
 __exportStar(require("./api"), exports);
 __exportStar(require("./vk"), exports);
+__exportStar(require("./whitelist"), exports);

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

@@ -0,0 +1,305 @@
+import { Field, Option, PublicKey, UInt64, Bool } from "o1js";
+import { Storage } from "../..";
+declare const WhitelistMap_base: typeof import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase;
+/** Represents the whitelist using an Indexed Merkle Map. */
+export declare class WhitelistMap extends WhitelistMap_base {
+}
+declare const WhitelistMapOption_base: import("o1js/dist/node/lib/provable/types/provable-intf").Provable<Option<import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase, {
+    root: bigint;
+    length: bigint;
+    data: {
+        nodes: (bigint | undefined)[][];
+        sortedLeaves: {
+            readonly value: bigint;
+            readonly key: bigint;
+            readonly nextKey: bigint;
+            readonly index: number;
+        }[];
+    };
+}>, {
+    root: bigint;
+    length: bigint;
+    data: {
+        nodes: (bigint | undefined)[][];
+        sortedLeaves: {
+            readonly value: bigint;
+            readonly key: bigint;
+            readonly nextKey: bigint;
+            readonly index: number;
+        }[];
+    };
+} | undefined> & (new (option: {
+    isSome: Bool;
+    value: import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase;
+}) => Option<import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase, {
+    root: bigint;
+    length: bigint;
+    data: {
+        nodes: (bigint | undefined)[][];
+        sortedLeaves: {
+            readonly value: bigint;
+            readonly key: bigint;
+            readonly nextKey: bigint;
+            readonly index: number;
+        }[];
+    };
+}>) & {
+    fromValue(value: import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase | {
+        root: bigint;
+        length: bigint;
+        data: {
+            nodes: (bigint | undefined)[][];
+            sortedLeaves: {
+                readonly value: bigint;
+                readonly key: bigint;
+                readonly nextKey: bigint;
+                readonly index: number;
+            }[];
+        };
+    } | {
+        isSome: boolean | Bool;
+        value: import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase | {
+            root: bigint;
+            length: bigint;
+            data: {
+                nodes: (bigint | undefined)[][];
+                sortedLeaves: {
+                    readonly value: bigint;
+                    readonly key: bigint;
+                    readonly nextKey: bigint;
+                    readonly index: number;
+                }[];
+            };
+        };
+    } | undefined): Option<import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase, {
+        root: bigint;
+        length: bigint;
+        data: {
+            nodes: (bigint | undefined)[][];
+            sortedLeaves: {
+                readonly value: bigint;
+                readonly key: bigint;
+                readonly nextKey: bigint;
+                readonly index: number;
+            }[];
+        };
+    }>;
+    from(value?: import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase | {
+        root: bigint;
+        length: bigint;
+        data: {
+            nodes: (bigint | undefined)[][];
+            sortedLeaves: {
+                readonly value: bigint;
+                readonly key: bigint;
+                readonly nextKey: bigint;
+                readonly index: number;
+            }[];
+        };
+    } | undefined): Option<import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase, {
+        root: bigint;
+        length: bigint;
+        data: {
+            nodes: (bigint | undefined)[][];
+            sortedLeaves: {
+                readonly value: bigint;
+                readonly key: bigint;
+                readonly nextKey: bigint;
+                readonly index: number;
+            }[];
+        };
+    }>;
+    none(): Option<import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase, {
+        root: bigint;
+        length: bigint;
+        data: {
+            nodes: (bigint | undefined)[][];
+            sortedLeaves: {
+                readonly value: bigint;
+                readonly key: bigint;
+                readonly nextKey: bigint;
+                readonly index: number;
+            }[];
+        };
+    }>;
+};
+export declare class WhitelistMapOption extends WhitelistMapOption_base {
+}
+declare const UInt64Option_base: Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<Option<UInt64, bigint>, bigint | undefined>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => Option<UInt64, bigint>;
+} & (new (option: {
+    isSome: Bool;
+    value: UInt64;
+}) => Option<UInt64, bigint>) & {
+    fromValue(value: bigint | UInt64 | {
+        isSome: boolean | Bool;
+        value: bigint | UInt64;
+    } | undefined): Option<UInt64, bigint>;
+    from(value?: bigint | UInt64 | undefined): Option<UInt64, bigint>;
+    none(): Option<UInt64, bigint>;
+};
+export declare class UInt64Option extends UInt64Option_base {
+}
+declare const WhitelistedAddress_base: (new (value: {
+    address: PublicKey;
+    amount: UInt64;
+}) => {
+    address: PublicKey;
+    amount: UInt64;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    address: PublicKey;
+    amount: UInt64;
+}, {
+    address: {
+        x: bigint;
+        isOdd: boolean;
+    };
+    amount: bigint;
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+} & {
+    fromValue: (value: {
+        address: PublicKey | {
+            x: Field | bigint;
+            isOdd: Bool | boolean;
+        };
+        amount: bigint | UInt64;
+    }) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+    toInput: (x: {
+        address: PublicKey;
+        amount: UInt64;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        address: PublicKey;
+        amount: UInt64;
+    }) => {
+        address: string;
+        amount: string;
+    };
+    fromJSON: (x: {
+        address: string;
+        amount: string;
+    }) => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+    empty: () => {
+        address: PublicKey;
+        amount: UInt64;
+    };
+};
+export declare class WhitelistedAddress extends WhitelistedAddress_base {
+}
+declare const Whitelist_base: (new (value: {
+    root: import("o1js/dist/node/lib/provable/field").Field;
+    storage: Storage;
+}) => {
+    root: import("o1js/dist/node/lib/provable/field").Field;
+    storage: Storage;
+}) & {
+    _isStruct: true;
+} & Omit<import("o1js/dist/node/lib/provable/types/provable-intf").Provable<{
+    root: import("o1js/dist/node/lib/provable/field").Field;
+    storage: Storage;
+}, {
+    root: bigint;
+    storage: {
+        url: bigint[];
+    };
+}>, "fromFields"> & {
+    fromFields: (fields: import("o1js/dist/node/lib/provable/field").Field[]) => {
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        storage: Storage;
+    };
+} & {
+    fromValue: (value: {
+        root: string | number | bigint | import("o1js/dist/node/lib/provable/field").Field;
+        storage: Storage | {
+            url: import("o1js/dist/node/lib/provable/field").Field[] | bigint[];
+        };
+    }) => {
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        storage: Storage;
+    };
+    toInput: (x: {
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        storage: Storage;
+    }) => {
+        fields?: Field[] | undefined;
+        packed?: [Field, number][] | undefined;
+    };
+    toJSON: (x: {
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        storage: Storage;
+    }) => {
+        root: string;
+        storage: {
+            url: string[];
+        };
+    };
+    fromJSON: (x: {
+        root: string;
+        storage: {
+            url: string[];
+        };
+    }) => {
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        storage: Storage;
+    };
+    empty: () => {
+        root: import("o1js/dist/node/lib/provable/field").Field;
+        storage: Storage;
+    };
+};
+export declare class Whitelist extends Whitelist_base {
+    isNone(): Bool;
+    isSome(): Bool;
+    load(): Promise<WhitelistMapOption>;
+    /**
+     * The function fetches a whitelisted amount associated with a given address using a map and returns it
+     * as a UInt64Option.
+     * @param {PublicKey} address - The `address` parameter is of type `PublicKey`, which represents a
+     * public key used in cryptography for various purposes such as encryption, digital signatures, and
+     * authentication. In the context of the `fetchWhitelistedAmount` function, the `address` parameter is
+     * used to retrieve a whitelisted amount
+     * @returns The `fetchWhitelistedAmount` function returns a `Promise` that resolves to a `UInt64Option`
+     * object. This object contains a `value` property representing the amount retrieved from a map based
+     * on the provided address. The `isSome` property indicates whether the value is present or not.
+     * The value is not present if the whitelist is NOT empty and the address is NOT whitelisted.
+     * The value is present if the whitelist is NOT empty or the address IS whitelisted.
+     * The value is present and equals to UInt64.MAXINT() if the whitelist IS empty.
+     */
+    getWhitelistedAmount(address: PublicKey): Promise<UInt64Option>;
+    static empty(): Whitelist;
+    /**
+     * Creates a new whitelist and pins it to IPFS.
+     * @param params - The parameters for creating the whitelist.
+     * @returns A new `Whitelist` instance.
+     */
+    static create(params: {
+        list: WhitelistedAddress[] | {
+            address: string;
+            amount?: number;
+        }[];
+        name?: string;
+        keyvalues?: {
+            key: string;
+            value: string;
+        }[];
+        timeout?: number;
+        attempts?: number;
+        auth?: string;
+    }): Promise<Whitelist>;
+}
+export {};

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

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Whitelist = exports.WhitelistedAddress = exports.UInt64Option = exports.WhitelistMapOption = exports.WhitelistMap = void 0;
+const o1js_1 = require("o1js");
+const __1 = require("../..");
+const { IndexedMerkleMap } = o1js_1.Experimental;
+const WHITELIST_HEIGHT = 20;
+/** Represents the whitelist using an Indexed Merkle Map. */
+class WhitelistMap extends IndexedMerkleMap(WHITELIST_HEIGHT) {
+}
+exports.WhitelistMap = WhitelistMap;
+class WhitelistMapOption extends (0, o1js_1.Option)(WhitelistMap) {
+}
+exports.WhitelistMapOption = WhitelistMapOption;
+class UInt64Option extends (0, o1js_1.Option)(o1js_1.UInt64) {
+}
+exports.UInt64Option = UInt64Option;
+class WhitelistedAddress extends (0, o1js_1.Struct)({
+    address: o1js_1.PublicKey,
+    amount: o1js_1.UInt64, // Maximum permitted amount of the transaction
+}) {
+}
+exports.WhitelistedAddress = WhitelistedAddress;
+class Whitelist extends (0, o1js_1.Struct)({
+    /** The root hash of the Merkle tree representing the whitelist. */
+    root: o1js_1.Field,
+    /** Off-chain storage information, typically an IPFS hash pointing to the whitelist data. */
+    storage: __1.Storage,
+}) {
+    isNone() {
+        return this.root
+            .equals((0, o1js_1.Field)(0))
+            .or(__1.Storage.equals(this.storage, __1.Storage.empty()));
+    }
+    isSome() {
+        return this.isNone().not();
+    }
+    async load() {
+        const isNone = this.isNone();
+        const map = await o1js_1.Provable.witnessAsync(WhitelistMapOption, async () => {
+            if (isNone.toBoolean())
+                return WhitelistMapOption.none();
+            else
+                return WhitelistMapOption.fromValue(await (0, __1.loadIndexedMerkleMap)({
+                    url: (0, __1.createIpfsURL)({ hash: this.storage.toString() }),
+                    type: WhitelistMap,
+                }));
+        });
+        isNone.assertEquals(map.isSome.not());
+        const root = o1js_1.Provable.if(map.isSome, map.orElse(new WhitelistMap()).root, (0, o1js_1.Field)(0));
+        root.equals(this.root);
+        return map;
+    }
+    /**
+     * The function fetches a whitelisted amount associated with a given address using a map and returns it
+     * as a UInt64Option.
+     * @param {PublicKey} address - The `address` parameter is of type `PublicKey`, which represents a
+     * public key used in cryptography for various purposes such as encryption, digital signatures, and
+     * authentication. In the context of the `fetchWhitelistedAmount` function, the `address` parameter is
+     * used to retrieve a whitelisted amount
+     * @returns The `fetchWhitelistedAmount` function returns a `Promise` that resolves to a `UInt64Option`
+     * object. This object contains a `value` property representing the amount retrieved from a map based
+     * on the provided address. The `isSome` property indicates whether the value is present or not.
+     * The value is not present if the whitelist is NOT empty and the address is NOT whitelisted.
+     * The value is present if the whitelist is NOT empty or the address IS whitelisted.
+     * The value is present and equals to UInt64.MAXINT() if the whitelist IS empty.
+     */
+    async getWhitelistedAmount(address) {
+        const map = await this.load();
+        const key = o1js_1.Poseidon.hashPacked(o1js_1.PublicKey, address);
+        const value = map.orElse(new WhitelistMap()).getOption(key);
+        const valueField = value.orElse(o1js_1.UInt64.MAXINT().value);
+        valueField.assertLessThanOrEqual(o1js_1.UInt64.MAXINT().value);
+        const amount = o1js_1.UInt64.Unsafe.fromField(valueField);
+        return new UInt64Option({
+            value: amount,
+            isSome: value.isSome.or(this.isNone()),
+        });
+    }
+    static empty() {
+        return new Whitelist({
+            root: (0, o1js_1.Field)(0),
+            storage: __1.Storage.empty(),
+        });
+    }
+    /**
+     * Creates a new whitelist and pins it to IPFS.
+     * @param params - The parameters for creating the whitelist.
+     * @returns A new `Whitelist` instance.
+     */
+    static async create(params) {
+        const { name = "whitelist.json", keyvalues = [{ key: "library", value: "zkcloudworker" }], timeout = 60 * 1000, attempts = 5, auth, } = params;
+        const list = typeof params.list[0].address === "string"
+            ? params.list.map((item) => new WhitelistedAddress({
+                address: o1js_1.PublicKey.fromBase58(item.address),
+                amount: item.amount
+                    ? o1js_1.UInt64.from(item.amount)
+                    : o1js_1.UInt64.MAXINT(),
+            }))
+            : params.list;
+        const map = new WhitelistMap();
+        for (const item of list) {
+            map.insert(o1js_1.Poseidon.hashPacked(o1js_1.PublicKey, item.address), item.amount.toBigInt());
+        }
+        const serializedMap = (0, __1.serializeIndexedMap)(map);
+        const json = {
+            map: serializedMap,
+            whitelist: list.map((item) => ({
+                address: item.address.toBase58(),
+                amount: Number(item.amount.toBigInt()),
+            })),
+        };
+        let attempt = 0;
+        const start = Date.now();
+        let hash = await (0, __1.pinJSON)({
+            data: json,
+            name,
+            keyvalues,
+            auth,
+        });
+        while (!hash && attempt < attempts && Date.now() - start < timeout) {
+            attempt++;
+            await (0, __1.sleep)(5000 * attempt); // handle rate-limits
+            hash = await (0, __1.pinJSON)({
+                data: json,
+                name,
+                keyvalues,
+                auth,
+            });
+        }
+        if (!hash)
+            throw new Error("Failed to pin whitelist");
+        return new Whitelist({
+            root: map.root,
+            storage: __1.Storage.fromString(hash),
+        });
+    }
+}
+exports.Whitelist = Whitelist;

package/lib/ts/src/mina/transactions/{accont.d.ts → account.d.ts}

@@ -1,4 +1,4 @@
 import { PublicKey, Field } from "o1js";
 export declare function accountExists(address: string | PublicKey, tokenId?: Field): Promise<boolean>;
-export declare function accountBalance(address: string | PublicKey, tokenId?: Field): Promise<number | undefined>;
+export declare function tokenBalance(address: string | PublicKey, tokenId?: Field): Promise<number | undefined>;
 export declare function checkAddress(address: string | undefined): Promise<boolean>;

package/lib/ts/src/mina/transactions/{accont.js → account.js}

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.accountExists = accountExists;
-exports.accountBalance = accountBalance;
+exports.tokenBalance = tokenBalance;
 exports.checkAddress = checkAddress;
 const __1 = require("..");
 const o1js_1 = require("o1js");
@@ -15,7 +15,7 @@ async function accountExists(address, tokenId) {
         return false;
     }
 }
-async function accountBalance(address, tokenId) {
+async function tokenBalance(address, tokenId) {
     try {
         const publicKey = typeof address === "string" ? o1js_1.PublicKey.fromBase58(address) : address;
         await (0, __1.fetchMinaAccount)({ publicKey, tokenId, force: false });

package/lib/ts/src/mina/transactions/index.d.ts

@@ -5,3 +5,4 @@ export * from "./chain";
 export * from "./blockberry";
 export * from "./tiny-contract";
 export * from "./send";
+export * from "./account";

package/lib/ts/src/mina/transactions/index.js

@@ -21,3 +21,4 @@ __exportStar(require("./chain"), exports);
 __exportStar(require("./blockberry"), exports);
 __exportStar(require("./tiny-contract"), exports);
 __exportStar(require("./send"), exports);
+__exportStar(require("./account"), exports);

package/lib/ts/src/mina/transactions/send.d.ts

@@ -1,12 +1,24 @@
 import { Mina } from "o1js";
 import { blockchain } from "../../cloud";
+/**
+ * The function `sendTx` sends a transaction, checks account updates, and waits for
+ * confirmation on the blockchain.
+ * @param params The parameters object
+ * @param params.tx The transaction to send
+ * @param params.description A description of the transaction
+ * @param params.verbose Whether to log verbose information
+ * @param params.wait Whether to wait for the transaction to be included in a block
+ * @param params.chain The blockchain to send the transaction on
+ * @returns The `sendTx` function returns a `Mina.IncludedTransaction`, `Mina.PendingTransaction`,
+ * `Mina.RejectedTransaction`, or `undefined` if there was an error during the process.
+ */
 export declare function sendTx(params: {
     tx: Mina.Transaction<false, true> | Mina.Transaction<true, true>;
     description?: string;
     verbose?: boolean;
     wait?: boolean;
     chain?: blockchain;
-}): Promise<Mina.PendingTransaction | Mina.RejectedTransaction | Mina.IncludedTransaction | undefined>;
+}): Promise<Mina.IncludedTransaction | Mina.PendingTransaction | Mina.RejectedTransaction | undefined>;
 export declare function getTxStatusFast(params: {
     hash: string;
     chain?: blockchain;

package/lib/ts/src/mina/transactions/send.js

@@ -5,6 +5,18 @@ exports.getTxStatusFast = getTxStatusFast;
 const o1js_1 = require("o1js");
 const cloud_1 = require("../../cloud");
 const __1 = require("..");
+/**
+ * The function `sendTx` sends a transaction, checks account updates, and waits for
+ * confirmation on the blockchain.
+ * @param params The parameters object
+ * @param params.tx The transaction to send
+ * @param params.description A description of the transaction
+ * @param params.verbose Whether to log verbose information
+ * @param params.wait Whether to wait for the transaction to be included in a block
+ * @param params.chain The blockchain to send the transaction on
+ * @returns The `sendTx` function returns a `Mina.IncludedTransaction`, `Mina.PendingTransaction`,
+ * `Mina.RejectedTransaction`, or `undefined` if there was an error during the process.
+ */
 async function sendTx(params) {
     const { tx, description = "", verbose = true, wait = true, chain = (0, __1.getCurrentNetwork)().network.chainId, } = params;
     // flatten accountUpdates
@@ -53,7 +65,7 @@ async function sendTx(params) {
             }
             else {
                 console.error(`${description} tx NOT sent: hash: ${txSent?.hash} status: ${txSent?.status}`, txSent.errors);
-                return undefined;
+                return txSent;
             }
         }
         if (txSent === undefined)

package/lib/ts/src/mina/utils/indexed-map.d.ts

@@ -11,6 +11,8 @@ export interface IndexedMapSerialized {
 export declare function loadIndexedMerkleMap(params: {
     url: string;
     type: ReturnType<typeof IndexedMerkleMap>;
+    timeout?: number;
+    attempts?: number;
 }): Promise<import("o1js/dist/node/lib/provable/merkle-tree-indexed").IndexedMerkleMapBase>;
 export declare function saveIndexedMerkleMap(params: {
     map: IndexedMerkleMap;

package/lib/ts/src/mina/utils/indexed-map.js

@@ -10,12 +10,22 @@ const cloud_1 = require("../../cloud");
 const pinata_1 = require("../storage/pinata");
 const { IndexedMerkleMap } = o1js_1.Experimental;
 async function loadIndexedMerkleMap(params) {
-    const { url, type } = params;
-    const response = await fetch(url);
+    const { url, type, timeout = 60000, attempts = 5 } = params;
+    let attempt = 0;
+    const start = Date.now();
+    let response = await fetch(url);
+    while (!response.ok && attempt < attempts && Date.now() - start < timeout) {
+        attempt++;
+        await (0, cloud_1.sleep)(5000 * attempt); // handle rate limiting
+        response = await fetch(url);
+    }
     if (!response.ok) {
         throw new Error("Failed to fetch IndexedMerkleMap");
     }
-    const serializedIndexedMap = (await response.json());
+    const json = await response.json();
+    const serializedIndexedMap = json.map;
+    if (!serializedIndexedMap)
+        throw new Error("wrong IndexedMerkleMap json format");
     const map = deserializeIndexedMerkleMapInternal({
         serializedIndexedMap,
         type,
@@ -29,7 +39,7 @@ async function saveIndexedMerkleMap(params) {
     const { map, name = "indexed-map", keyvalues, auth } = params;
     const serialized = serializeIndexedMap(map);
     const ipfsHash = await (0, pinata_1.pinJSON)({
-        data: serialized,
+        data: { map: serialized },
         name,
         keyvalues,
         auth,