@settlemint/sdk-js 2.4.0 → 2.4.1-main1923abdd

package/dist/settlemint.js

@@ -1,3 +1,4 @@
+/* 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";
@@ -118,7 +119,9 @@ 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));
@@ -173,7 +176,9 @@ 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
@@ -350,7 +355,9 @@ 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;
 	};
 };
@@ -381,15 +388,17 @@ 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;
 }
 
@@ -574,6 +583,26 @@ 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
@@ -642,6 +671,28 @@ 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
@@ -794,6 +845,26 @@ 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
@@ -849,6 +920,28 @@ 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
@@ -953,6 +1046,26 @@ 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
@@ -1023,6 +1136,28 @@ 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
@@ -1131,6 +1266,26 @@ 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
@@ -1191,6 +1346,28 @@ 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
@@ -1283,6 +1460,26 @@ 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
@@ -1320,8 +1517,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(void 0),
-			loadBalancerUniqueName ? loadBalancerRead(gqlClient)(loadBalancerUniqueName) : Promise.resolve(void 0)
+			blockchainNodeUniqueName ? blockchainNodeRead(gqlClient)(blockchainNodeUniqueName) : Promise.resolve(undefined),
+			loadBalancerUniqueName ? loadBalancerRead(gqlClient)(loadBalancerUniqueName) : Promise.resolve(undefined)
 		]);
 		const { createInsights: insights } = await gqlClient.request(createInsights, {
 			...otherArgs,
@@ -1343,6 +1540,28 @@ 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
@@ -1431,6 +1650,26 @@ 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
@@ -1485,6 +1724,28 @@ 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
@@ -1573,6 +1834,26 @@ 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
@@ -1627,6 +1908,28 @@ 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
@@ -1749,6 +2052,26 @@ 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
@@ -1802,9 +2125,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(void 0),
-			loadBalancerUniqueName ? loadBalancerRead(gqlClient)(loadBalancerUniqueName) : Promise.resolve(void 0),
-			storageUniqueName ? storageRead(gqlClient)(storageUniqueName) : Promise.resolve(void 0)
+			blockchainNodeUniqueName ? blockchainNodeRead(gqlClient)(blockchainNodeUniqueName) : Promise.resolve(undefined),
+			loadBalancerUniqueName ? loadBalancerRead(gqlClient)(loadBalancerUniqueName) : Promise.resolve(undefined),
+			storageUniqueName ? storageRead(gqlClient)(storageUniqueName) : Promise.resolve(undefined)
 		]);
 		const { createMiddleware: middleware } = await gqlClient.request(createMiddleware, {
 			...otherArgs,
@@ -1827,6 +2150,28 @@ 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
@@ -1991,6 +2336,26 @@ 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
@@ -2028,7 +2393,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) : void 0;
+		const relayerKey = relayerKeyUniqueName ? await privatekeyRead(gqlClient)(relayerKeyUniqueName) : undefined;
 		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);
@@ -2056,6 +2421,28 @@ 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
@@ -2093,7 +2480,9 @@ 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();
@@ -2106,7 +2495,9 @@ 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);
 }
@@ -2139,8 +2530,13 @@ 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("")
@@ -2180,57 +2576,75 @@ function createSettleMintClient(options) {
 			read: blockchainNetworkRead(gqlClient),
 			create: blockchainNetworkCreate(gqlClient),
 			delete: blockchainNetworkDelete(gqlClient),
-			restart: blockchainNetworkRestart(gqlClient)
+			restart: blockchainNetworkRestart(gqlClient),
+			pause: blockchainNetworkPause(gqlClient),
+			resume: blockchainNetworkResume(gqlClient)
 		},
 		blockchainNode: {
 			list: blockchainNodeList(gqlClient),
 			read: blockchainNodeRead(gqlClient),
 			create: blockchainNodeCreate(gqlClient),
-			restart: blockchainNodeRestart(gqlClient)
+			restart: blockchainNodeRestart(gqlClient),
+			pause: blockchainNodePause(gqlClient),
+			resume: blockchainNodeResume(gqlClient)
 		},
 		loadBalancer: {
 			list: loadBalancerList(gqlClient),
 			read: loadBalancerRead(gqlClient),
 			create: loadBalancerCreate(gqlClient),
-			restart: loadBalancerRestart(gqlClient)
+			restart: loadBalancerRestart(gqlClient),
+			pause: loadBalancerPause(gqlClient),
+			resume: loadBalancerResume(gqlClient)
 		},
 		middleware: {
 			list: middlewareList(gqlClient),
 			read: middlewareRead(gqlClient),
 			graphSubgraphs: graphMiddlewareSubgraphs(gqlClient),
 			create: middlewareCreate(gqlClient),
-			restart: middlewareRestart(gqlClient)
+			restart: middlewareRestart(gqlClient),
+			pause: middlewarePause(gqlClient),
+			resume: middlewareResume(gqlClient)
 		},
 		integrationTool: {
 			list: integrationToolList(gqlClient),
 			read: integrationToolRead(gqlClient),
 			create: integrationToolCreate(gqlClient),
-			restart: integrationToolRestart(gqlClient)
+			restart: integrationToolRestart(gqlClient),
+			pause: integrationToolPause(gqlClient),
+			resume: integrationToolResume(gqlClient)
 		},
 		storage: {
 			list: storageList(gqlClient),
 			read: storageRead(gqlClient),
 			create: storageCreate(gqlClient),
-			restart: storageRestart(gqlClient)
+			restart: storageRestart(gqlClient),
+			pause: storagePause(gqlClient),
+			resume: storageResume(gqlClient)
 		},
 		privateKey: {
 			list: privateKeyList(gqlClient),
 			read: privatekeyRead(gqlClient),
 			create: privateKeyCreate(gqlClient),
-			restart: privateKeyRestart(gqlClient)
+			restart: privateKeyRestart(gqlClient),
+			pause: privateKeyPause(gqlClient),
+			resume: privateKeyResume(gqlClient)
 		},
 		insights: {
 			list: insightsList(gqlClient),
 			read: insightsRead(gqlClient),
 			create: insightsCreate(gqlClient),
-			restart: insightsRestart(gqlClient)
+			restart: insightsRestart(gqlClient),
+			pause: insightsPause(gqlClient),
+			resume: insightsResume(gqlClient)
 		},
 		customDeployment: {
 			list: customdeploymentList(gqlClient),
 			read: customdeploymentRead(gqlClient),
 			create: customdeploymentCreate(gqlClient),
 			update: customdeploymentUpdate(gqlClient),
-			restart: customDeploymentRestart(gqlClient)
+			restart: customDeploymentRestart(gqlClient),
+			pause: customDeploymentPause(gqlClient),
+			resume: customDeploymentResume(gqlClient)
 		},
 		foundry: { env: getEnv(gqlClient) },
 		applicationAccessToken: { create: applicationAccessTokenCreate(gqlClient) },