Initial commit: 3

Author: Will Pote

.gitignore

@@ -1,4 +1,5 @@
 node_modules
+.env
 .vscode
 build
 cdk.out

README.md

@@ -1,14 +1,18 @@
-# Welcome to your CDK TypeScript project!
+# Prerequisites
 
-This is a blank project for TypeScript development with CDK.
+## API
 
-The `cdk.json` file tells the CDK Toolkit how to execute your app.
+Create .env file with:
 
-## Useful commands
+```
+ETH_GAS_STATION_INFO_KEY = '...'
+JSON_RPC_URL = '...'
+```
 
- * `npm run build`   compile typescript to js
- * `npm run watch`   watch for changes and compile
- * `npm run test`    perform the jest unit tests
- * `cdk deploy`      deploy this stack to your default AWS account/region
- * `cdk diff`        compare deployed stack with current state
- * `cdk synth`       emits the synthesized CloudFormation template
+## Integ Tests
+
+To run the integ tests you must first deploy the API, then add its url to your .env file.
+
+```
+UNISWAP_ROUTING_API= '...'
+```

bin/app.ts

@@ -1,9 +1,156 @@
 #!/usr/bin/env node
+import { BuildEnvironmentVariableType } from '@aws-cdk/aws-codebuild';
+import * as codepipeline from '@aws-cdk/aws-codepipeline';
+import * as codepipeline_actions from '@aws-cdk/aws-codepipeline-actions';
+import * as sm from '@aws-cdk/aws-secretsmanager';
+import * as cdk from '@aws-cdk/core';
+import {
+  CfnOutput,
+  Construct,
+  SecretValue,
+  Stack,
+  StackProps,
+  Stage,
+  StageProps,
+} from '@aws-cdk/core';
+import {
+  CdkPipeline,
+  CdkStage,
+  ShellScriptAction,
+  SimpleSynthAction,
+} from '@aws-cdk/pipelines';
+import dotenv from 'dotenv';
 import 'source-map-support/register';
-import * as cdk from 'aws-cdk-lib';
 import { RoutingAPIStack } from './stacks/routing-api-stack';
-import dotenv from 'dotenv'
 dotenv.config();
 
+export class RoutingAPIStage extends Stage {
+  public readonly url: CfnOutput;
+
+  constructor(
+    scope: Construct,
+    id: string,
+    props: StageProps & { nodeRPC: string }
+  ) {
+    super(scope, id, props);
+    const { nodeRPC } = props;
+
+    const { url } = new RoutingAPIStack(this, 'RoutingAPI', { nodeRPC });
+    this.url = url;
+  }
+}
+
+export class RoutingAPIPipeline extends Stack {
+  constructor(scope: Construct, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+    const sourceArtifact = new codepipeline.Artifact();
+    const cloudAssemblyArtifact = new codepipeline.Artifact();
+
+    const pipeline = new CdkPipeline(this, 'RoutingAPIPipeline', {
+      // The pipeline name
+      pipelineName: 'RoutingAPI',
+      cloudAssemblyArtifact,
+
+      // Where the source can be found
+      sourceAction: new codepipeline_actions.GitHubSourceAction({
+        actionName: 'GitHub',
+        output: sourceArtifact,
+        oauthToken: SecretValue.secretsManager('github-token-2'),
+        owner: 'Uniswap',
+        repo: 'uniswap-routing-api',
+        branch: 'main',
+      }),
+
+      // Build, Unit Test, and Synth templates.
+      synthAction: SimpleSynthAction.standardNpmSynth({
+        sourceArtifact,
+        cloudAssemblyArtifact,
+        environmentVariables: {
+          NPM_TOKEN: {
+            value: 'npm-private-repo-access-token',
+            type: BuildEnvironmentVariableType.SECRETS_MANAGER,
+          },
+        },
+        installCommand:
+          'echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc && npm ci',
+        buildCommand: 'npm run build',
+        testCommands: ['npm run test'],
+      }),
+    });
+
+    // Secrets are stored in secrets manager in the pipeline account. Accounts we deploy to
+    // have been granted permissions to access secrets via resource policies.
+    const rpcNodeUrl = sm.Secret.fromSecretAttributes(this, 'RPCNodeUrl', {
+      secretCompleteArn:
+        'arn:aws:secretsmanager:us-east-2:644039819003:secret:routing-api-infura-rpc-url-fSmY28',
+    });
+
+    // Beta us-east-2
+    const betaUsEast2Stage = new RoutingAPIStage(this, 'beta-us-east-2', {
+      env: { account: '145079444317', region: 'us-east-2' },
+      nodeRPC: rpcNodeUrl.secretValue.toString(),
+    });
+    const betaUsEast2AppStage = pipeline.addApplicationStage(betaUsEast2Stage);
+    this.addIntegTests(
+      pipeline,
+      sourceArtifact,
+      betaUsEast2Stage,
+      betaUsEast2AppStage
+    );
+
+    // Prod us-east-2
+    const prodUsEast2Stage = new RoutingAPIStage(this, 'prod-us-east-2', {
+      env: { account: '606857263320', region: 'us-east-2' },
+      nodeRPC: rpcNodeUrl.secretValue.toString(),
+    });
+    const prodUsEast2AppStage = pipeline.addApplicationStage(prodUsEast2Stage);
+    this.addIntegTests(
+      pipeline,
+      sourceArtifact,
+      prodUsEast2Stage,
+      prodUsEast2AppStage
+    );
+  }
+
+  private addIntegTests(
+    pipeline: CdkPipeline,
+    sourceArtifact: codepipeline.Artifact,
+    routingAPIStage: RoutingAPIStage,
+    applicationStage: CdkStage
+  ) {
+    applicationStage.addActions(
+      new ShellScriptAction({
+        actionName: 'IntegrationTests',
+        additionalArtifacts: [sourceArtifact],
+        useOutputs: {
+          UNISWAP_ROUTING_API: pipeline.stackOutput(routingAPIStage.url),
+        },
+        environmentVariables: {
+          NPM_TOKEN: {
+            value: 'npm-private-repo-access-token',
+            type: BuildEnvironmentVariableType.SECRETS_MANAGER,
+          },
+        },
+        commands: [
+          'echo "//registry.npmjs.org/:_authToken=${NPM_TOKEN}" > .npmrc && npm ci',
+          'echo "UNISWAP_ROUTING_API=${UNISWAP_ROUTING_API}" > .env',
+          'npm install',
+          'npm run integ-test',
+        ],
+        runOrder: applicationStage.nextSequentialRunOrder(),
+      })
+    );
+  }
+}
+
 const app = new cdk.App();
-new RoutingAPIStack(app, 'RoutingAPIStack');
+
+// Local dev stack
+new RoutingAPIStack(app, 'RoutingAPIStack', {
+  nodeRPC: process.env.JSON_RPC_URL!,
+});
+
+new RoutingAPIPipeline(app, 'RoutingAPIPipelineStack', {
+  env: { account: '644039819003', region: 'us-east-2' },
+});

bin/stacks/routing-api-stack.ts

@@ -1,37 +1,47 @@
-import * as cdk from 'aws-cdk-lib';
-import { aws_apigateway, aws_logs } from 'aws-cdk-lib';
-import { MethodLoggingLevel } from 'aws-cdk-lib/lib/aws-apigateway';
+import * as aws_apigateway from '@aws-cdk/aws-apigateway';
+import { MethodLoggingLevel } from '@aws-cdk/aws-apigateway';
+import * as aws_logs from '@aws-cdk/aws-logs';
+import * as cdk from '@aws-cdk/core';
+import { CfnOutput } from '@aws-cdk/core';
 import { RoutingCachingStack } from './routing-caching-stack';
 import { RoutingDashboardStack } from './routing-dashboard-stack';
 import { RoutingLambdaStack } from './routing-lambda-stack';
 
 export class RoutingAPIStack extends cdk.Stack {
-  constructor(parent: cdk.App, name: string, props?: cdk.StackProps) {
+  public readonly url: CfnOutput;
+
+  constructor(
+    parent: cdk.Construct,
+    name: string,
+    props: cdk.StackProps & { nodeRPC: string }
+  ) {
     super(parent, name, props);
 
     const { poolCacheBucket, poolCacheKey } = new RoutingCachingStack(
       this,
       'RoutingCachingStack'
     );
 
+    const { nodeRPC } = props;
+
     const { routingLambda } = new RoutingLambdaStack(
       this,
       'RoutingLambdaStack',
-      { poolCacheBucket, poolCacheKey }
+      { poolCacheBucket, poolCacheKey, nodeRPC }
     );
 
-    const accessLogGroup = new aws_logs.LogGroup(
-      this,
-      'RoutingAPIGAccessLogs'
-    );
+    const accessLogGroup = new aws_logs.LogGroup(this, 'RoutingAPIGAccessLogs');
 
     const api = new aws_apigateway.RestApi(this, 'routing-api', {
       restApiName: 'Routing API',
       deployOptions: {
         tracingEnabled: true,
         loggingLevel: MethodLoggingLevel.ERROR,
-        accessLogDestination: new aws_apigateway.LogGroupLogDestination(accessLogGroup),
-        accessLogFormat: aws_apigateway.AccessLogFormat.jsonWithStandardFields()
+        accessLogDestination: new aws_apigateway.LogGroupLogDestination(
+          accessLogGroup
+        ),
+        accessLogFormat:
+          aws_apigateway.AccessLogFormat.jsonWithStandardFields(),
       },
     });
 
@@ -45,5 +55,9 @@ export class RoutingAPIStack extends cdk.Stack {
 
     const quote = api.root.addResource('quote');
     quote.addMethod('POST', lambdaIntegration); // POST /swap
+
+    this.url = new CfnOutput(this, 'Url', {
+      value: api.url,
+    });
   }
 }

bin/stacks/routing-caching-stack.ts

@@ -1,17 +1,16 @@
-import * as cdk from 'aws-cdk-lib';
-import {
-  aws_s3,
-  aws_lambda,
-  aws_lambda_nodejs,
-  aws_iam,
-  aws_events,
-  aws_events_targets,
-  Duration,
-} from 'aws-cdk-lib';
-import { Schedule } from 'aws-cdk-lib/lib/aws-events';
-import { Construct } from 'constructs';
+import * as aws_events from '@aws-cdk/aws-events';
+import * as aws_events_targets from '@aws-cdk/aws-events-targets';
+import * as aws_iam from '@aws-cdk/aws-iam';
+import * as aws_lambda from '@aws-cdk/aws-lambda';
+import * as aws_lambda_nodejs from '@aws-cdk/aws-lambda-nodejs';
+import * as aws_s3 from '@aws-cdk/aws-s3';
+import * as cdk from '@aws-cdk/core';
+import { Construct, Duration } from '@aws-cdk/core';
 import * as path from 'path';
 
+export interface RoutingCachingStackProps extends cdk.NestedStackProps {
+  region: string;
+}
 export class RoutingCachingStack extends cdk.NestedStack {
   public readonly poolCacheBucket: aws_s3.Bucket;
   public readonly poolCacheKey: string;
@@ -32,6 +31,8 @@ export class RoutingCachingStack extends cdk.NestedStack {
       ],
     });
 
+    const region = cdk.Stack.of(this).region;
+
     const poolCachingLambda = new aws_lambda_nodejs.NodejsFunction(
       this,
       'PoolCacheLambda',
@@ -50,7 +51,7 @@ export class RoutingCachingStack extends cdk.NestedStack {
           aws_lambda.LayerVersion.fromLayerVersionArn(
             this,
             'InsightsLayer',
-            'arn:aws:lambda:us-east-1:580247275435:layer:LambdaInsightsExtension:14'
+            `arn:aws:lambda:${region}:580247275435:layer:LambdaInsightsExtension:14`
           ),
         ],
         tracing: aws_lambda.Tracing.ACTIVE,
@@ -64,7 +65,7 @@ export class RoutingCachingStack extends cdk.NestedStack {
     this.poolCacheBucket.grantReadWrite(poolCachingLambda);
 
     new aws_events.Rule(this, 'SchedulePoolCache', {
-      schedule: Schedule.rate(Duration.minutes(1)),
+      schedule: aws_events.Schedule.rate(Duration.minutes(1)),
       targets: [new aws_events_targets.LambdaFunction(poolCachingLambda)],
     });
   }

bin/stacks/routing-dashboard-stack.ts

@@ -1,6 +1,5 @@
-import * as cdk from 'aws-cdk-lib';
-import { aws_cloudwatch, Stack } from 'aws-cdk-lib';
-import { Construct } from 'constructs';
+import * as aws_cloudwatch from '@aws-cdk/aws-cloudwatch';
+import * as cdk from '@aws-cdk/core';
 
 export const NAMESPACE = 'Uniswap';
 
@@ -9,11 +8,15 @@ export interface RoutingDashboardProps extends cdk.NestedStackProps {
 }
 
 export class RoutingDashboardStack extends cdk.NestedStack {
-  constructor(scope: Construct, name: string, props: RoutingDashboardProps) {
+  constructor(
+    scope: cdk.Construct,
+    name: string,
+    props: RoutingDashboardProps
+  ) {
     super(scope, name, props);
 
     const { apiName } = props;
-    const region = Stack.of(this).region;
+    const region = cdk.Stack.of(this).region;
 
     new aws_cloudwatch.CfnDashboard(this, 'RoutingAPIDashboard', {
       dashboardName: 'RoutingDashboard',