@imtbl/sdk 1.33.0 → 1.34.0-alpha

package/dist/index.cjs

@@ -34,6 +34,7 @@ var solidity = require('@ethersproject/solidity');
 var routerSdk = require('@uniswap/router-sdk');
 var units = require('@ethersproject/units');
 var bignumber = require('@ethersproject/bignumber');
+var MessageValidator = require('sns-validator');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -183,7 +184,7 @@ const flattenProperties$1 = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION$1 = '1.33.0';
+const SDK_VERSION$1 = '1.34.0-alpha';
 const getFrameParentDomain$1 = () => {
     if (isNode$1()) {
         return '';
@@ -14210,7 +14211,7 @@ class MultiRollupApiClients {
 }
 
 // eslint-disable-next-line @typescript-eslint/naming-convention
-const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.33.0' };
+const defaultHeaders$2 = { 'x-sdk-version': 'ts-immutable-sdk-1.34.0-alpha' };
 const createConfig$1 = ({ basePath, headers, }) => {
     if (!basePath.trim()) {
         throw Error('basePath can not be empty');
@@ -14282,7 +14283,7 @@ class APIError extends Error {
 
 /* eslint-disable implicit-arrow-linebreak */
 const defaultHeaders$1 = {
-    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.33.0',
+    sdkVersion: 'ts-immutable-sdk-multi-rollup-api-client-1.34.0-alpha',
 };
 /**
  * createAPIConfiguration to create a custom Configuration
@@ -14756,7 +14757,7 @@ var blockchain_data = /*#__PURE__*/Object.freeze({
 /* eslint-disable @typescript-eslint/naming-convention */
 class ApiConfiguration extends index$2.Configuration {
 }
-const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.33.0' };
+const defaultHeaders = { 'x-sdk-version': 'ts-immutable-sdk-1.34.0-alpha' };
 /**
  * @dev use createImmutableXConfiguration instead
  */
@@ -14795,7 +14796,7 @@ const createImmutableXConfiguration = ({ basePath, chainID, coreContractAddress,
     chainID,
     coreContractAddress,
     registrationContractAddress,
-    sdkVersion: 'ts-immutable-sdk-1.33.0',
+    sdkVersion: 'ts-immutable-sdk-1.34.0-alpha',
     baseConfig,
 });
 const production = ({ baseConfig }) => createImmutableXConfiguration({
@@ -23617,12 +23618,12 @@ function assertOptions$1(options, schema, allowUnknown) {
   }
 }
 
-var validator$1 = {
+var validator$2 = {
   assertOptions: assertOptions$1,
   validators: validators$1$1
 };
 
-const validators$2 = validator$1.validators;
+const validators$2 = validator$2.validators;
 
 /**
  * Create a new instance of Axios
@@ -23663,7 +23664,7 @@ let Axios$2 = class Axios {
     const {transitional, paramsSerializer, headers} = config;
 
     if (transitional !== undefined) {
-      validator$1.assertOptions(transitional, {
+      validator$2.assertOptions(transitional, {
         silentJSONParsing: validators$2.transitional(validators$2.boolean),
         forcedJSONParsing: validators$2.transitional(validators$2.boolean),
         clarifyTimeoutError: validators$2.transitional(validators$2.boolean)
@@ -23676,7 +23677,7 @@ let Axios$2 = class Axios {
           serialize: paramsSerializer
         };
       } else {
-        validator$1.assertOptions(paramsSerializer, {
+        validator$2.assertOptions(paramsSerializer, {
           encode: validators$2.function,
           serialize: validators$2.function
         }, true);
@@ -32269,12 +32270,12 @@ function assertOptions(options, schema, allowUnknown) {
   }
 }
 
-var validator = {
+var validator$1 = {
   assertOptions,
   validators: validators$1
 };
 
-const validators = validator.validators;
+const validators = validator$1.validators;
 
 /**
  * Create a new instance of Axios
@@ -32315,7 +32316,7 @@ class Axios {
     const {transitional, paramsSerializer, headers} = config;
 
     if (transitional !== undefined) {
-      validator.assertOptions(transitional, {
+      validator$1.assertOptions(transitional, {
         silentJSONParsing: validators.transitional(validators.boolean),
         forcedJSONParsing: validators.transitional(validators.boolean),
         clarifyTimeoutError: validators.transitional(validators.boolean)
@@ -32328,7 +32329,7 @@ class Axios {
           serialize: paramsSerializer
         };
       } else {
-        validator.assertOptions(paramsSerializer, {
+        validator$1.assertOptions(paramsSerializer, {
           encode: validators.function,
           serialize: validators.function
         }, true);
@@ -57957,7 +57958,7 @@ const flattenProperties = (properties) => {
 };
 
 // WARNING: DO NOT CHANGE THE STRING BELOW. IT GETS REPLACED AT BUILD TIME.
-const SDK_VERSION = '1.33.0';
+const SDK_VERSION = '1.34.0-alpha';
 const getFrameParentDomain = () => {
     if (isNode()) {
         return '';
@@ -63179,7 +63180,7 @@ const IMMUTABLE_ZKVEM_GAS_OVERRIDES = {
     maxPriorityFeePerGas: ethers.BigNumber.from(10e9),
 };
 
-const SDK_VERSION_MARKER = '1.33.0';
+const SDK_VERSION_MARKER = '1.34.0-alpha';
 // This SDK version is replaced by the `yarn build` command ran on the root level
 const globalPackageVersion = () => SDK_VERSION_MARKER;
 
@@ -68709,9 +68710,323 @@ var x = /*#__PURE__*/Object.freeze({
     sandbox: sandbox
 });
 
+const validator = new MessageValidator();
+const allowedTopicArnPrefix = {
+    [Environment$1.PRODUCTION]: 'arn:aws:sns:us-east-2:362750628221:',
+    [Environment$1.SANDBOX]: 'arn:aws:sns:us-east-2:783421985614:'
+};
+const init = async (body, env, handlers) => {
+    const msg = await new Promise((resolve, reject) => {
+        validator.validate(body, (err, message) => {
+            if (err) {
+                return reject(err);
+            }
+            // check for topic arn prefix
+            if (!msg.TopicArn.startsWith(allowedTopicArnPrefix[env])) {
+                throw new Error('Invalid topic arn');
+            }
+            if (message?.Type === 'SubscriptionConfirmation') {
+                fetch(message.SubscribeURL).then(() => {
+                    resolve(message);
+                }).catch((e) => {
+                    reject(e);
+                });
+            }
+            return resolve(message);
+        });
+    });
+    if (msg.Type === 'Notification') {
+        const event = JSON.parse(msg.Message);
+        switch (event.event_name) {
+            case 'imtbl_zkevm_mint_request_updated':
+                await handlers.zkevmMintRequestUpdated(event);
+                break;
+            default:
+                if (handlers.others) {
+                    await handlers.others(event);
+                }
+                break;
+        }
+    }
+};
+
+var webhook = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    init: init
+});
+
+/* eslint-disable no-console */
+/* eslint-disable global-require */
+let optionalPackage = null;
+let pgClient = null;
+try {
+    optionalPackage = require('pg');
+    pgClient = new optionalPackage.Pool({
+        user: process.env.PG_USER || 'postgres',
+        host: process.env.PG_HOST || 'localhost',
+        database: process.env.PG_DB_NAME || 'nullus',
+        password: process.env.PG_PASSWORD || 'postgres',
+        port: parseInt(process.env.PG_PORT || '5432', 10) || 5432,
+    });
+}
+catch (error) {
+    console.error('pg is not installed. Please install it by running `npm install pg`');
+    optionalPackage = null;
+}
+const client = pgClient;
+
+const mintingPersistence = {
+    recordMint: async (request) => {
+        const r = await client.query(`
+      INSERT INTO im_assets (asset_id, contract_address, owner_address, metadata) 
+      VALUES ($1, $2, $3, $4) ON CONFLICT (asset_id) DO NOTHING;
+      `, [request.asset_id, request.contract_address, request.owner_address, request.metadata]);
+        if (r.rowCount === 0) {
+            throw new Error('Duplicated mint');
+        }
+    },
+    getNextBatchForSubmission: async (limit) => {
+        const res = await client.query(`
+      UPDATE im_assets SET minting_status = 'submitting' WHERE minting_status IS NULL and id in (
+          select id from im_assets where minting_status is null limit $1 for update skip locked
+      ) returning *;
+    `, [limit]);
+        return res.rows;
+    },
+    updateMintingStatusToSubmitted: async (ids) => {
+        await client.query(`
+              UPDATE im_assets SET minting_status = $2 WHERE id = ANY($1);
+            `, [ids, 'submitted']);
+    },
+    syncMintingStatus: async (submittedMintRequest) => {
+        // doing a upsert just in case the row has not been created yet
+        await client.query(`
+      INSERT INTO im_assets (
+        asset_id, 
+        contract_address, 
+        owner_address, 
+        token_id, 
+        minting_status, 
+        metadata_id, 
+        last_imtbl_zkevm_mint_request_updated_id, 
+        error
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8) ON CONFLICT (asset_id, contract_address)
+      DO UPDATE SET 
+        owner_address = $3,
+        token_id = $4,
+        minting_status = $5,
+        metadata_id = $6,
+        last_imtbl_zkevm_mint_request_updated_id = $7,
+        error = $8
+      where (
+        im_assets.last_imtbl_zkevm_mint_request_updated_id < $7 OR 
+        im_assets.last_imtbl_zkevm_mint_request_updated_id is null
+      );
+      `, [
+            submittedMintRequest.assetId,
+            submittedMintRequest.contractAddress,
+            submittedMintRequest.ownerAddress,
+            submittedMintRequest.tokenId,
+            submittedMintRequest.status,
+            submittedMintRequest.metadataId,
+            submittedMintRequest.imtblZkevmMintRequestUpdatedId,
+            submittedMintRequest.error
+        ]);
+    },
+    markAsConflict: async (assetIds, contractAddress) => {
+        await client.query(`
+      UPDATE im_assets 
+      SET minting_status = 'conflicting' 
+      WHERE asset_id = ANY($1) 
+        AND contract_address = $2;
+            `, [assetIds, contractAddress]);
+    },
+    resetMintingStatus: async (ids) => {
+        await client.query(`
+            UPDATE im_assets SET minting_status = null WHERE id = ANY($1) and contract_address = $2;
+            `, [ids]);
+    },
+    markForRetry: async (ids) => {
+        await client.query(`
+      UPDATE im_assets 
+      SET minting_status = null, tried_count = tried_count + 1 WHERE id = ANY($1);
+      `, [ids]);
+    },
+    updateMintingStatusToSubmissionFailed: async (ids) => {
+        await client.query(`
+      UPDATE im_assets SET minting_status = 'submission_failed' WHERE id = ANY($1);
+    `, [ids]);
+    },
+    getMintingRequest: async (contractAddress, referenceId) => {
+        const res = await client.query(`
+      SELECT * FROM im_assets WHERE contract_address = $1 and asset_id = $2;
+    `, [contractAddress, referenceId]);
+        return res.rows[0];
+    }
+};
+
+// TODO: expose metrics
+//       - submitting status count, conflicting status count
+//       - failed events count
+const recordMint = async (mintingPersistence, mintRequest) => {
+    mintingPersistence.recordMint(mintRequest);
+};
+const defaultMintingDelay = 1000;
+// This function can be called in different node process and will run in parallel to mint assets.
+// Each process will NOT mint the same asset.
+// Monitor your database to see if parallel processes are saturating the database CPU and triggering excessive vacuuming.
+// default batch size will be treated as 100 when it exceeds 100 because minting API has a limit of 100 assets per request.
+const submitMintingRequests = async (mintingPersistence, blockchainDataSDKClient, { defaultBatchSize = 1000, chainName = 'imtbl-zkevm-testnet', maxNumberOfTries = 3, }, logger = console) => {
+    let mintingResponse;
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+        await new Promise((resolve) => {
+            setTimeout(resolve, defaultMintingDelay);
+        });
+        let batchSize = Math.min(mintingResponse
+            ? parseInt(mintingResponse.imx_remaining_mint_requests, 10)
+            : defaultBatchSize, defaultBatchSize);
+        if (batchSize === 0
+            && mintingResponse
+            && new Date(mintingResponse.imx_mint_requests_limit_reset) > new Date()) {
+            logger.info(`minting limit reached, waiting for reset at ${mintingResponse?.imx_mint_requests_limit_reset}`);
+            continue;
+        }
+        if (batchSize === 0) {
+            logger.info(`minting limit has been reset, use default batch size: ${defaultBatchSize}`);
+            mintingResponse = undefined;
+            batchSize = defaultBatchSize;
+        }
+        // get mints to be submitted
+        const pendingMints = await mintingPersistence.getNextBatchForSubmission(batchSize);
+        if (pendingMints.length === 0) {
+            logger.info('no assets to mint');
+            continue;
+        }
+        // chunk assets by every 100 assets. every chunk should all be for the same contract address.
+        const chunkedAssets = pendingMints.sort((a, b) => (a.contract_address > b.contract_address ? 1 : -1)).reduce((acc, row) => {
+            if (acc.length === 0) {
+                return [{ contractAddress: row.contract_address, assets: [row] }];
+            }
+            const lastBatch = acc[acc.length - 1];
+            if (lastBatch.contractAddress === row.contract_address && lastBatch.assets.length < 100) {
+                return [...acc.slice(0, -1), { ...lastBatch, assets: [...lastBatch.assets, row] }];
+            }
+            return [...acc, { contractAddress: row.contract_address, assets: [row] }];
+        }, []);
+        // submit minting request for each contract address in parallel
+        const mintingResults = await Promise.allSettled(chunkedAssets.map(async ({ contractAddress, assets }) => {
+            const mintingRequest = {
+                chainName,
+                contractAddress,
+                createMintRequestRequest: {
+                    assets: assets.map((row) => ({
+                        reference_id: row.asset_id,
+                        owner_address: row.owner_address,
+                        metadata: row.metadata,
+                    })),
+                },
+            };
+            try {
+                const response = await blockchainDataSDKClient.createMintRequest(mintingRequest);
+                logger.info(`mintingResponse: ${JSON.stringify(response, null, 2)}`);
+                // update minting status to submitted
+                await mintingPersistence.updateMintingStatusToSubmitted(assets.map(({ id }) => id));
+                return response;
+            }
+            catch (e) {
+                logger.error(e);
+                if (e.code === 'CONFLICT_ERROR'
+                    && e.details?.id === 'reference_id') {
+                    try {
+                        // mark the assets as conflicting, so that we don't send them again.
+                        await mintingPersistence.markAsConflict(e.details.values, contractAddress);
+                        // remove non conflicting assets status so that they can be retried.
+                        await mintingPersistence.resetMintingStatus(assets
+                            .map(({ id }) => id)
+                            .filter((id) => !e.details.values.includes(id)));
+                    }
+                    catch (e2) {
+                        logger.error(e2);
+                    }
+                }
+                else {
+                    // separate assets into "need to be retied" and "exceeded max number of tries."
+                    const { assetsToRetry, assetsExceededMaxNumberOfTries } = assets.reduce((acc, { tried_count = 0, id }) => {
+                        if (tried_count < maxNumberOfTries) {
+                            acc.assetsToRetry.push(id);
+                        }
+                        else {
+                            acc.assetsExceededMaxNumberOfTries.push(id);
+                        }
+                        return acc;
+                    }, {
+                        assetsToRetry: [],
+                        assetsExceededMaxNumberOfTries: [],
+                    });
+                    // remove all assets status so that they can be retried.
+                    await mintingPersistence.markForRetry(assetsToRetry);
+                    // mark assets that have exceeded the max number of tries as submission_failed
+                    await mintingPersistence.updateMintingStatusToSubmissionFailed(assetsExceededMaxNumberOfTries);
+                }
+                return e;
+            }
+        }));
+        mintingResponse = mintingResults
+            .reverse()
+            .find((r) => r.status === 'fulfilled')?.value;
+    }
+};
+const processMint = async (mintingPersistence, event, logger = console) => {
+    if (event.event_name !== 'imtbl_zkevm_mint_request_updated') {
+        logger.info(`${event.event_name} is not imtbl_zkevm_mint_request_updated, skip.`);
+        return;
+    }
+    const referenceId = event.data.reference_id;
+    if (!referenceId) {
+        throw new Error('reference_id not found in webhook event');
+    }
+    const contractAddress = event.data.contract_address;
+    if (!contractAddress) {
+        throw new Error('contract_address not found in webhook event');
+    }
+    if (event.data.status === 'failed') {
+        logger.error(`mint failed: ${JSON.stringify(event.data, null, 2)}`);
+    }
+    const mintReq = await mintingPersistence.getMintingRequest(contractAddress, referenceId);
+    if (!mintReq) {
+        logger.info(`minting request not found in the database, ${JSON.stringify(event.data)}`);
+    }
+    const ownerAddress = mintReq?.wallet_address || event.data.owner_address;
+    if (!ownerAddress) {
+        logger.error('owner_address missing');
+        throw new Error('owner_address missing');
+    }
+    await mintingPersistence.syncMintingStatus({
+        tokenId: event.data.token_id,
+        status: event.data.status,
+        assetId: referenceId,
+        contractAddress,
+        ownerAddress,
+        metadataId: event.data.metadata_id,
+        imtblZkevmMintRequestUpdatedId: event.event_id,
+        error: event.data.error ? JSON.stringify(event.data.error) : null,
+    });
+};
+
+var minting_backend = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    mintingPersistencePg: mintingPersistence,
+    processMint: processMint,
+    recordMint: recordMint,
+    submitMintingRequests: submitMintingRequests
+});
+
 exports.blockchainData = blockchain_data;
 exports.checkout = checkout;
 exports.config = config;
+exports.mintingBackend = minting_backend;
 exports.orderbook = orderbook;
 exports.passport = passport;
+exports.webhook = webhook;
 exports.x = x;

package/dist/index.d.ts

@@ -7841,7 +7841,7 @@ interface MintUser$1 {
  * @export
  * @interface MintRequest
  */
-interface MintRequest$1 {
+interface MintRequest$2 {
     /**
      * Signature from authorised minter
      * @type {string}
@@ -10820,7 +10820,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 +21026,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 +21184,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 {
 }
@@ -29056,7 +29056,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;
@@ -29199,7 +29198,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,
@@ -29263,4 +29262,105 @@ 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: (id: string[]) => Promise<void>;
+    updateMintingStatusToSubmissionFailed: (id: 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>;
+}
+
+declare const mintingPersistence: 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>;
+
+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 {
+    mintingPersistence as mintingPersistencePg,
+    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 };