Support env subset deployments

typescript/helloworld/src/deploy/check.ts

@@ -9,7 +9,7 @@ export class HelloWorldChecker<
   Chain extends ChainName,
 > extends AbacusRouterChecker<
   Chain,
-  HelloWorldContracts,
   HelloWorldApp<Chain>,
-  HelloWorldConfig
+  HelloWorldConfig,
+  HelloWorldContracts
 > {}

typescript/helloworld/src/deploy/config.ts

@@ -1,32 +1,14 @@
-import {
-  ChainMap,
-  RouterConfig,
-  TestChainNames,
-  chainConnectionConfigs,
-} from '@abacus-network/sdk';
+import { RouterConfig, chainConnectionConfigs } from '@abacus-network/sdk';
 
 export type HelloWorldConfig = RouterConfig;
 
-// TODO reduce this config boilerplate
-
 export const testConfigs = {
   test1: chainConnectionConfigs.test1,
   test2: chainConnectionConfigs.test2,
   test3: chainConnectionConfigs.test3,
 };
 
-export function getConfigMap(
-  signerAddress: string,
-): ChainMap<TestChainNames, { owner: string }> {
-  return {
-    test1: {
-      owner: signerAddress,
-    },
-    test2: {
-      owner: signerAddress,
-    },
-    test3: {
-      owner: signerAddress,
-    },
-  };
-}
+// SET DESIRED NETWORKS HERE
+export const prodConfigs = {
+  alfajores: chainConnectionConfigs.alfajores,
+};

typescript/helloworld/src/deploy/deploy.ts

@@ -18,9 +18,9 @@ export class HelloWorldDeployer<
   Chain extends ChainName,
 > extends AbacusRouterDeployer<
   Chain,
+  HelloWorldConfig,
   HelloWorldContracts,
-  HelloWorldFactories,
-  HelloWorldConfig
+  HelloWorldFactories
 > {
   constructor(
     multiProvider: MultiProvider<Chain>,

typescript/helloworld/src/scripts/check.ts

@@ -1,38 +1,46 @@
-import { ethers } from 'hardhat';
+import { providers } from 'ethers';
 
 import {
   AbacusCore,
   ChainMap,
   ChainName,
   buildContracts,
-  getMultiProviderFromConfigAndSigner,
+  getChainToOwnerMap,
+  getMultiProviderFromConfigAndProvider,
 } from '@abacus-network/sdk';
 
 import { HelloWorldApp } from '../app/app';
 import { HelloWorldContracts, helloWorldFactories } from '../app/contracts';
-import testEnvironmentAddresses from '../app/environments/test.json';
 import { HelloWorldChecker } from '../deploy/check';
-import { getConfigMap, testConfigs } from '../deploy/config';
+import { prodConfigs } from '../deploy/config';
+
+// COPY FROM OUTPUT OF DEPLOYMENT SCRIPT OR IMPORT FROM ELSEWHERE
+const deploymentAddresses = {};
+
+// SET CONTRACT OWNER ADDRESS HERE
+const ownerAddress = '0x123...';
 
 async function check() {
-  const [signer] = await ethers.getSigners();
-  const multiProvider = getMultiProviderFromConfigAndSigner(
-    testConfigs,
-    signer,
-  );
+  console.info('Getting provider');
+  const provider = new providers.JsonRpcProvider('URL_HERE');
 
+  console.info('Preparing utilities');
+  const multiProvider = getMultiProviderFromConfigAndProvider(
+    prodConfigs,
+    provider,
+  );
   const contractsMap = buildContracts(
-    testEnvironmentAddresses,
+    deploymentAddresses,
     helloWorldFactories,
   ) as ChainMap<ChainName, HelloWorldContracts>;
-
   const app = new HelloWorldApp(contractsMap, multiProvider);
 
-  const core = AbacusCore.fromEnvironment('test', multiProvider);
+  const core = AbacusCore.fromEnvironment('testnet2', multiProvider);
   const config = core.extendWithConnectionClientConfig(
-    getConfigMap(signer.address),
+    getChainToOwnerMap(prodConfigs, ownerAddress),
   );
 
+  console.info('Starting check');
   const helloWorldChecker = new HelloWorldChecker(multiProvider, app, config);
   await helloWorldChecker.check();
   helloWorldChecker.expectEmpty();

typescript/helloworld/src/scripts/deploy.ts

@@ -1,25 +1,28 @@
-import '@nomiclabs/hardhat-ethers';
-import { ethers } from 'hardhat';
+import { Wallet } from 'ethers';
 
 import {
   AbacusCore,
+  getChainToOwnerMap,
   getMultiProviderFromConfigAndSigner,
   serializeContracts,
 } from '@abacus-network/sdk';
 
-import { getConfigMap, testConfigs } from '../deploy/config';
+import { prodConfigs } from '../deploy/config';
 import { HelloWorldDeployer } from '../deploy/deploy';
 
 async function main() {
-  const [signer] = await ethers.getSigners();
+  console.info('Getting signer');
+  const signer = new Wallet('SET KEY HERE OR CREATE YOUR OWN SIGNER');
+
+  console.info('Preparing utilities');
   const multiProvider = getMultiProviderFromConfigAndSigner(
-    testConfigs,
+    prodConfigs,
     signer,
   );
 
-  const core = AbacusCore.fromEnvironment('test', multiProvider);
+  const core = AbacusCore.fromEnvironment('testnet2', multiProvider);
   const config = core.extendWithConnectionClientConfig(
-    getConfigMap(signer.address),
+    getChainToOwnerMap(prodConfigs, signer.address),
   );
 
   const deployer = new HelloWorldDeployer(multiProvider, config, core);

typescript/helloworld/src/test/deploy.test.ts

@@ -7,13 +7,14 @@ import {
   TestChainNames,
   TestCoreApp,
   TestCoreDeployer,
+  getChainToOwnerMap,
   getMultiProviderFromConfigAndSigner,
 } from '@abacus-network/sdk';
 
 import { HelloWorldApp } from '../app/app';
 import { HelloWorldContracts } from '../app/contracts';
 import { HelloWorldChecker } from '../deploy/check';
-import { HelloWorldConfig, getConfigMap, testConfigs } from '../deploy/config';
+import { HelloWorldConfig, testConfigs } from '../deploy/config';
 import { HelloWorldDeployer } from '../deploy/deploy';
 
 describe('deploy', async () => {
@@ -32,7 +33,7 @@ describe('deploy', async () => {
     const coreContractsMaps = await coreDeployer.deploy();
     core = new TestCoreApp(coreContractsMaps, multiProvider);
     config = core.extendWithConnectionClientConfig(
-      getConfigMap(signer.address),
+      getChainToOwnerMap(testConfigs, signer.address),
     );
     deployer = new HelloWorldDeployer(multiProvider, config, core);
   });

typescript/helloworld/src/test/helloworld.test.ts

@@ -9,10 +9,11 @@ import {
   TestChainNames,
   TestCoreApp,
   TestCoreDeployer,
+  getChainToOwnerMap,
   getMultiProviderFromConfigAndSigner,
 } from '@abacus-network/sdk';
 
-import { HelloWorldConfig, getConfigMap, testConfigs } from '../deploy/config';
+import { HelloWorldConfig, testConfigs } from '../deploy/config';
 import { HelloWorldDeployer } from '../deploy/deploy';
 import { HelloWorld } from '../types';
 
@@ -38,7 +39,7 @@ describe('HelloWorld', async () => {
     const coreContractsMaps = await coreDeployer.deploy();
     coreApp = new TestCoreApp(coreContractsMaps, multiProvider);
     config = coreApp.extendWithConnectionClientConfig(
-      getConfigMap(signer.address),
+      getChainToOwnerMap(testConfigs, signer.address),
     );
   });
 

typescript/sdk/package.json

@@ -24,6 +24,7 @@
     "mocha": "^9.2.2",
     "prettier": "^2.4.1",
     "sinon": "^13.0.2",
+    "ts-node": "^10.8.0",
     "typescript": "^4.7.2"
   },
   "files": [

typescript/sdk/src/core/AbacusCore.ts

@@ -15,7 +15,7 @@ import { ChainConnection } from '../providers/ChainConnection';
 import { MultiProvider } from '../providers/MultiProvider';
 import { ConnectionClientConfig } from '../router';
 import { ChainMap, ChainName, Remotes } from '../types';
-import { objMap } from '../utils';
+import { objMap, pick } from '../utils';
 
 import { CoreContracts, coreFactories } from './contracts';
 
@@ -46,15 +46,41 @@ export class AbacusCore<Chain extends ChainName = ChainName> extends AbacusApp<
     super(contractsMap, multiProvider);
   }
 
-  static fromEnvironment<Env extends CoreEnvironment>(
-    env: Env,
-    multiProvider: MultiProvider<CoreEnvironmentChain<Env>>,
-  ): AbacusCore<CoreEnvironmentChain<Env>> {
+  // eslint-disable-next-line @typescript-eslint/explicit-module-boundary-types
+  static fromEnvironment<
+    Env extends CoreEnvironment,
+    Chain extends ChainName = ChainName,
+  >(env: Env, multiProvider: MultiProvider<Chain>) {
+    const envConfig = environments[env];
+    if (!envConfig) {
+      throw new Error(`No default env config found for ${env}`);
+    }
+
+    const multiProviderChains = multiProvider.chains();
+    const envChains = Object.keys(envConfig);
+    const intersection = multiProviderChains.filter((c) =>
+      envChains.includes(c),
+    );
+
+    if (!intersection.length) {
+      throw new Error(`No chains shared between MultiProvider and env ${env}`);
+    }
+
+    type EnvChain = keyof typeof envConfig;
+    type IntersectionChain = EnvChain & Chain;
+    // Force cast of multiProvider to ensure Core gets correct type later
+    const intersectionProvider =
+      multiProvider as unknown as MultiProvider<IntersectionChain>;
+    const intersectionConfig = pick(
+      envConfig as ChainMap<Chain, any>,
+      intersection,
+    );
     const contractsMap = buildContracts(
-      environments[env],
+      intersectionConfig,
       coreFactories,
-    ) as CoreContractsMap<CoreEnvironmentChain<Env>>;
-    return new AbacusCore(contractsMap, multiProvider);
+    ) as CoreContractsMap<IntersectionChain>;
+
+    return new AbacusCore(contractsMap, intersectionProvider);
   }
 
   // override type to be derived from chain key

typescript/sdk/src/core/TestCoreApp.ts

@@ -32,18 +32,17 @@ export type TestCoreContracts<Local extends TestChainNames> = CoreContracts<
     inboxes: ChainMap<Remotes<TestChainNames, Local>, TestInboxContracts>;
   };
 
-export class TestCoreApp extends AbacusCore<TestChainNames> {
-  getContracts<Local extends TestChainNames>(
+export class TestCoreApp<
+  TestChain extends TestChainNames = TestChainNames,
+> extends AbacusCore<TestChain> {
+  getContracts<Local extends TestChain>(
     chain: Local,
   ): TestCoreContracts<Local> {
     return super.getContracts(chain) as TestCoreContracts<Local>;
   }
 
   async processMessages(): Promise<
-    Map<
-      TestChainNames,
-      Map<TestChainNames, ethers.providers.TransactionResponse[]>
-    >
+    Map<TestChain, Map<TestChain, ethers.providers.TransactionResponse[]>>
   > {
     const responses = new Map();
     for (const origin of this.chains()) {
@@ -57,7 +56,7 @@ export class TestCoreApp extends AbacusCore<TestChainNames> {
     return responses;
   }
 
-  async processOutboundMessages<Local extends TestChainNames>(
+  async processOutboundMessages<Local extends TestChain>(
     origin: Local,
   ): Promise<Map<ChainName, any>> {
     const responses = new Map<ChainName, any>();

typescript/sdk/src/core/TestCoreDeployer.ts

@@ -7,7 +7,7 @@ import { AbacusCoreDeployer } from '../deploy/core/AbacusCoreDeployer';
 import { CoreConfig, ValidatorManagerConfig } from '../deploy/core/types';
 import { MultiProvider } from '../providers/MultiProvider';
 import { ProxiedContract } from '../proxy';
-import { Remotes, TestChainNames } from '../types';
+import { ChainMap, Remotes, TestChainNames } from '../types';
 
 import {
   TestCoreApp,
@@ -38,21 +38,26 @@ function mockProxy(contract: ethers.Contract) {
   });
 }
 
-export class TestCoreDeployer extends AbacusCoreDeployer<TestChainNames> {
-  constructor(public readonly multiProvider: MultiProvider<TestChainNames>) {
-    super(
-      multiProvider,
-      {
+export class TestCoreDeployer<
+  TestChain extends TestChainNames = TestChainNames,
+> extends AbacusCoreDeployer<TestChain> {
+  constructor(
+    public readonly multiProvider: MultiProvider<TestChain>,
+    configMap?: ChainMap<TestChain, CoreConfig>,
+  ) {
+    const configs =
+      configMap ??
+      ({
         test1: testValidatorManagerConfig,
         test2: testValidatorManagerConfig,
         test3: testValidatorManagerConfig,
-      },
-      testCoreFactories,
-    );
+      } as ChainMap<TestChain, CoreConfig>); // cast so param can be optional
+
+    super(multiProvider, configs, testCoreFactories);
   }
 
   // skip proxying
-  async deployOutbox<LocalChain extends TestChainNames>(
+  async deployOutbox<LocalChain extends TestChain>(
     chain: LocalChain,
     config: ValidatorManagerConfig,
   ): Promise<TestOutboxContracts> {
@@ -74,9 +79,9 @@ export class TestCoreDeployer extends AbacusCoreDeployer<TestChainNames> {
   }
 
   // skip proxying
-  async deployInbox<LocalChain extends TestChainNames>(
+  async deployInbox<LocalChain extends TestChain>(
     local: LocalChain,
-    remote: Remotes<TestChainNames, LocalChain>,
+    remote: Remotes<TestChain, LocalChain>,
     config: ValidatorManagerConfig,
   ): Promise<TestInboxContracts> {
     const localDomain = chainMetadata[local].id;
@@ -96,7 +101,7 @@ export class TestCoreDeployer extends AbacusCoreDeployer<TestChainNames> {
     } as TestInboxContracts;
   }
 
-  async deployApp(): Promise<TestCoreApp> {
+  async deployApp(): Promise<TestCoreApp<TestChain>> {
     return new TestCoreApp(await this.deploy(), this.multiProvider);
   }
 }

typescript/sdk/src/deploy/AbacusDeployer.ts

@@ -28,8 +28,8 @@ export interface DeployerOptions {
 export abstract class AbacusDeployer<
   Chain extends ChainName,
   Config,
-  Factories extends AbacusFactories,
   Contracts extends AbacusContracts,
+  Factories extends AbacusFactories,
 > {
   public deployedContracts: Partial<Record<Chain, Contracts>> = {};