@settlemint/sdk-js 2.4.0-prd61aaa2c → 2.4.0-prda9b71e5

package/dist/settlemint.js

@@ -1,4 +1,3 @@
-/* SettleMint SDK - Main Package */
 import { fetchWithRetry } from "@settlemint/sdk-utils/http";
 import { ensureServer } from "@settlemint/sdk-utils/runtime";
 import { AccessTokenSchema, IdSchema, LOCAL_INSTANCE, STANDALONE_INSTANCE, UrlSchema, validate } from "@settlemint/sdk-utils/validation";
@@ -119,9 +118,7 @@ const workspaceList = (gqlClient) => {
 		const { workspaces } = await gqlClient.request(getWorkspacesAndApplications);
 		const allWorkspaces = workspaces.reduce((acc, workspace) => {
 			acc.push(workspace);
-			if (workspace.childWorkspaces) {
-				acc.push(...workspace.childWorkspaces);
-			}
+			if (workspace.childWorkspaces) acc.push(...workspace.childWorkspaces);
 			return acc;
 		}, []);
 		return allWorkspaces.sort((a, b) => a.name.localeCompare(b.name));
@@ -176,9 +173,7 @@ const workspaceDelete = (gqlClient) => {
 const workspaceAddCredits = (gqlClient) => {
 	return async (workspaceId, amount) => {
 		const id = validate(IdSchema, workspaceId);
-		if (amount <= 0) {
-			throw new Error("Credit amount must be a positive number");
-		}
+		if (amount <= 0) throw new Error("Credit amount must be a positive number");
 		const { addCredits: result } = await gqlClient.request(addCredits, {
 			workspaceId: id,
 			amount
@@ -355,9 +350,7 @@ const applicationAccessTokenCreate = (gqlClient) => {
 			...otherArgs,
 			applicationId: application.id
 		});
-		if (!applicationAccessToken.token) {
-			throw new Error("Failed to create application access token");
-		}
+		if (!applicationAccessToken.token) throw new Error("Failed to create application access token");
 		return applicationAccessToken.token;
 	};
 };
@@ -388,17 +381,15 @@ function setClusterServiceDefaults(args) {
 */
 function setNetworkDefaults(args) {
 	const clusterServiceArgs = setClusterServiceDefaults(args);
-	if (args.consensusAlgorithm === "BESU_QBFT") {
-		return {
-			...clusterServiceArgs,
-			chainId: args.chainId ?? 46040,
-			contractSizeLimit: args.contractSizeLimit ?? 2147483647,
-			evmStackSize: args.evmStackSize ?? 2048,
-			gasLimit: args.gasLimit ?? "9007199254740991",
-			gasPrice: args.gasPrice ?? 0,
-			secondsPerBlock: args.secondsPerBlock ?? 2
-		};
-	}
+	if (args.consensusAlgorithm === "BESU_QBFT") return {
+		...clusterServiceArgs,
+		chainId: args.chainId ?? 46040,
+		contractSizeLimit: args.contractSizeLimit ?? 2147483647,
+		evmStackSize: args.evmStackSize ?? 2048,
+		gasLimit: args.gasLimit ?? "9007199254740991",
+		gasPrice: args.gasPrice ?? 0,
+		secondsPerBlock: args.secondsPerBlock ?? 2
+	};
 	return clusterServiceArgs;
 }
 
@@ -583,26 +574,6 @@ const restartBlockchainNetwork = graphql(`
   }
   `, [BlockchainNetworkFragment]);
 /**
-* Mutation to pause a blockchain network.
-*/
-const pauseBlockchainNetwork = graphql(`
-  mutation PauseBlockchainNetwork($uniqueName: String!) {
-    pauseBlockchainNetworkByUniqueName(uniqueName: $uniqueName) {
-      ...BlockchainNetwork
-    }
-  }
-  `, [BlockchainNetworkFragment]);
-/**
-* Mutation to resume a blockchain network.
-*/
-const resumeBlockchainNetwork = graphql(`
-  mutation ResumeBlockchainNetwork($uniqueName: String!) {
-    resumeBlockchainNetworkByUniqueName(uniqueName: $uniqueName) {
-      ...BlockchainNetwork
-    }
-  }
-  `, [BlockchainNetworkFragment]);
-/**
 * Creates a function to list blockchain networks for a given application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -671,28 +642,6 @@ const blockchainNetworkRestart = (gqlClient) => async (blockchainNetworkUniqueNa
 	const { restartBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(restartBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
 	return blockchainNetwork;
 };
-/**
-* Creates a function to pause a blockchain network.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses a network by unique name
-* @throws If the network cannot be found or the pause fails
-*/
-const blockchainNetworkPause = (gqlClient) => async (blockchainNetworkUniqueName) => {
-	const { pauseBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(pauseBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
-	return blockchainNetwork;
-};
-/**
-* Creates a function to resume a blockchain network.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes a network by unique name
-* @throws If the network cannot be found or the resume fails
-*/
-const blockchainNetworkResume = (gqlClient) => async (blockchainNetworkUniqueName) => {
-	const { resumeBlockchainNetworkByUniqueName: blockchainNetwork } = await gqlClient.request(resumeBlockchainNetwork, { uniqueName: blockchainNetworkUniqueName });
-	return blockchainNetwork;
-};
 
 //#endregion
 //#region src/graphql/blockchain-node.ts
@@ -845,26 +794,6 @@ const restartBlockchainNode = graphql(`
     }
   `, [BlockchainNodeFragment]);
 /**
-* Mutation to pause a blockchain node.
-*/
-const pauseBlockchainNode = graphql(`
-    mutation PauseBlockchainNode($uniqueName: String!) {
-      pauseBlockchainNodeByUniqueName(uniqueName: $uniqueName) {
-        ...BlockchainNode
-      }
-    }
-  `, [BlockchainNodeFragment]);
-/**
-* Mutation to resume a blockchain node.
-*/
-const resumeBlockchainNode = graphql(`
-    mutation ResumeBlockchainNode($uniqueName: String!) {
-      resumeBlockchainNodeByUniqueName(uniqueName: $uniqueName) {
-        ...BlockchainNode
-      }
-    }
-  `, [BlockchainNodeFragment]);
-/**
 * Creates a function to list blockchain nodes for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -920,28 +849,6 @@ const blockchainNodeRestart = (gqlClient) => async (blockchainNodeUniqueName) =>
 	const { restartBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(restartBlockchainNode, { uniqueName: blockchainNodeUniqueName });
 	return blockchainNode;
 };
-/**
-* Creates a function to pause a blockchain node.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses a blockchain node by unique name
-* @throws If the blockchain node cannot be found or the pause fails
-*/
-const blockchainNodePause = (gqlClient) => async (blockchainNodeUniqueName) => {
-	const { pauseBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(pauseBlockchainNode, { uniqueName: blockchainNodeUniqueName });
-	return blockchainNode;
-};
-/**
-* Creates a function to resume a blockchain node.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes a blockchain node by unique name
-* @throws If the blockchain node cannot be found or the resume fails
-*/
-const blockchainNodeResume = (gqlClient) => async (blockchainNodeUniqueName) => {
-	const { resumeBlockchainNodeByUniqueName: blockchainNode } = await gqlClient.request(resumeBlockchainNode, { uniqueName: blockchainNodeUniqueName });
-	return blockchainNode;
-};
 
 //#endregion
 //#region src/graphql/custom-deployment.ts
@@ -1046,26 +953,6 @@ const restartCustomDeployment = graphql(`
     }
   `, [CustomDeploymentFragment]);
 /**
-* Mutation to pause a custom deployment.
-*/
-const pauseCustomDeployment = graphql(`
-    mutation PauseCustomDeployment($uniqueName: String!) {
-      pauseCustomDeploymentByUniqueName(uniqueName: $uniqueName) {
-        ...CustomDeployment
-      }
-    }
-  `, [CustomDeploymentFragment]);
-/**
-* Mutation to resume a custom deployment.
-*/
-const resumeCustomDeployment = graphql(`
-    mutation ResumeCustomDeployment($uniqueName: String!) {
-      resumeCustomDeploymentByUniqueName(uniqueName: $uniqueName) {
-        ...CustomDeployment
-      }
-    }
-  `, [CustomDeploymentFragment]);
-/**
 * Creates a function to list custom deployments for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1136,28 +1023,6 @@ const customDeploymentRestart = (gqlClient) => async (customDeploymentUniqueName
 	const { restartCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(restartCustomDeployment, { uniqueName: customDeploymentUniqueName });
 	return customDeployment;
 };
-/**
-* Creates a function to pause a custom deployment.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses a custom deployment by unique name
-* @throws If the custom deployment cannot be found or the pause fails
-*/
-const customDeploymentPause = (gqlClient) => async (customDeploymentUniqueName) => {
-	const { pauseCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(pauseCustomDeployment, { uniqueName: customDeploymentUniqueName });
-	return customDeployment;
-};
-/**
-* Creates a function to resume a custom deployment.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes a custom deployment by unique name
-* @throws If the custom deployment cannot be found or the resume fails
-*/
-const customDeploymentResume = (gqlClient) => async (customDeploymentUniqueName) => {
-	const { resumeCustomDeploymentByUniqueName: customDeployment } = await gqlClient.request(resumeCustomDeployment, { uniqueName: customDeploymentUniqueName });
-	return customDeployment;
-};
 
 //#endregion
 //#region src/graphql/foundry.ts
@@ -1266,26 +1131,6 @@ const restartLoadBalancer = graphql(`
     }
   `, [LoadBalancerFragment]);
 /**
-* Mutation to pause a load balancer.
-*/
-const pauseLoadBalancer = graphql(`
-    mutation PauseLoadBalancer($uniqueName: String!) {
-      pauseLoadBalancerByUniqueName(uniqueName: $uniqueName) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
-/**
-* Mutation to resume a load balancer.
-*/
-const resumeLoadBalancer = graphql(`
-    mutation ResumeLoadBalancer($uniqueName: String!) {
-      resumeLoadBalancerByUniqueName(uniqueName: $uniqueName) {
-        ...LoadBalancer
-      }
-    }
-  `, [LoadBalancerFragment]);
-/**
 * Creates a function to fetch a specific load balancer.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1346,28 +1191,6 @@ const loadBalancerRestart = (gqlClient) => async (loadBalancerUniqueName) => {
 	const { restartLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(restartLoadBalancer, { uniqueName: loadBalancerUniqueName });
 	return loadBalancer;
 };
-/**
-* Creates a function to pause a load balancer.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses a load balancer
-* @throws If the load balancer cannot be paused or the request fails
-*/
-const loadBalancerPause = (gqlClient) => async (loadBalancerUniqueName) => {
-	const { pauseLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(pauseLoadBalancer, { uniqueName: loadBalancerUniqueName });
-	return loadBalancer;
-};
-/**
-* Creates a function to resume a load balancer.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes a load balancer
-* @throws If the load balancer cannot be resumed or the request fails
-*/
-const loadBalancerResume = (gqlClient) => async (loadBalancerUniqueName) => {
-	const { resumeLoadBalancerByUniqueName: loadBalancer } = await gqlClient.request(resumeLoadBalancer, { uniqueName: loadBalancerUniqueName });
-	return loadBalancer;
-};
 
 //#endregion
 //#region src/graphql/insights.ts
@@ -1460,26 +1283,6 @@ const restartInsights = graphql(`
     }
   `, [InsightsFragment]);
 /**
-* Mutation to pause insights.
-*/
-const pauseInsights = graphql(`
-    mutation PauseInsights($uniqueName: String!) {
-      pauseInsightsByUniqueName(uniqueName: $uniqueName) {
-        ...Insights
-      }
-    }
-  `, [InsightsFragment]);
-/**
-* Mutation to resume insights.
-*/
-const resumeInsights = graphql(`
-    mutation ResumeInsights($uniqueName: String!) {
-      resumeInsightsByUniqueName(uniqueName: $uniqueName) {
-        ...Insights
-      }
-    }
-  `, [InsightsFragment]);
-/**
 * Creates a function to list insights for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1517,8 +1320,8 @@ const insightsCreate = (gqlClient) => {
 		const { applicationUniqueName, blockchainNodeUniqueName, loadBalancerUniqueName,...otherArgs } = args;
 		const [application, blockchainNode, loadBalancer] = await Promise.all([
 			applicationRead(gqlClient)(applicationUniqueName),
-			blockchainNodeUniqueName ? blockchainNodeRead(gqlClient)(blockchainNodeUniqueName) : Promise.resolve(undefined),
-			loadBalancerUniqueName ? loadBalancerRead(gqlClient)(loadBalancerUniqueName) : Promise.resolve(undefined)
+			blockchainNodeUniqueName ? blockchainNodeRead(gqlClient)(blockchainNodeUniqueName) : Promise.resolve(void 0),
+			loadBalancerUniqueName ? loadBalancerRead(gqlClient)(loadBalancerUniqueName) : Promise.resolve(void 0)
 		]);
 		const { createInsights: insights } = await gqlClient.request(createInsights, {
 			...otherArgs,
@@ -1540,28 +1343,6 @@ const insightsRestart = (gqlClient) => async (insightsUniqueName) => {
 	const { restartInsightsByUniqueName: insights } = await gqlClient.request(restartInsights, { uniqueName: insightsUniqueName });
 	return insights;
 };
-/**
-* Creates a function to pause insights.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses insights by unique name
-* @throws If the insights cannot be found or the pause fails
-*/
-const insightsPause = (gqlClient) => async (insightsUniqueName) => {
-	const { pauseInsightsByUniqueName: insights } = await gqlClient.request(pauseInsights, { uniqueName: insightsUniqueName });
-	return insights;
-};
-/**
-* Creates a function to resume insights.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes insights by unique name
-* @throws If the insights cannot be found or the resume fails
-*/
-const insightsResume = (gqlClient) => async (insightsUniqueName) => {
-	const { resumeInsightsByUniqueName: insights } = await gqlClient.request(resumeInsights, { uniqueName: insightsUniqueName });
-	return insights;
-};
 
 //#endregion
 //#region src/graphql/integration-tool.ts
@@ -1650,26 +1431,6 @@ const restartIntegrationTool = graphql(`
     }
   `, [IntegrationFragment]);
 /**
-* Mutation to pause an integration.
-*/
-const pauseIntegrationTool = graphql(`
-    mutation PauseIntegrationTool($uniqueName: String!) {
-      pauseIntegrationByUniqueName(uniqueName: $uniqueName) {
-        ...Integration
-      }
-    }
-  `, [IntegrationFragment]);
-/**
-* Mutation to resume an integration.
-*/
-const resumeIntegrationTool = graphql(`
-    mutation ResumeIntegrationTool($uniqueName: String!) {
-      resumeIntegrationByUniqueName(uniqueName: $uniqueName) {
-        ...Integration
-      }
-    }
-  `, [IntegrationFragment]);
-/**
 * Creates a function to list integration tools for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1724,28 +1485,6 @@ const integrationToolRestart = (gqlClient) => async (integrationUniqueName) => {
 	const { restartIntegrationByUniqueName: integration } = await gqlClient.request(restartIntegrationTool, { uniqueName: integrationUniqueName });
 	return integration;
 };
-/**
-* Creates a function to pause an integration tool.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses integration tool by unique name
-* @throws If the integration tool cannot be found or the pause fails
-*/
-const integrationToolPause = (gqlClient) => async (integrationUniqueName) => {
-	const { pauseIntegrationByUniqueName: integration } = await gqlClient.request(pauseIntegrationTool, { uniqueName: integrationUniqueName });
-	return integration;
-};
-/**
-* Creates a function to resume an integration tool.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes integration tool by unique name
-* @throws If the integration tool cannot be found or the resume fails
-*/
-const integrationToolResume = (gqlClient) => async (integrationUniqueName) => {
-	const { resumeIntegrationByUniqueName: integration } = await gqlClient.request(resumeIntegrationTool, { uniqueName: integrationUniqueName });
-	return integration;
-};
 
 //#endregion
 //#region src/graphql/storage.ts
@@ -1834,26 +1573,6 @@ const restartStorage = graphql(`
     }
   `, [StorageFragment]);
 /**
-* Mutation to pause a storage.
-*/
-const pauseStorage = graphql(`
-    mutation PauseStorage($uniqueName: String!) {
-      pauseStorageByUniqueName(uniqueName: $uniqueName) {
-        ...Storage
-      }
-    }
-  `, [StorageFragment]);
-/**
-* Mutation to resume a storage.
-*/
-const resumeStorage = graphql(`
-    mutation ResumeStorage($uniqueName: String!) {
-      resumeStorageByUniqueName(uniqueName: $uniqueName) {
-        ...Storage
-      }
-    }
-  `, [StorageFragment]);
-/**
 * Creates a function to list storages for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -1908,28 +1627,6 @@ const storageRestart = (gqlClient) => async (storageUniqueName) => {
 	const { restartStorageByUniqueName: storage } = await gqlClient.request(restartStorage, { uniqueName: storageUniqueName });
 	return storage;
 };
-/**
-* Creates a function to pause a storage.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses storage by unique name
-* @throws If the storage cannot be found or the pause fails
-*/
-const storagePause = (gqlClient) => async (storageUniqueName) => {
-	const { pauseStorageByUniqueName: storage } = await gqlClient.request(pauseStorage, { uniqueName: storageUniqueName });
-	return storage;
-};
-/**
-* Creates a function to resume a storage.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes storage by unique name
-* @throws If the storage cannot be found or the resume fails
-*/
-const storageResume = (gqlClient) => async (storageUniqueName) => {
-	const { resumeStorageByUniqueName: storage } = await gqlClient.request(resumeStorage, { uniqueName: storageUniqueName });
-	return storage;
-};
 
 //#endregion
 //#region src/graphql/middleware.ts
@@ -2052,26 +1749,6 @@ const restartMiddleware = graphql(`
     }
   `, [MiddlewareFragment]);
 /**
-* Mutation to pause a middleware.
-*/
-const pauseMiddleware = graphql(`
-    mutation PauseMiddleware($uniqueName: String!) {
-      pauseMiddlewareByUniqueName(uniqueName: $uniqueName) {
-        ...Middleware
-      }
-    }
-  `, [MiddlewareFragment]);
-/**
-* Mutation to resume a middleware.
-*/
-const resumeMiddleware = graphql(`
-    mutation ResumeMiddleware($uniqueName: String!) {
-      resumeMiddlewareByUniqueName(uniqueName: $uniqueName) {
-        ...Middleware
-      }
-    }
-  `, [MiddlewareFragment]);
-/**
 * Creates a function to list middlewares for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -2125,9 +1802,9 @@ const middlewareCreate = (gqlClient) => {
 		const { applicationUniqueName, blockchainNodeUniqueName, loadBalancerUniqueName, storageUniqueName,...otherArgs } = args;
 		const [application, blockchainNode, loadBalancer, storage] = await Promise.all([
 			applicationRead(gqlClient)(applicationUniqueName),
-			blockchainNodeUniqueName ? blockchainNodeRead(gqlClient)(blockchainNodeUniqueName) : Promise.resolve(undefined),
-			loadBalancerUniqueName ? loadBalancerRead(gqlClient)(loadBalancerUniqueName) : Promise.resolve(undefined),
-			storageUniqueName ? storageRead(gqlClient)(storageUniqueName) : Promise.resolve(undefined)
+			blockchainNodeUniqueName ? blockchainNodeRead(gqlClient)(blockchainNodeUniqueName) : Promise.resolve(void 0),
+			loadBalancerUniqueName ? loadBalancerRead(gqlClient)(loadBalancerUniqueName) : Promise.resolve(void 0),
+			storageUniqueName ? storageRead(gqlClient)(storageUniqueName) : Promise.resolve(void 0)
 		]);
 		const { createMiddleware: middleware } = await gqlClient.request(createMiddleware, {
 			...otherArgs,
@@ -2150,28 +1827,6 @@ const middlewareRestart = (gqlClient) => async (middlewareUniqueName) => {
 	const { restartMiddlewareByUniqueName: middleware } = await gqlClient.request(restartMiddleware, { uniqueName: middlewareUniqueName });
 	return middleware;
 };
-/**
-* Creates a function to pause a middleware.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses middleware by unique name
-* @throws If the middleware cannot be found or the pause fails
-*/
-const middlewarePause = (gqlClient) => async (middlewareUniqueName) => {
-	const { pauseMiddlewareByUniqueName: middleware } = await gqlClient.request(pauseMiddleware, { uniqueName: middlewareUniqueName });
-	return middleware;
-};
-/**
-* Creates a function to resume a middleware.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes middleware by unique name
-* @throws If the middleware cannot be found or the resume fails
-*/
-const middlewareResume = (gqlClient) => async (middlewareUniqueName) => {
-	const { resumeMiddlewareByUniqueName: middleware } = await gqlClient.request(resumeMiddleware, { uniqueName: middlewareUniqueName });
-	return middleware;
-};
 
 //#endregion
 //#region src/graphql/platform.ts
@@ -2336,26 +1991,6 @@ const restartPrivateKey = graphql(`
     }
   `, [PrivateKeyFragment]);
 /**
-* Mutation to pause a private key.
-*/
-const pausePrivateKey = graphql(`
-    mutation PausePrivateKey($uniqueName: String!) {
-      pausePrivateKeyByUniqueName(uniqueName: $uniqueName) {
-        ...PrivateKey
-      }
-    }
-  `, [PrivateKeyFragment]);
-/**
-* Mutation to resume a private key.
-*/
-const resumePrivateKey = graphql(`
-    mutation ResumePrivateKey($uniqueName: String!) {
-      resumePrivateKeyByUniqueName(uniqueName: $uniqueName) {
-        ...PrivateKey
-      }
-    }
-  `, [PrivateKeyFragment]);
-/**
 * Creates a function to list private keys for an application.
 *
 * @param gqlClient - The GraphQL client instance
@@ -2393,7 +2028,7 @@ const privateKeyCreate = (gqlClient) => {
 		const { applicationUniqueName, blockchainNodeUniqueNames, relayerKeyUniqueName,...otherArgs } = args;
 		const application = await applicationRead(gqlClient)(applicationUniqueName);
 		const blockchainNodes = blockchainNodeUniqueNames ? await Promise.all(blockchainNodeUniqueNames.map((uniqueName) => blockchainNodeRead(gqlClient)(uniqueName))) : [];
-		const relayerKey = relayerKeyUniqueName ? await privatekeyRead(gqlClient)(relayerKeyUniqueName) : undefined;
+		const relayerKey = relayerKeyUniqueName ? await privatekeyRead(gqlClient)(relayerKeyUniqueName) : void 0;
 		const platformConfig = await getPlatformConfig(gqlClient)();
 		const defaultProvider = platformConfig.deploymentEngineTargets.find((target) => !target.disabled && target.clusters.some((cluster) => !cluster.disabled));
 		const defaultRegion = defaultProvider?.clusters.find((cluster) => !cluster.disabled);
@@ -2421,28 +2056,6 @@ const privateKeyRestart = (gqlClient) => async (privateKeyUniqueName) => {
 	const { restartPrivateKeyByUniqueName: privateKey } = await gqlClient.request(restartPrivateKey, { uniqueName: privateKeyUniqueName });
 	return privateKey;
 };
-/**
-* Creates a function to pause a private key.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that pauses private key by unique name
-* @throws If the private key cannot be found or the pause fails
-*/
-const privateKeyPause = (gqlClient) => async (privateKeyUniqueName) => {
-	const { pausePrivateKeyByUniqueName: privateKey } = await gqlClient.request(pausePrivateKey, { uniqueName: privateKeyUniqueName });
-	return privateKey;
-};
-/**
-* Creates a function to resume a private key.
-*
-* @param gqlClient - The GraphQL client instance
-* @returns Function that resumes private key by unique name
-* @throws If the private key cannot be found or the resume fails
-*/
-const privateKeyResume = (gqlClient) => async (privateKeyUniqueName) => {
-	const { resumePrivateKeyByUniqueName: privateKey } = await gqlClient.request(resumePrivateKey, { uniqueName: privateKeyUniqueName });
-	return privateKey;
-};
 
 //#endregion
 //#region src/helpers/client-options.schema.ts
@@ -2480,9 +2093,7 @@ async function getPincodeVerificationChallenges({ userWalletAddress, accessToken
 		}
 	});
 	if (!response.ok) {
-		if (response.status === 404) {
-			throw new Error(`No user wallet found with address '${userWalletAddress}' for node '${nodeId}'`);
-		}
+		if (response.status === 404) throw new Error(`No user wallet found with address '${userWalletAddress}' for node '${nodeId}'`);
 		throw new Error("Failed to get verification challenge");
 	}
 	const verificationChallenges = await response.json();
@@ -2495,9 +2106,7 @@ async function getPincodeVerificationChallenges({ userWalletAddress, accessToken
 * @returns The pincode verification challenge response.
 */
 function getPincodeVerificationChallengeResponse({ verificationChallenge, pincode }) {
-	if (!verificationChallenge?.challenge?.secret || !verificationChallenge?.challenge?.salt) {
-		throw new Error("Could not authenticate pin code, invalid challenge format");
-	}
+	if (!verificationChallenge?.challenge?.secret || !verificationChallenge?.challenge?.salt) throw new Error("Could not authenticate pin code, invalid challenge format");
 	const { secret, salt } = verificationChallenge.challenge;
 	return generateResponse(pincode, salt, secret);
 }
@@ -2530,13 +2139,8 @@ function getPincodeVerificationChallengeResponse({ verificationChallenge, pincod
 */
 function createSettleMintClient(options) {
 	ensureServer();
-	if (options.instance === STANDALONE_INSTANCE || options.instance === LOCAL_INSTANCE) {
-		if (options.anonymous) {
-			options.instance = "https://console.settlemint.com";
-		} else {
-			throw new Error("Standalone and local instances cannot connect to the SettleMint platform");
-		}
-	}
+	if (options.instance === STANDALONE_INSTANCE || options.instance === LOCAL_INSTANCE) if (options.anonymous) options.instance = "https://console.settlemint.com";
+	else throw new Error("Standalone and local instances cannot connect to the SettleMint platform");
 	const validatedOptions = options.anonymous ? validate(z.object({
 		...ClientOptionsSchema.shape,
 		accessToken: z.literal("")
@@ -2576,75 +2180,57 @@ function createSettleMintClient(options) {
 			read: blockchainNetworkRead(gqlClient),
 			create: blockchainNetworkCreate(gqlClient),
 			delete: blockchainNetworkDelete(gqlClient),
-			restart: blockchainNetworkRestart(gqlClient),
-			pause: blockchainNetworkPause(gqlClient),
-			resume: blockchainNetworkResume(gqlClient)
+			restart: blockchainNetworkRestart(gqlClient)
 		},
 		blockchainNode: {
 			list: blockchainNodeList(gqlClient),
 			read: blockchainNodeRead(gqlClient),
 			create: blockchainNodeCreate(gqlClient),
-			restart: blockchainNodeRestart(gqlClient),
-			pause: blockchainNodePause(gqlClient),
-			resume: blockchainNodeResume(gqlClient)
+			restart: blockchainNodeRestart(gqlClient)
 		},
 		loadBalancer: {
 			list: loadBalancerList(gqlClient),
 			read: loadBalancerRead(gqlClient),
 			create: loadBalancerCreate(gqlClient),
-			restart: loadBalancerRestart(gqlClient),
-			pause: loadBalancerPause(gqlClient),
-			resume: loadBalancerResume(gqlClient)
+			restart: loadBalancerRestart(gqlClient)
 		},
 		middleware: {
 			list: middlewareList(gqlClient),
 			read: middlewareRead(gqlClient),
 			graphSubgraphs: graphMiddlewareSubgraphs(gqlClient),
 			create: middlewareCreate(gqlClient),
-			restart: middlewareRestart(gqlClient),
-			pause: middlewarePause(gqlClient),
-			resume: middlewareResume(gqlClient)
+			restart: middlewareRestart(gqlClient)
 		},
 		integrationTool: {
 			list: integrationToolList(gqlClient),
 			read: integrationToolRead(gqlClient),
 			create: integrationToolCreate(gqlClient),
-			restart: integrationToolRestart(gqlClient),
-			pause: integrationToolPause(gqlClient),
-			resume: integrationToolResume(gqlClient)
+			restart: integrationToolRestart(gqlClient)
 		},
 		storage: {
 			list: storageList(gqlClient),
 			read: storageRead(gqlClient),
 			create: storageCreate(gqlClient),
-			restart: storageRestart(gqlClient),
-			pause: storagePause(gqlClient),
-			resume: storageResume(gqlClient)
+			restart: storageRestart(gqlClient)
 		},
 		privateKey: {
 			list: privateKeyList(gqlClient),
 			read: privatekeyRead(gqlClient),
 			create: privateKeyCreate(gqlClient),
-			restart: privateKeyRestart(gqlClient),
-			pause: privateKeyPause(gqlClient),
-			resume: privateKeyResume(gqlClient)
+			restart: privateKeyRestart(gqlClient)
 		},
 		insights: {
 			list: insightsList(gqlClient),
 			read: insightsRead(gqlClient),
 			create: insightsCreate(gqlClient),
-			restart: insightsRestart(gqlClient),
-			pause: insightsPause(gqlClient),
-			resume: insightsResume(gqlClient)
+			restart: insightsRestart(gqlClient)
 		},
 		customDeployment: {
 			list: customdeploymentList(gqlClient),
 			read: customdeploymentRead(gqlClient),
 			create: customdeploymentCreate(gqlClient),
 			update: customdeploymentUpdate(gqlClient),
-			restart: customDeploymentRestart(gqlClient),
-			pause: customDeploymentPause(gqlClient),
-			resume: customDeploymentResume(gqlClient)
+			restart: customDeploymentRestart(gqlClient)
 		},
 		foundry: { env: getEnv(gqlClient) },
 		applicationAccessToken: { create: applicationAccessTokenCreate(gqlClient) },