feat: implement predicates/scripts CLI deploy

nodemon.config.json

@@ -14,6 +14,7 @@
     "**/out/release/**",
     "apps/demo-typegen/src/contract-types/**",
     "apps/demo-typegen/src/predicate-types/**",
-    "apps/demo-typegen/src/script-types/**"
+    "apps/demo-typegen/src/script-types/**",
+    "packages/fuels/src/cli/commands/deploy/proxy/types/**"
   ]
 }

packages/contract/src/contract-factory.ts

@@ -376,16 +376,21 @@
     return { waitForResult, contractId, waitForTransactionId };
   }
 
   async deployAsBlobTxForScript(configurableConstants: { [name: string]: unknown } = {}): Promise<{
     waitForResult: () => Promise<{
       transactionResult: TransactionResult<TransactionType.Blob>;
       loaderBytecode: string;
     }>;
+    blobId: string;
+    loaderBytecode: Uint8Array;
+    loaderBytecodeHexlified: string;
   }> {
     const account = this.getAccount();
-    if (configurableConstants) {
-      this.setConfigurableConstants(configurableConstants);
-    }
+
+    // TODO: We think that we should not be setting configurable constants here, but rather when we try to call the script.
+    // if (configurableConstants) {
+    //   this.setConfigurableConstants(configurableConstants);
+    // }
 
     // Generate the associated create tx for the loader contract
     const blobId = hash(this.bytecode);
@@ -444,7 +449,12 @@
       return { transactionResult: result, loaderBytecode: hexlify(loaderBytecode) };
     };
 
-    return { waitForResult };
+    return {
+      waitForResult,
+      blobId,
+      loaderBytecode,
+      loaderBytecodeHexlified: hexlify(loaderBytecode),
+    };
   }
 
   /**

packages/fuels/src/cli/commands/deploy/deployScripts.ts

@@ -1,15 +1,10 @@
 import type { WalletUnlocked } from '@fuel-ts/account';
+import type { DeployContractOptions } from '@fuel-ts/contract';
+import { ContractFactory } from '@fuel-ts/contract';
 import { debug, log } from 'console';
+import { readFileSync } from 'fs';
 
-import type { ForcToml } from '../../config/forcUtils';
-import {
-  getClosestForcTomlDir,
-  getBinaryPath,
-  getABIPath,
-  getStorageSlotsPath,
-  getContractName,
-  readForcToml,
-} from '../../config/forcUtils';
+import { getBinaryPath, getABIPath, getContractName } from '../../config/forcUtils';
 import type { FuelsConfig, DeployedScript } from '../../types';
 
 import { createWallet } from './createWallet';
@@ -21,24 +16,23 @@
   wallet: WalletUnlocked,
   binaryPath: string,
   abiPath: string,
-  storageSlotsPath: string,
-  scriptPath: string,
-  tomlContents: ForcToml
+  configurableConstants?: DeployContractOptions['configurableConstants']
 ) {
   debug(`Deploying script for ABI: ${abiPath}`);
 
-  // Implement script deploy
-  await Promise.resolve({
-    wallet,
-    binaryPath,
-    abiPath,
-    storageSlotsPath,
-    scriptPath,
-    tomlContents,
-  });
+  const bytecode = readFileSync(binaryPath);
+  const abi = JSON.parse(readFileSync(abiPath, 'utf-8'));
+  const factory = new ContractFactory(bytecode, abi, wallet);
 
-  // TODO: implement me
-  return 'deployed-blob-id';
+  const { waitForResult, blobId, loaderBytecode, loaderBytecodeHexlified } =
+    await factory.deployAsBlobTxForScript(configurableConstants);
+  await waitForResult();
+
+  return {
+    blobId,
+    loaderBytecode,
+    loaderBytecodeHexlified,
+  };
 }
 
 /**
@@ -51,36 +45,27 @@
 
   log(`Deploying scripts to: ${wallet.provider.url}`);
 
   const scriptsLen = config.scripts.length;
 
   for (let i = 0; i < scriptsLen; i++) {
     const scriptPath = config.scripts[i];
-    const forcTomlPath = getClosestForcTomlDir(scriptPath);
     const binaryPath = getBinaryPath(scriptPath, config);
     const abiPath = getABIPath(scriptPath, config);
-    const storageSlotsPath = getStorageSlotsPath(scriptPath, config);
     const projectName = getContractName(scriptPath);
-    // const scriptName = getContractCamelCase(scriptPath);
-    const tomlContents = readForcToml(forcTomlPath);
 
-    const blobId = await deployScript(
+    const { blobId, loaderBytecode, loaderBytecodeHexlified } = await deployScript(
       wallet,
       binaryPath,
-      abiPath,
-      storageSlotsPath,
-      scriptPath,
-      tomlContents
+      abiPath
     );
 
-    // TODO: implement me
-    const loaderBytecode = `0x${blobId}`;
-
     debug(`Script deployed: ${projectName} - ${blobId}`);
 
     scripts.push({
       path: scriptPath,
       blobId,
       loaderBytecode,
+      loaderBytecodeHexlified,
     });
   }
 

packages/fuels/src/cli/commands/deploy/index.ts

@@ -24,7 +24,7 @@
    * After saving the script files, we need to
    * re-generate types for them.
    *
-   * This time, the script will have to binaries:
+   * This time, the script will have two binaries:
    *  - the original one
    *  - the loader one (after deploy)
    *
@@ -32,7 +32,7 @@
    *
    * This would look like:
    *
    *  import { MyScript, MyScriptDeployed } from './generated-types';
    *
    */
 

packages/fuels/src/cli/commands/deploy/saveScriptFiles.ts

@@ -1,3 +1,6 @@
+import { writeFileSync } from 'fs';
+
+import { getScriptName } from '../../config/forcUtils';
 import type { DeployedScript, FuelsConfig } from '../../types';
 
 export async function saveScriptFiles(scripts: DeployedScript[], _config: FuelsConfig) {
@@ -9,6 +12,15 @@ export async function saveScriptFiles(scripts: DeployedScript[], _config: FuelsC
      *    - Hash file for scripts
      *    - Root file for predicates
      */
+    const scriptName = getScriptName(path);
+    const buildMode = _config.buildMode;
+
+    const scriptBlobIdPath = `${path}/out/${buildMode}/${scriptName}-deployed-bin-hash`;
+    writeFileSync(scriptBlobIdPath, blobId);
+
+    const loaderBytecodePath = `${path}/out/${buildMode}/${scriptName}-deployed.bin`;
+    writeFileSync(loaderBytecodePath, loaderBytecode);
+
     await Promise.resolve({ path, blobId, loaderBytecode });
   }
 }

packages/fuels/src/cli/config/forcUtils.ts

@@ -119,6 +119,11 @@ export function getContractName(contractPath: string) {
   return project.name;
 }
 
+export function getScriptName(scriptPath: string) {
+  const { project } = readForcToml(scriptPath);
+  return project.name;
+}
+
 export function getContractCamelCase(contractPath: string) {
   const projectName = getContractName(contractPath);
   return camelCase(projectName);

packages/fuels/src/cli/types.ts

@@ -43,7 +43,8 @@ export type DeployedContract = {
 export type DeployedScript = {
   path: string;
   blobId: string;
-  loaderBytecode: string;
+  loaderBytecode: Uint8Array;
+  loaderBytecodeHexlified: string;
 };
 
 export type ContractDeployOptions = {