@imtbl/sdk 1.43.3 → 1.43.4

package/dist/json-rpc-provider.d-5c038bd9.d.ts

@@ -0,0 +1,249 @@
+/// <reference types="node" />
+import { A as AccessList, B as BigNumber, a as Block, T as TransactionResponse, b as TransactionReceipt, L as Listener, E as EventType, F as Filter, P as Provider, N as Network, c as Networkish, d as Transaction, e as BlockTag, f as BigNumberish, D as Deferrable, g as TransactionRequest, h as FilterByBlockHash, i as BlockWithTransactions, j as Log, C as ConnectionInfo, S as Signer, k as TypedDataSigner, l as Bytes, m as TypedDataDomain, n as TypedDataField } from './index.d-c4a4c17d.js';
+
+declare type FormatFunc = (value: any) => any;
+declare type FormatFuncs = {
+    [key: string]: FormatFunc;
+};
+declare type Formats = {
+    transaction: FormatFuncs;
+    transactionRequest: FormatFuncs;
+    receipt: FormatFuncs;
+    receiptLog: FormatFuncs;
+    block: FormatFuncs;
+    blockWithTransactions: FormatFuncs;
+    filter: FormatFuncs;
+    filterLog: FormatFuncs;
+};
+declare class Formatter {
+    readonly formats: Formats;
+    constructor();
+    getDefaultFormats(): Formats;
+    accessList(accessList: Array<any>): AccessList;
+    number(number: any): number;
+    type(number: any): number;
+    bigNumber(value: any): BigNumber;
+    boolean(value: any): boolean;
+    hex(value: any, strict?: boolean): string;
+    data(value: any, strict?: boolean): string;
+    address(value: any): string;
+    callAddress(value: any): string;
+    contractAddress(value: any): string;
+    blockTag(blockTag: any): string;
+    hash(value: any, strict?: boolean): string;
+    difficulty(value: any): number;
+    uint256(value: any): string;
+    _block(value: any, format: any): Block;
+    block(value: any): Block;
+    blockWithTransactions(value: any): Block;
+    transactionRequest(value: any): any;
+    transactionResponse(transaction: any): TransactionResponse;
+    transaction(value: any): any;
+    receiptLog(value: any): any;
+    receipt(value: any): TransactionReceipt;
+    topics(value: any): any;
+    filter(value: any): any;
+    filterLog(value: any): any;
+    static check(format: {
+        [name: string]: FormatFunc;
+    }, object: any): any;
+    static allowNull(format: FormatFunc, nullValue?: any): FormatFunc;
+    static allowFalsish(format: FormatFunc, replaceValue: any): FormatFunc;
+    static arrayOf(format: FormatFunc): FormatFunc;
+}
+
+declare class Event {
+    readonly listener: Listener;
+    readonly once: boolean;
+    readonly tag: string;
+    _lastBlockNumber: number;
+    _inflight: boolean;
+    constructor(tag: string, listener: Listener, once: boolean);
+    get event(): EventType;
+    get type(): string;
+    get hash(): string;
+    get filter(): Filter;
+    pollable(): boolean;
+}
+interface EnsResolver {
+    readonly name: string;
+    readonly address: string;
+    getAddress(coinType?: 60): Promise<null | string>;
+    getContentHash(): Promise<null | string>;
+    getText(key: string): Promise<null | string>;
+}
+interface EnsProvider {
+    resolveName(name: string): Promise<null | string>;
+    lookupAddress(address: string): Promise<null | string>;
+    getResolver(name: string): Promise<null | EnsResolver>;
+}
+interface Avatar {
+    url: string;
+    linkage: Array<{
+        type: string;
+        content: string;
+    }>;
+}
+declare class Resolver implements EnsResolver {
+    readonly provider: BaseProvider;
+    readonly name: string;
+    readonly address: string;
+    readonly _resolvedAddress: null | string;
+    _supportsEip2544: null | Promise<boolean>;
+    constructor(provider: BaseProvider, address: string, name: string, resolvedAddress?: string);
+    supportsWildcard(): Promise<boolean>;
+    _fetch(selector: string, parameters?: string): Promise<null | string>;
+    _fetchBytes(selector: string, parameters?: string): Promise<null | string>;
+    _getAddress(coinType: number, hexBytes: string): string;
+    getAddress(coinType?: number): Promise<string>;
+    getAvatar(): Promise<null | Avatar>;
+    getContentHash(): Promise<string>;
+    getText(key: string): Promise<string>;
+}
+declare class BaseProvider extends Provider implements EnsProvider {
+    _networkPromise: Promise<Network>;
+    _network: Network;
+    _events: Array<Event>;
+    formatter: Formatter;
+    _emitted: {
+        [eventName: string]: number | "pending";
+    };
+    _pollingInterval: number;
+    _poller: NodeJS.Timer;
+    _bootstrapPoll: NodeJS.Timer;
+    _lastBlockNumber: number;
+    _maxFilterBlockRange: number;
+    _fastBlockNumber: number;
+    _fastBlockNumberPromise: Promise<number>;
+    _fastQueryDate: number;
+    _maxInternalBlockNumber: number;
+    _internalBlockNumber: Promise<{
+        blockNumber: number;
+        reqTime: number;
+        respTime: number;
+    }>;
+    readonly anyNetwork: boolean;
+    disableCcipRead: boolean;
+    /**
+     *  ready
+     *
+     *  A Promise<Network> that resolves only once the provider is ready.
+     *
+     *  Sub-classes that call the super with a network without a chainId
+     *  MUST set this. Standard named networks have a known chainId.
+     *
+     */
+    constructor(network: Networkish | Promise<Network>);
+    _ready(): Promise<Network>;
+    get ready(): Promise<Network>;
+    static getFormatter(): Formatter;
+    static getNetwork(network: Networkish): Network;
+    ccipReadFetch(tx: Transaction, calldata: string, urls: Array<string>): Promise<null | string>;
+    _getInternalBlockNumber(maxAge: number): Promise<number>;
+    poll(): Promise<void>;
+    resetEventsBlock(blockNumber: number): void;
+    get network(): Network;
+    detectNetwork(): Promise<Network>;
+    getNetwork(): Promise<Network>;
+    get blockNumber(): number;
+    get polling(): boolean;
+    set polling(value: boolean);
+    get pollingInterval(): number;
+    set pollingInterval(value: number);
+    _getFastBlockNumber(): Promise<number>;
+    _setFastBlockNumber(blockNumber: number): void;
+    waitForTransaction(transactionHash: string, confirmations?: number, timeout?: number): Promise<TransactionReceipt>;
+    _waitForTransaction(transactionHash: string, confirmations: number, timeout: number, replaceable: {
+        data: string;
+        from: string;
+        nonce: number;
+        to: string;
+        value: BigNumber;
+        startBlock: number;
+    }): Promise<TransactionReceipt>;
+    getBlockNumber(): Promise<number>;
+    getGasPrice(): Promise<BigNumber>;
+    getBalance(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<BigNumber>;
+    getTransactionCount(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<number>;
+    getCode(addressOrName: string | Promise<string>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    getStorageAt(addressOrName: string | Promise<string>, position: BigNumberish | Promise<BigNumberish>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    _wrapTransaction(tx: Transaction, hash?: string, startBlock?: number): TransactionResponse;
+    sendTransaction(signedTransaction: string | Promise<string>): Promise<TransactionResponse>;
+    _getTransactionRequest(transaction: Deferrable<TransactionRequest>): Promise<Transaction>;
+    _getFilter(filter: Filter | FilterByBlockHash | Promise<Filter | FilterByBlockHash>): Promise<Filter | FilterByBlockHash>;
+    _call(transaction: TransactionRequest, blockTag: BlockTag, attempt: number): Promise<string>;
+    call(transaction: Deferrable<TransactionRequest>, blockTag?: BlockTag | Promise<BlockTag>): Promise<string>;
+    estimateGas(transaction: Deferrable<TransactionRequest>): Promise<BigNumber>;
+    _getAddress(addressOrName: string | Promise<string>): Promise<string>;
+    _getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>, includeTransactions?: boolean): Promise<Block | BlockWithTransactions>;
+    getBlock(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<Block>;
+    getBlockWithTransactions(blockHashOrBlockTag: BlockTag | string | Promise<BlockTag | string>): Promise<BlockWithTransactions>;
+    getTransaction(transactionHash: string | Promise<string>): Promise<TransactionResponse>;
+    getTransactionReceipt(transactionHash: string | Promise<string>): Promise<TransactionReceipt>;
+    getLogs(filter: Filter | FilterByBlockHash | Promise<Filter | FilterByBlockHash>): Promise<Array<Log>>;
+    getEtherPrice(): Promise<number>;
+    _getBlockTag(blockTag: BlockTag | Promise<BlockTag>): Promise<BlockTag>;
+    getResolver(name: string): Promise<null | Resolver>;
+    _getResolver(name: string, operation?: string): Promise<string>;
+    resolveName(name: string | Promise<string>): Promise<null | string>;
+    lookupAddress(address: string | Promise<string>): Promise<null | string>;
+    getAvatar(nameOrAddress: string): Promise<null | string>;
+    perform(method: string, params: any): Promise<any>;
+    _startEvent(event: Event): void;
+    _stopEvent(event: Event): void;
+    _addEventListener(eventName: EventType, listener: Listener, once: boolean): this;
+    on(eventName: EventType, listener: Listener): this;
+    once(eventName: EventType, listener: Listener): this;
+    emit(eventName: EventType, ...args: Array<any>): boolean;
+    listenerCount(eventName?: EventType): number;
+    listeners(eventName?: EventType): Array<Listener>;
+    off(eventName: EventType, listener?: Listener): this;
+    removeAllListeners(eventName?: EventType): this;
+}
+
+declare class JsonRpcSigner extends Signer implements TypedDataSigner {
+    readonly provider: JsonRpcProvider;
+    _index: number;
+    _address: string;
+    constructor(constructorGuard: any, provider: JsonRpcProvider, addressOrIndex?: string | number);
+    connect(provider: Provider): JsonRpcSigner;
+    connectUnchecked(): JsonRpcSigner;
+    getAddress(): Promise<string>;
+    sendUncheckedTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    signTransaction(transaction: Deferrable<TransactionRequest>): Promise<string>;
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+    signMessage(message: Bytes | string): Promise<string>;
+    _legacySignMessage(message: Bytes | string): Promise<string>;
+    _signTypedData(domain: TypedDataDomain, types: Record<string, Array<TypedDataField>>, value: Record<string, any>): Promise<string>;
+    unlock(password: string): Promise<boolean>;
+}
+declare class UncheckedJsonRpcSigner extends JsonRpcSigner {
+    sendTransaction(transaction: Deferrable<TransactionRequest>): Promise<TransactionResponse>;
+}
+declare class JsonRpcProvider extends BaseProvider {
+    readonly connection: ConnectionInfo;
+    _pendingFilter: Promise<number>;
+    _nextId: number;
+    _eventLoopCache: Record<string, Promise<any>>;
+    get _cache(): Record<string, Promise<any>>;
+    constructor(url?: ConnectionInfo | string, network?: Networkish);
+    static defaultUrl(): string;
+    detectNetwork(): Promise<Network>;
+    _uncachedDetectNetwork(): Promise<Network>;
+    getSigner(addressOrIndex?: string | number): JsonRpcSigner;
+    getUncheckedSigner(addressOrIndex?: string | number): UncheckedJsonRpcSigner;
+    listAccounts(): Promise<Array<string>>;
+    send(method: string, params: Array<any>): Promise<any>;
+    prepareRequest(method: string, params: any): [string, Array<any>];
+    perform(method: string, params: any): Promise<any>;
+    _startEvent(event: Event): void;
+    _startPending(): void;
+    _stopEvent(event: Event): void;
+    static hexlifyTransaction(transaction: TransactionRequest, allowExtra?: {
+        [key: string]: boolean;
+    }): {
+        [key: string]: string | AccessList;
+    };
+}
+
+export { JsonRpcProvider as J };

package/dist/minting_backend-04aef147.js

@@ -0,0 +1 @@
+import{B as t}from"./index-96599707.js";import{h as e}from"./index-3951cdf0.js";import{t as s,s as a,b as n}from"./index-14aad537.js";const i="minting_backend_sdk",d=t=>{try{s(i,"error",{name:t.name,message:t.message})}catch{}},r=(t,e)=>{try{s(i,"error",{name:t.name,message:t.message,origin:e})}catch{}},o=t=>((()=>{try{s(i,"initializePersistencePG")}catch{}})(),{recordMint:async e=>{if(0===(await t.query("\n        INSERT INTO im_assets (asset_id, contract_address, owner_address, metadata, amount, token_id) \n        VALUES ($1, $2, $3, $4, $5, $6) ON CONFLICT (asset_id, contract_address) DO NOTHING;\n        ",[e.asset_id,e.contract_address,e.owner_address,e.metadata,e.amount,e.token_id])).rowCount)throw new Error("Duplicated mint")},getNextBatchForSubmission:async e=>(await t.query("\n      WITH limited_assets AS (\n        SELECT id \n        FROM im_assets \n        WHERE minting_status IS NULL \n        LIMIT $1 \n        FOR UPDATE SKIP LOCKED\n      )\n      UPDATE im_assets \n        SET minting_status = 'submitting' \n      WHERE minting_status IS NULL \n        AND id IN (SELECT id FROM limited_assets)\n      RETURNING *;\n      ",[e])).rows,updateMintingStatusToSubmitted:async e=>{await t.query("\n                UPDATE im_assets SET minting_status = $2 WHERE id = ANY($1);\n              ",[e,"submitted"])},syncMintingStatus:async e=>{await t.query("\n        INSERT INTO im_assets (\n          asset_id, \n          contract_address, \n          owner_address, \n          token_id, \n          minting_status, \n          metadata_id, \n          last_imtbl_zkevm_mint_request_updated_id, \n          error,\n          amount\n        ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9) ON CONFLICT (asset_id, contract_address)\n        DO UPDATE SET \n          owner_address = $3,\n          token_id = $4,\n          minting_status = $5,\n          metadata_id = $6,\n          last_imtbl_zkevm_mint_request_updated_id = $7,\n          error = $8\n        where (\n          im_assets.last_imtbl_zkevm_mint_request_updated_id < $7 OR \n          im_assets.last_imtbl_zkevm_mint_request_updated_id is null\n        );\n        ",[e.assetId,e.contractAddress,e.ownerAddress,e.tokenId,e.status,e.metadataId,e.imtblZkevmMintRequestUpdatedId,e.error,e.amount])},markAsConflict:async(e,s)=>{await t.query("\n        UPDATE im_assets \n        SET minting_status = 'conflicting' \n        WHERE asset_id = ANY($1) \n          AND contract_address = $2;\n              ",[e,s])},resetMintingStatus:async e=>{await t.query("\n              UPDATE im_assets SET minting_status = null WHERE id = ANY($1);\n              ",[e])},markForRetry:async e=>{await t.query("\n        UPDATE im_assets \n        SET minting_status = null, tried_count = tried_count + 1 WHERE id = ANY($1);\n        ",[e])},updateMintingStatusToSubmissionFailed:async e=>{await t.query("\n        UPDATE im_assets SET minting_status = 'submission_failed' WHERE id = ANY($1);\n      ",[e])},getMintingRequest:async(e,s)=>(await t.query("\n        SELECT * FROM im_assets WHERE contract_address = $1 and asset_id = $2;\n      ",[e,s])).rows[0]||null}),m=t=>((()=>{try{s(i,"initializePersistencePrismaSqlite")}catch{}})(),{recordMint:async e=>{if(!await t.imAssets.upsert({where:{im_assets_uindex:{assetId:e.asset_id,contractAddress:e.contract_address}},update:{},create:{assetId:e.asset_id,contractAddress:e.contract_address,ownerAddress:e.owner_address,metadata:JSON.stringify(e.metadata),amount:e.amount||null,tokenId:e.token_id||null}}))throw new Error("Duplicated mint")},getNextBatchForSubmission:async e=>{const s=(await t.imAssets.findMany({where:{mintingStatus:null},take:e})).map((t=>t.id));await t.imAssets.updateMany({where:{id:{in:s}},data:{mintingStatus:"submitting"}});return(await t.imAssets.findMany({where:{id:{in:s}}})).map((t=>({id:t.id,contract_address:t.contractAddress,wallet_address:t.ownerAddress,asset_id:t.assetId,metadata:t.metadata?JSON.parse(t.metadata):null,owner_address:t.ownerAddress,tried_count:t.triedCount,amount:t.amount||null,token_id:t.tokenId||null})))},updateMintingStatusToSubmitted:async e=>{await t.imAssets.updateMany({where:{id:{in:e}},data:{mintingStatus:"submitted"}})},syncMintingStatus:async e=>{const s=await t.imAssets.findUnique({where:{im_assets_uindex:{assetId:e.assetId,contractAddress:e.contractAddress}}});s&&(null===s.lastImtblZkevmMintRequestUpdatedId||s.lastImtblZkevmMintRequestUpdatedId<e.imtblZkevmMintRequestUpdatedId)?await t.imAssets.update({where:{im_assets_uindex:{assetId:e.assetId,contractAddress:e.contractAddress}},data:{ownerAddress:e.ownerAddress,tokenId:e.tokenId,mintingStatus:e.status,metadataId:e.metadataId,lastImtblZkevmMintRequestUpdatedId:e.imtblZkevmMintRequestUpdatedId,error:e.error,amount:e.amount||null}}):s||await t.imAssets.create({data:{assetId:e.assetId,contractAddress:e.contractAddress,ownerAddress:e.ownerAddress,tokenId:e.tokenId,mintingStatus:e.status,metadataId:e.metadataId,lastImtblZkevmMintRequestUpdatedId:e.imtblZkevmMintRequestUpdatedId,error:e.error,amount:e.amount||null}})},updateMintingStatusToSubmissionFailed:async e=>{await t.imAssets.updateMany({where:{id:{in:e}},data:{mintingStatus:"submission_failed"}})},markAsConflict:async(e,s)=>{await t.imAssets.updateMany({where:{assetId:{in:e},contractAddress:s},data:{mintingStatus:"conflicting"}})},resetMintingStatus:async e=>{await t.imAssets.updateMany({where:{id:{in:e}},data:{mintingStatus:null}})},markForRetry:async e=>{const s=await t.imAssets.findMany({where:{id:{in:e}},select:{id:!0,triedCount:!0}});for(const e of s)await t.imAssets.update({where:{id:e.id},data:{mintingStatus:null,triedCount:e.triedCount+1}})},getMintingRequest:async(e,s)=>{const a=await t.imAssets.findFirst({where:{contractAddress:e,assetId:s}});return a?{asset_id:a.assetId,contract_address:a.contractAddress,id:a.id,metadata:a.metadata?JSON.parse(a.metadata):null,owner_address:a.ownerAddress,tried_count:a.triedCount,wallet_address:a.ownerAddress,amount:a.amount||null}:null}}),c=async(t,e)=>{(()=>{try{s(i,"recordMint")}catch{}})(),t.recordMint(e)},u=async(t,e,{defaultBatchSize:a=1e3,chainName:n="imtbl-zkevm-testnet",maxNumberOfTries:r=3},o=console,m=1/0)=>{let c;(()=>{try{s(i,"submitMintingRequests")}catch{}})();let u=0;for(;u++<m;){await new Promise((t=>{setTimeout(t,1e3)}));let s=Math.min(c?.imx_remaining_mint_requests?parseInt(c.imx_remaining_mint_requests,10):a,a);if(0===s&&c&&new Date(c.imx_mint_requests_limit_reset)>new Date){o.info(`minting limit reached, waiting for reset at ${c?.imx_mint_requests_limit_reset}`);continue}0===s&&(o.info(`minting limit has been reset, use default batch size: ${a}`),c=void 0,s=a);const i=await t.getNextBatchForSubmission(s);if(0===i.length){o.info("no assets to mint");continue}const m=i.sort(((t,e)=>t.contract_address>e.contract_address?1:-1)).reduce(((t,e)=>{if(0===t.length)return[{contractAddress:e.contract_address,assets:[e]}];const s=t[t.length-1];return s.contractAddress===e.contract_address&&s.assets.length<100?[...t.slice(0,-1),{...s,assets:[...s.assets,e]}]:[...t,{contractAddress:e.contract_address,assets:[e]}]}),[]),u=await Promise.allSettled(m.map((async({contractAddress:s,assets:a})=>{const i={chainName:n,contractAddress:s,createMintRequestRequest:{assets:a.map((t=>({reference_id:t.asset_id,owner_address:t.owner_address,metadata:t.metadata,token_id:t.token_id,amount:t.amount?`${t.amount}`:null})))}};try{const s=await e.createMintRequest(i);return o.info(`mintingResponse: ${JSON.stringify(s,null,2)}`),await t.updateMintingStatusToSubmitted(a.map((({id:t})=>t))),s}catch(e){if(o.error(e),d(e),"CONFLICT_ERROR"===e.code&&"reference_id"===e.details?.id)try{await t.markAsConflict(e.details.values,s),await t.resetMintingStatus(a.map((({id:t})=>t)).filter((t=>!e.details.values.includes(t))))}catch(t){o.error(t),d(e)}else{const{assetsToRetry:e,assetsExceededMaxNumberOfTries:s}=a.reduce(((t,{tried_count:e=0,id:s})=>(e<r?t.assetsToRetry.push(s):t.assetsExceededMaxNumberOfTries.push(s),t)),{assetsToRetry:[],assetsExceededMaxNumberOfTries:[]});await t.markForRetry(e),await t.updateMintingStatusToSubmissionFailed(s)}return e}})));c=u.reverse().find((t=>"fulfilled"===t.status))?.value}},_=async(t,e,a=console)=>{if((()=>{try{s(i,"processMint")}catch{}})(),"imtbl_zkevm_mint_request_updated"!==e.event_name)return void a.info(`${e.event_name} is not imtbl_zkevm_mint_request_updated, skip.`);const n=e.data.reference_id;if(!n)throw new Error("reference_id not found in webhook event");const d=e.data.contract_address;if(!d)throw new Error("contract_address not found in webhook event");"failed"===e.data.status&&a.error(`mint failed: ${JSON.stringify(e.data,null,2)}`);const r=await t.getMintingRequest(d,n);r||a.info(`minting request not found in the database, ${JSON.stringify(e.data)}`);const o=r?.wallet_address||e.data.owner_address;if(!o)throw a.error("owner_address missing"),new Error("owner_address missing");await t.syncMintingStatus({tokenId:e.data.token_id,status:e.data.status,assetId:n,contractAddress:d,ownerAddress:o,metadataId:e.data.metadata_id,imtblZkevmMintRequestUpdatedId:e.event_id,error:e.data.error?JSON.stringify(e.data.error):null,amount:e.data.amount||null})},l={zkevmMintRequestUpdated:async t=>{}};class w{baseConfig;persistence;blockchainDataClient;logger;constructor(e){this.baseConfig=e.baseConfig,this.persistence=e.persistence,this.logger=e.logger||console,this.blockchainDataClient=new t({baseConfig:e.baseConfig}),a(this.baseConfig.environment),this.baseConfig.publishableKey&&n(this.baseConfig.publishableKey)}async recordMint(t){await c(this.persistence,t)}async submitMintingRequests(t){await u(this.persistence,this.blockchainDataClient,t)}async processMint(t,s=l){await e(t,this.baseConfig.environment,{zkevmMintRequestUpdated:async t=>{await _(this.persistence,t,this.logger),s.zkevmMintRequestUpdated&&s.zkevmMintRequestUpdated(t)}})}}if("undefined"!=typeof process&&process.on)try{process.on("uncaughtExceptionMonitor",r)}catch{}var g=Object.freeze({__proto__:null,MintingBackendModule:w,mintingPersistencePg:o,mintingPersistencePrismaSqlite:m,processMint:_,recordMint:c,submitMintingRequests:u});export{w as M,o as a,m as b,g as m,_ as p,c as r,u as s};

package/dist/minting_backend.d-4754ffee.d.ts

@@ -0,0 +1,104 @@
+import { M as ModuleConfiguration } from './index.d-f0845744.js';
+import { Z as ZkevmMintRequestUpdated } from './event-types.d-42520276.js';
+import { B as BlockchainData } from './blockchain-data.d-1634b683.js';
+import { Pool } from 'pg';
+
+type CreateMintRequest = {
+    contract_address: string;
+    asset_id: string;
+    metadata: any;
+    owner_address: string;
+    amount?: number;
+    token_id?: string;
+};
+type MintRequest = {
+    id: string;
+    contract_address: string;
+    wallet_address: string;
+    asset_id: string;
+    metadata: any;
+    owner_address: string;
+    tried_count: number;
+    amount?: number;
+    token_id?: string;
+};
+type SubmittedMintRequest = {
+    tokenId: string | null;
+    status: string;
+    assetId: string;
+    contractAddress: string;
+    ownerAddress: string;
+    metadataId: string;
+    imtblZkevmMintRequestUpdatedId: string;
+    error: any | null;
+    amount: number | null;
+};
+interface MintingPersistence {
+    recordMint: (request: CreateMintRequest) => Promise<void>;
+    getNextBatchForSubmission: (limit: number) => Promise<MintRequest[]>;
+    updateMintingStatusToSubmitted: (ids: string[]) => Promise<void>;
+    updateMintingStatusToSubmissionFailed: (ids: string[]) => Promise<void>;
+    syncMintingStatus: (submittedMintRequest: SubmittedMintRequest) => Promise<void>;
+    markAsConflict: (assetIds: string[], contractAddress: string) => Promise<void>;
+    resetMintingStatus: (ids: string[]) => Promise<void>;
+    markForRetry: (ids: string[]) => Promise<void>;
+    getMintingRequest: (contractAddress: string, referenceId: string) => Promise<MintRequest | null>;
+}
+
+declare const mintingPersistence$1: (client: Pool) => MintingPersistence;
+
+declare const mintingPersistence: (client: any) => MintingPersistence;
+
+interface Logger {
+    info: (message: string) => void;
+    error: (message: any) => void;
+}
+
+declare const recordMint: (mintingPersistence: MintingPersistence, mintRequest: CreateMintRequest) => Promise<void>;
+declare const submitMintingRequests: (mintingPersistence: MintingPersistence, blockchainDataSDKClient: BlockchainData, { defaultBatchSize, chainName, maxNumberOfTries, }: {
+    defaultBatchSize?: number | undefined;
+    chainName?: string | undefined;
+    maxNumberOfTries?: number | undefined;
+}, logger?: Logger, maxLoops?: number) => Promise<void>;
+declare const processMint: (mintingPersistence: MintingPersistence, event: ZkevmMintRequestUpdated, logger?: Logger) => Promise<void>;
+
+interface MintingBackendModuleConfiguration extends ModuleConfiguration<undefined> {
+    persistence: MintingPersistence;
+    logger?: Logger;
+}
+declare class MintingBackendModule {
+    private readonly baseConfig;
+    private readonly persistence;
+    private readonly blockchainDataClient;
+    private readonly logger;
+    constructor(config: MintingBackendModuleConfiguration);
+    recordMint(mintRequest: CreateMintRequest): Promise<void>;
+    submitMintingRequests(config: {
+        defaultBatchSize?: number;
+        chainName?: string;
+        maxNumberOfTries?: number;
+    }): Promise<void>;
+    processMint(body: string | Record<string, unknown>, otherHandlers?: {
+        zkevmMintRequestUpdated: (event: ZkevmMintRequestUpdated) => Promise<void>;
+    }): Promise<void>;
+}
+
+type minting_backend_d_MintingBackendModule = MintingBackendModule;
+declare const minting_backend_d_MintingBackendModule: typeof MintingBackendModule;
+type minting_backend_d_MintingBackendModuleConfiguration = MintingBackendModuleConfiguration;
+declare const minting_backend_d_processMint: typeof processMint;
+declare const minting_backend_d_recordMint: typeof recordMint;
+declare const minting_backend_d_submitMintingRequests: typeof submitMintingRequests;
+declare namespace minting_backend_d {
+  export {
+    minting_backend_d_MintingBackendModule as MintingBackendModule,
+    minting_backend_d_MintingBackendModuleConfiguration as MintingBackendModuleConfiguration,
+    mintingPersistence$1 as mintingPersistencePg,
+    mintingPersistence as mintingPersistencePrismaSqlite,
+    minting_backend_d_processMint as processMint,
+    minting_backend_d_recordMint as recordMint,
+    minting_backend_d_submitMintingRequests as submitMintingRequests,
+  };
+}
+
+export { MintingBackendModuleConfiguration as M, mintingPersistence$1 as a, mintingPersistence as b, MintingBackendModule as c, minting_backend_d as m, processMint as p, recordMint as r, submitMintingRequests as s };