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,8 @@
-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,
+// SET DESIRED NETWORKS HERE
+export const prodConfigs = {
+  alfajores: chainConnectionConfigs.alfajores,
 };
-
-export function getConfigMap(
-  signerAddress: string,
-): ChainMap<TestChainNames, { owner: string }> {
-  return {
-    test1: {
-      owner: signerAddress,
-    },
-    test2: {
-      owner: signerAddress,
-    },
-    test3: {
-      owner: signerAddress,
-    },
-  };
-}

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,45 @@
-import { ethers } from 'hardhat';
-
 import {
   AbacusCore,
   ChainMap,
   ChainName,
+  MultiProvider,
   buildContracts,
-  getMultiProviderFromConfigAndSigner,
+  getChainToOwnerMap,
+  objMap,
 } 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('Preparing utilities');
+  const chainProviders = objMap(prodConfigs, (_, config) => ({
+    provider: config.provider,
+    confirmations: config.confirmations,
+    overrides: config.overrides,
+  }));
+  const multiProvider = new MultiProvider(chainProviders);
 
   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,31 @@
-import '@nomiclabs/hardhat-ethers';
-import { ethers } from 'hardhat';
+import { Wallet } from 'ethers';
 
 import {
   AbacusCore,
-  getMultiProviderFromConfigAndSigner,
+  MultiProvider,
+  getChainToOwnerMap,
+  objMap,
   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();
-  const multiProvider = getMultiProviderFromConfigAndSigner(
-    testConfigs,
-    signer,
-  );
+  console.info('Getting signer');
+  const signer = new Wallet('SET KEY HERE OR CREATE YOUR OWN SIGNER');
+
+  console.info('Preparing utilities');
+  const chainProviders = objMap(prodConfigs, (_, config) => ({
+    provider: config.provider,
+    confirmations: config.confirmations,
+    overrides: config.overrides,
+  }));
+  const multiProvider = new MultiProvider(chainProviders);
 
-  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,15 @@ import {
   TestChainNames,
   TestCoreApp,
   TestCoreDeployer,
-  getMultiProviderFromConfigAndSigner,
+  getChainToOwnerMap,
+  getTestMultiProvider,
+  testChainConnectionConfigs,
 } 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 } from '../deploy/config';
 import { HelloWorldDeployer } from '../deploy/deploy';
 
 describe('deploy', async () => {
@@ -26,13 +28,13 @@ describe('deploy', async () => {
 
   before(async () => {
     const [signer] = await ethers.getSigners();
-    multiProvider = getMultiProviderFromConfigAndSigner(testConfigs, signer);
+    multiProvider = getTestMultiProvider(signer);
 
     const coreDeployer = new TestCoreDeployer(multiProvider);
     const coreContractsMaps = await coreDeployer.deploy();
     core = new TestCoreApp(coreContractsMaps, multiProvider);
     config = core.extendWithConnectionClientConfig(
-      getConfigMap(signer.address),
+      getChainToOwnerMap(testChainConnectionConfigs, signer.address),
     );
     deployer = new HelloWorldDeployer(multiProvider, config, core);
   });

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

@@ -9,10 +9,12 @@ import {
   TestChainNames,
   TestCoreApp,
   TestCoreDeployer,
-  getMultiProviderFromConfigAndSigner,
+  getChainToOwnerMap,
+  getTestMultiProvider,
+  testChainConnectionConfigs,
 } from '@abacus-network/sdk';
 
-import { HelloWorldConfig, getConfigMap, testConfigs } from '../deploy/config';
+import { HelloWorldConfig } from '../deploy/config';
 import { HelloWorldDeployer } from '../deploy/deploy';
 import { HelloWorld } from '../types';
 
@@ -32,13 +34,13 @@ describe('HelloWorld', async () => {
   before(async () => {
     [signer] = await ethers.getSigners();
 
-    multiProvider = getMultiProviderFromConfigAndSigner(testConfigs, signer);
+    multiProvider = getTestMultiProvider(signer);
 
     const coreDeployer = new TestCoreDeployer(multiProvider);
     const coreContractsMaps = await coreDeployer.deploy();
     coreApp = new TestCoreApp(coreContractsMaps, multiProvider);
     config = coreApp.extendWithConnectionClientConfig(
-      getConfigMap(signer.address),
+      getChainToOwnerMap(testChainConnectionConfigs, signer.address),
     );
   });
 

typescript/infra/config/environments/test/index.ts

@@ -1,6 +1,6 @@
 import { JsonRpcProvider } from '@ethersproject/providers';
 
-import { getMultiProviderFromConfigAndSigner } from '@abacus-network/sdk';
+import { getTestMultiProvider } from '@abacus-network/sdk';
 
 import { CoreEnvironmentConfig } from '../../../src/config';
 
@@ -19,6 +19,6 @@ export const environment: CoreEnvironmentConfig<TestChains> = {
   getMultiProvider: async () => {
     const provider = testConfigs.test1.provider! as JsonRpcProvider;
     const signer = provider.getSigner(0);
-    return getMultiProviderFromConfigAndSigner(testConfigs, signer);
+    return getTestMultiProvider(signer, testConfigs);
   },
 };

typescript/infra/hardhat.config.ts

@@ -8,7 +8,7 @@ import {
   AbacusCore,
   ChainName,
   ChainNameToDomainId,
-  getMultiProviderFromConfigAndSigner,
+  getTestMultiProvider,
 } from '@abacus-network/sdk';
 
 import { getCoreEnvironmentConfig } from './scripts/utils';
@@ -63,9 +63,9 @@ task('kathy', 'Dispatches random abacus messages')
       const interchainGasPayment = hre.ethers.utils.parseUnits('100', 'gwei');
       const config = getCoreEnvironmentConfig(environment);
       const [signer] = await hre.ethers.getSigners();
-      const multiProvider = getMultiProviderFromConfigAndSigner(
-        config.transactionConfigs,
+      const multiProvider = getTestMultiProvider(
         signer,
+        config.transactionConfigs,
       );
       const core = AbacusCore.fromEnvironment(environment, multiProvider);
 

typescript/infra/test/core.test.ts

@@ -12,7 +12,7 @@ import {
   CoreConfig,
   CoreContractsMap,
   MultiProvider,
-  getMultiProviderFromConfigAndSigner,
+  getTestMultiProvider,
   objMap,
   serializeContracts,
 } from '@abacus-network/sdk';
@@ -35,10 +35,7 @@ describe('core', async () => {
   beforeEach(async () => {
     const [signer, owner] = await ethers.getSigners();
     // This is kind of awkward and really these tests shouldn't live here
-    multiProvider = getMultiProviderFromConfigAndSigner(
-      testConfig.transactionConfigs,
-      signer,
-    );
+    multiProvider = getTestMultiProvider(signer, testConfig.transactionConfigs);
     coreConfig = testConfig.core;
     deployer = new AbacusCoreInfraDeployer(multiProvider, coreConfig);
     owners = objMap(testConfig.transactionConfigs, () => owner.address);

typescript/sdk/package.json

@@ -26,6 +26,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/consts/chainConnectionConfigs.ts

@@ -189,3 +189,9 @@ export const chainConnectionConfigs: ChainMap<ChainName, IChainConnection> = {
   test2,
   test3,
 };
+
+export const testChainConnectionConfigs = {
+  test1,
+  test2,
+  test3,
+};

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,33 @@ 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}`);
+    }
+
+    type EnvChain = keyof typeof envConfig;
+    type IntersectionChain = EnvChain & Chain;
+    const envChains = Object.keys(envConfig) as IntersectionChain[];
+
+    const { intersection, multiProvider: intersectionProvider } =
+      multiProvider.intersect<IntersectionChain>(envChains);
+
+    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>();