@imtbl/sdk 1.36.2 → 1.36.3-alpha.1

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 /// <reference types="node" />
+import { Pool } from 'pg';
+
 declare enum Environment {
     PRODUCTION = "production",
     SANDBOX = "sandbox"
@@ -7841,7 +7843,7 @@ interface MintUser$1 {
  * @export
  * @interface MintRequest
  */
-interface MintRequest$1 {
+interface MintRequest$2 {
     /**
      * Signature from authorised minter
      * @type {string}
@@ -10820,7 +10822,7 @@ interface MintsApiMintTokensRequest$1 {
      * @type {Array<MintRequest>}
      * @memberof MintsApiMintTokens
      */
-    readonly mintTokensRequestV2: Array<MintRequest$1>;
+    readonly mintTokensRequestV2: Array<MintRequest$2>;
 }
 /**
  * MintsApi - object-oriented interface
@@ -21026,7 +21028,7 @@ type UnsignedTransferRequest = TokenAmount & {
 /**
  * Parameter required to Mint tokens
  */
-type UnsignedMintRequest = Omit<MintRequest$1, 'auth_signature'>;
+type UnsignedMintRequest = Omit<MintRequest$2, 'auth_signature'>;
 /**
  * Parameter required to create a Transfer
  */
@@ -21184,7 +21186,7 @@ interface MetadataSchemaRequest extends MetadataSchemaRequest$1 {
 }
 interface MintFee extends MintFee$1 {
 }
-interface MintRequest extends MintRequest$1 {
+interface MintRequest$1 extends MintRequest$2 {
 }
 interface MintTokenDataV2 extends MintTokenDataV2$1 {
 }
@@ -29150,7 +29152,6 @@ declare const x_d_MetadataRefreshesApi: typeof MetadataRefreshesApi;
 type x_d_MetadataSchemaRequest = MetadataSchemaRequest;
 declare const x_d_MetadataSchemaRequestTypeEnum: typeof MetadataSchemaRequestTypeEnum;
 type x_d_MintFee = MintFee;
-type x_d_MintRequest = MintRequest;
 type x_d_MintTokenDataV2 = MintTokenDataV2;
 type x_d_MintTokensResponse = MintTokensResponse;
 type x_d_MintUser = MintUser;
@@ -29293,7 +29294,7 @@ declare namespace x_d {
     x_d_MetadataSchemaRequest as MetadataSchemaRequest,
     x_d_MetadataSchemaRequestTypeEnum as MetadataSchemaRequestTypeEnum,
     x_d_MintFee as MintFee,
-    x_d_MintRequest as MintRequest,
+    MintRequest$1 as MintRequest,
     x_d_MintTokenDataV2 as MintTokenDataV2,
     x_d_MintTokensResponse as MintTokensResponse,
     x_d_MintUser as MintUser,
@@ -29357,4 +29358,135 @@ declare namespace x_d {
   };
 }
 
-export { blockchain_data_d as blockchainData, checkout_d as checkout, config_d as config, orderbook_d as orderbook, passport_d as passport, x_d as x };
+declare const init: (body: string | Record<string, unknown>, env: Environment, handlers: {
+    zkevmMintRequestUpdated: (event: any) => Promise<void>;
+    others?: ((event: any) => Promise<void>) | undefined;
+}) => Promise<void>;
+
+declare const webhook_d_init: typeof init;
+declare namespace webhook_d {
+  export {
+    webhook_d_init as init,
+  };
+}
+
+type CreateMintRequest = {
+    contract_address: string;
+    asset_id: string;
+    metadata: any;
+    owner_address: string;
+};
+type MintRequest = {
+    id: string;
+    contract_address: string;
+    wallet_address: string;
+    asset_id: string;
+    metadata: any;
+    owner_address: string;
+    tried_count: number;
+};
+type SubmittedMintRequest = {
+    tokenId: string | null;
+    status: string;
+    assetId: string;
+    contractAddress: string;
+    ownerAddress: string;
+    metadataId: string;
+    imtblZkevmMintRequestUpdatedId: string;
+    error: any | 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) => Promise<never>;
+type MintRequestEvent = {
+    event_name: string;
+    chain: string;
+    event_id: string;
+    data: {
+        chain: {
+            id: string;
+            name: string;
+        };
+        contract_address: string;
+        owner_address: string;
+        reference_id: string;
+        metadata_id: string;
+        token_id: string | null;
+        status: string;
+        transaction_hash: string | null;
+        activity_id: string | null;
+        error: {
+            code: string;
+            message: string;
+        } | null;
+        created_at: string;
+        updated_at: string;
+    };
+};
+declare const processMint: (mintingPersistence: MintingPersistence, event: MintRequestEvent, 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: MintRequestEvent) => Promise<void>;
+        others: (..._args: any) => 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 { blockchain_data_d as blockchainData, checkout_d as checkout, config_d as config, minting_backend_d as mintingBackend, orderbook_d as orderbook, passport_d as passport, webhook_d as webhook, x_d as x };