Absorb token

1 year ago · 11d9d0bf0d
parent 0ed4e84406 6992a4cc1f
commit 11d9d0bf0d
39 changed files with 18533 additions and 1 deletions
--- a/typescript/token
+++ b/typescript/token
@ -1 +0,0 @@
-Subproject commit 1bcdd324f4d055a9cae6cc4648c9210e5cd9668b
--- a/typescript/token/.eslintignore
+++ b/typescript/token/.eslintignore
@ -0,0 +1,7 @@
+node_modules
+dist
+coverage
+types
+hardhat.config.ts
+scripts
+test
--- a/typescript/token/.eslintrc
+++ b/typescript/token/.eslintrc
@ -0,0 +1,31 @@
+{
+  "env": {
+    "node": true,
+    "browser": true,
+    "es2021": true
+  },
+  "root": true,
+  "parser": "@typescript-eslint/parser",
+  "parserOptions": {
+    "ecmaVersion": 12,
+    "sourceType": "module",
+    "project": "./tsconfig.json"
+  },
+  "plugins": ["@typescript-eslint"],
+  "extends": [
+    "eslint:recommended",
+    "plugin:@typescript-eslint/recommended",
+    "prettier"
+  ],
+  "rules": {
+    "no-eval": ["error"],
+    "no-ex-assign": ["error"],
+    "no-constant-condition": ["off"],
+    "@typescript-eslint/ban-ts-comment": ["off"],
+    "@typescript-eslint/explicit-module-boundary-types": ["off"],
+    "@typescript-eslint/no-explicit-any": ["off"],
+    "@typescript-eslint/no-floating-promises": ["off"],
+    "@typescript-eslint/no-non-null-assertion": ["off"],
+    "@typescript-eslint/no-require-imports": ["warn"]
+  }
+}
--- a/typescript/token/.github/CODEOWNERS
+++ b/typescript/token/.github/CODEOWNERS
@ -0,0 +1,3 @@
+* @yorhodes @jmrossy @asaj
+
+contracts @yorhodes
--- a/typescript/token/.github/workflows/ci.yml
+++ b/typescript/token/.github/workflows/ci.yml
@ -0,0 +1,106 @@
+name: ci
+
+on:
+  # Triggers the workflow on push or pull request events but only for the main branch
+  push:
+    branches: [main]
+  pull_request:
+    branches: [main]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+jobs:
+  install:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: .//node_modules
+          key: ${{ runner.os }}-yarn-cache-${{ hashFiles('./yarn.lock') }}
+
+      - name: yarn-install
+        # Check out the lockfile from main, reinstall, and then
+        # verify the lockfile matches what was committed.
+        run: |
+            yarn install
+            CHANGES=$(git status -s)
+            if [[ ! -z $CHANGES ]]; then
+              echo "Changes found: $CHANGES"
+              git diff
+              exit 1
+            fi
+
+  build:
+    runs-on: ubuntu-latest
+    needs: [install]
+    steps:
+      - uses: actions/checkout@v2
+
+      - name: yarn-cache
+        uses: actions/cache@v2
+        with:
+          path: .//node_modules
+          key: ${{ runner.os }}-yarn-cache-${{ hashFiles('./yarn.lock') }}
+
+      - name: build-cache
+        uses: actions/cache@v2
+        with:
+          path: ./*
+          key: ${{ github.sha }}
+
+      - name: build
+        run: yarn run build
+
+  prettier:
+    runs-on: ubuntu-latest
+    needs: [install]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: .//node_modules
+          key: ${{ runner.os }}-yarn-cache-${{ hashFiles('./yarn.lock') }}
+
+      - name: prettier
+        run: |
+          yarn run prettier
+          CHANGES=$(git status -s)
+          if [[ ! -z $CHANGES ]]; then
+            echo "Changes found: $CHANGES"
+            exit 1
+          fi
+
+  lint:
+    runs-on: ubuntu-latest
+    needs: [build]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: ./*
+          key: ${{ github.sha }}
+
+      - name: lint
+        run: yarn run lint
+
+  test:
+    runs-on: ubuntu-latest
+    needs: [build]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/cache@v2
+        with:
+          path: ./*
+          key: ${{ github.sha }}
+
+      - name: test with coverage
+        run: yarn run coverage
+
+      - uses: osmind-development-org/lcov-reporter-action@v0.3.2
+        with:
+          title: "Hardhat Coverage Report"
+          lcov-file: ./coverage/lcov.info
+          lcov-base: ./lcov.base.info
+          delete-old-comments: true
--- a/typescript/token/.gitignore
+++ b/typescript/token/.gitignore
@ -0,0 +1,9 @@
+node_modules/
+cache/
+artifacts/
+types/
+dist/
+coverage/
+coverage.json
+*.swp
+.yarn/install-state.gz
--- a/typescript/token/.prettierignore
+++ b/typescript/token/.prettierignore
@ -0,0 +1,2 @@
+src/types
+test/outputs
--- a/typescript/token/.prettierrc
+++ b/typescript/token/.prettierrc
@ -0,0 +1,21 @@
+{
+  "tabWidth": 2,
+  "singleQuote": true,
+  "trailingComma": "all",
+  "overrides": [
+    {
+      "files": "*.sol",
+      "options": {
+        "printWidth": 80,
+        "tabWidth": 4,
+        "useTabs": false,
+        "singleQuote": false,
+        "bracketSpacing": false,
+        "explicitTypes": "always"
+      }
+    }
+  ],
+  "importOrder": ["^@hyperlane-xyz/(.*)$", "^../(.*)$", "^./(.*)$"],
+  "importOrderSeparation": true,
+  "importOrderSortSpecifiers": true
+}
--- a/typescript/token/.solcover.js
+++ b/typescript/token/.solcover.js
@ -0,0 +1,3 @@
+module.exports = {
+  skipFiles: ['test'],
+};
--- a/typescript/token/.solhint.json
+++ b/typescript/token/.solhint.json
@ -0,0 +1,8 @@
+{
+  "extends": "solhint:recommended",
+  "rules": {
+    "compiler-version": ["error", ">=0.6.0"],
+    "func-visibility": ["warn", {"ignoreConstructors":true}],
+    "not-rely-on-time": "off"
+  }
+}
--- a/typescript/token/.yarn/releases/yarn-3.2.0.cjs
+++ b/typescript/token/.yarn/releases/yarn-3.2.0.cjs
--- a/typescript/token/.yarnrc.yml
+++ b/typescript/token/.yarnrc.yml
@ -0,0 +1,3 @@
+nodeLinker: node-modules
+
+yarnPath: .yarn/releases/yarn-3.2.0.cjs
--- a/typescript/token/LICENSE.md
+++ b/typescript/token/LICENSE.md
@ -0,0 +1,193 @@
+# Apache License
+
+_Version 2.0, January 2004_  
+_&lt;<http://www.apache.org/licenses/>&gt;_
+
+### Terms and Conditions for use, reproduction, and distribution
+
+#### 1. Definitions
+
+“License” shall mean the terms and conditions for use, reproduction, and
+distribution as defined by Sections 1 through 9 of this document.
+
+“Licensor” shall mean the copyright owner or entity authorized by the copyright
+owner that is granting the License.
+
+“Legal Entity” shall mean the union of the acting entity and all other entities
+that control, are controlled by, or are under common control with that entity.
+For the purposes of this definition, “control” means **(i)** the power, direct or
+indirect, to cause the direction or management of such entity, whether by
+contract or otherwise, or **(ii)** ownership of fifty percent (50%) or more of the
+outstanding shares, or **(iii)** beneficial ownership of such entity.
+
+“You” (or “Your”) shall mean an individual or Legal Entity exercising
+permissions granted by this License.
+
+“Source” form shall mean the preferred form for making modifications, including
+but not limited to software source code, documentation source, and configuration
+files.
+
+“Object” form shall mean any form resulting from mechanical transformation or
+translation of a Source form, including but not limited to compiled object code,
+generated documentation, and conversions to other media types.
+
+“Work” shall mean the work of authorship, whether in Source or Object form, made
+available under the License, as indicated by a copyright notice that is included
+in or attached to the work (an example is provided in the Appendix below).
+
+“Derivative Works” shall mean any work, whether in Source or Object form, that
+is based on (or derived from) the Work and for which the editorial revisions,
+annotations, elaborations, or other modifications represent, as a whole, an
+original work of authorship. For the purposes of this License, Derivative Works
+shall not include works that remain separable from, or merely link (or bind by
+name) to the interfaces of, the Work and Derivative Works thereof.
+
+“Contribution” shall mean any work of authorship, including the original version
+of the Work and any modifications or additions to that Work or Derivative Works
+thereof, that is intentionally submitted to Licensor for inclusion in the Work
+by the copyright owner or by an individual or Legal Entity authorized to submit
+on behalf of the copyright owner. For the purposes of this definition,
+“submitted” means any form of electronic, verbal, or written communication sent
+to the Licensor or its representatives, including but not limited to
+communication on electronic mailing lists, source code control systems, and
+issue tracking systems that are managed by, or on behalf of, the Licensor for
+the purpose of discussing and improving the Work, but excluding communication
+that is conspicuously marked or otherwise designated in writing by the copyright
+owner as “Not a Contribution.”
+
+“Contributor” shall mean Licensor and any individual or Legal Entity on behalf
+of whom a Contribution has been received by Licensor and subsequently
+incorporated within the Work.
+
+#### 2. Grant of Copyright License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable copyright license to reproduce, prepare Derivative Works of,
+publicly display, publicly perform, sublicense, and distribute the Work and such
+Derivative Works in Source or Object form.
+
+#### 3. Grant of Patent License
+
+Subject to the terms and conditions of this License, each Contributor hereby
+grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free,
+irrevocable (except as stated in this section) patent license to make, have
+made, use, offer to sell, sell, import, and otherwise transfer the Work, where
+such license applies only to those patent claims licensable by such Contributor
+that are necessarily infringed by their Contribution(s) alone or by combination
+of their Contribution(s) with the Work to which such Contribution(s) was
+submitted. If You institute patent litigation against any entity (including a
+cross-claim or counterclaim in a lawsuit) alleging that the Work or a
+Contribution incorporated within the Work constitutes direct or contributory
+patent infringement, then any patent licenses granted to You under this License
+for that Work shall terminate as of the date such litigation is filed.
+
+#### 4. Redistribution
+
+You may reproduce and distribute copies of the Work or Derivative Works thereof
+in any medium, with or without modifications, and in Source or Object form,
+provided that You meet the following conditions:
+
+- **(a)** You must give any other recipients of the Work or Derivative Works a copy of
+  this License; and
+- **(b)** You must cause any modified files to carry prominent notices stating that You
+  changed the files; and
+- **(c)** You must retain, in the Source form of any Derivative Works that You distribute,
+  all copyright, patent, trademark, and attribution notices from the Source form
+  of the Work, excluding those notices that do not pertain to any part of the
+  Derivative Works; and
+- **(d)** If the Work includes a “NOTICE” text file as part of its distribution, then any
+  Derivative Works that You distribute must include a readable copy of the
+  attribution notices contained within such NOTICE file, excluding those notices
+  that do not pertain to any part of the Derivative Works, in at least one of the
+  following places: within a NOTICE text file distributed as part of the
+  Derivative Works; within the Source form or documentation, if provided along
+  with the Derivative Works; or, within a display generated by the Derivative
+  Works, if and wherever such third-party notices normally appear. The contents of
+  the NOTICE file are for informational purposes only and do not modify the
+  License. You may add Your own attribution notices within Derivative Works that
+  You distribute, alongside or as an addendum to the NOTICE text from the Work,
+  provided that such additional attribution notices cannot be construed as
+  modifying the License.
+
+You may add Your own copyright statement to Your modifications and may provide
+additional or different license terms and conditions for use, reproduction, or
+distribution of Your modifications, or for any such Derivative Works as a whole,
+provided Your use, reproduction, and distribution of the Work otherwise complies
+with the conditions stated in this License.
+
+#### 5. Submission of Contributions
+
+Unless You explicitly state otherwise, any Contribution intentionally submitted
+for inclusion in the Work by You to the Licensor shall be under the terms and
+conditions of this License, without any additional terms or conditions.
+Notwithstanding the above, nothing herein shall supersede or modify the terms of
+any separate license agreement you may have executed with Licensor regarding
+such Contributions.
+
+#### 6. Trademarks
+
+This License does not grant permission to use the trade names, trademarks,
+service marks, or product names of the Licensor, except as required for
+reasonable and customary use in describing the origin of the Work and
+reproducing the content of the NOTICE file.
+
+#### 7. Disclaimer of Warranty
+
+Unless required by applicable law or agreed to in writing, Licensor provides the
+Work (and each Contributor provides its Contributions) on an “AS IS” BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied,
+including, without limitation, any warranties or conditions of TITLE,
+NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are
+solely responsible for determining the appropriateness of using or
+redistributing the Work and assume any risks associated with Your exercise of
+permissions under this License.
+
+#### 8. Limitation of Liability
+
+In no event and under no legal theory, whether in tort (including negligence),
+contract, or otherwise, unless required by applicable law (such as deliberate
+and grossly negligent acts) or agreed to in writing, shall any Contributor be
+liable to You for damages, including any direct, indirect, special, incidental,
+or consequential damages of any character arising as a result of this License or
+out of the use or inability to use the Work (including but not limited to
+damages for loss of goodwill, work stoppage, computer failure or malfunction, or
+any and all other commercial damages or losses), even if such Contributor has
+been advised of the possibility of such damages.
+
+#### 9. Accepting Warranty or Additional Liability
+
+While redistributing the Work or Derivative Works thereof, You may choose to
+offer, and charge a fee for, acceptance of support, warranty, indemnity, or
+other liability obligations and/or rights consistent with this License. However,
+in accepting such obligations, You may act only on Your own behalf and on Your
+sole responsibility, not on behalf of any other Contributor, and only if You
+agree to indemnify, defend, and hold each Contributor harmless for any liability
+incurred by, or claims asserted against, such Contributor by reason of your
+accepting any such warranty or additional liability.
+
+_END OF TERMS AND CONDITIONS_
+
+### APPENDIX: How to apply the Apache License to your work
+
+To apply the Apache License to your work, attach the following boilerplate
+notice, with the fields enclosed by brackets `[]` replaced with your own
+identifying information. (Don't include the brackets!) The text should be
+enclosed in the appropriate comment syntax for the file format. We also
+recommend that a file or class name and description of purpose be included on
+the same “printed page” as the copyright notice for easier identification within
+third-party archives.
+
+    Copyright [yyyy] [name of copyright owner]
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
--- a/typescript/token/README.md
+++ b/typescript/token/README.md
@ -0,0 +1,253 @@
+# Hyperlane Tokens and Warp Routes
+
+This repo contains contracts and SDK tooling for Hyperlane-connected ERC20 and ERC721 tokens. The contracts herein can be used to create [Hyperlane Warp Routes](https://docs.hyperlane.xyz/docs/deploy/deploy-warp-route) across different chains.
+
+For instructions on deploying Warp Routes, see [the deployment documentation](https://docs.hyperlane.xyz/docs/deploy/deploy-warp-route/deploy-a-warp-route) and the [Hyperlane-Deploy repository](https://github.com/hyperlane-xyz/hyperlane-deploy).
+
+## Warp Route Architecture
+
+A Warp Route is a collection of [`TokenRouter`](./contracts/libs/TokenRouter.sol) contracts deployed across a set of Hyperlane chains. These contracts leverage the `Router` pattern to implement access control and routing logic for remote token transfers. These contracts send and receive [`Messages`](./contracts/libs/Message.sol) which encode payloads containing a transfer `amount` and `recipient` address.
+
+```mermaid
+%%{ init: {
+  "theme": "neutral",
+  "themeVariables": {
+    "mainBkg": "#025AA1",
+    "textColor": "white",
+    "clusterBkg": "white"
+  },
+  "themeCSS": ".edgeLabel { color: black }"
+}}%%
+
+graph LR
+    subgraph "Ethereum"
+        HYP_E[TokenRouter]
+        style HYP_E fill:orange
+        Mailbox_E[(Mailbox)]
+    end
+
+    subgraph "Polygon"
+        HYP_P[TokenRouter]
+        style HYP_P fill:orange
+        Mailbox_P[(Mailbox)]
+    end
+
+
+    subgraph "Gnosis"
+        HYP_G[TokenRouter]
+        style HYP_G fill:orange
+        Mailbox_G[(Mailbox)]
+    end
+
+    HYP_E -. "router" .- HYP_P -. "router" .- HYP_G
+
+```
+
+The Token Router contract comes in several flavors and a warp route can be composed of a combination of these flavors.
+
+- [`Native`](./contracts/HypNative.sol) - for warping native assets (e.g. ETH) from the canonical chain
+- [`Collateral`](./contracts/HypERC20Collateral.sol) - for warping tokens, ERC20 or ERC721, from the canonical chain
+- [`Synthetic`](./contracts/HypERC20.sol) - for representing tokens, Native/ERC20 or ERC721, on a non-canonical chain
+
+## Interchain Security Models
+
+Warp routes are unique amongst token bridging solutions because they provide modular security. Because the `TokenRouter` implements the `IMessageRecipient` interface, it can be configured with a custom interchain security module. Please refer to the relevant guide to specifying interchain security modules on the [Messaging API receive docs](https://docs.hyperlane.xyz/docs/apis/messaging-api/receive#interchain-security-modules).
+
+## Remote Transfer Lifecycle Diagrams
+
+To initiate a remote transfer, users call the `TokenRouter.transferRemote` function with the `destination` chain ID, `recipient` address, and transfer `amount`.
+
+```solidity
+interface TokenRouter {
+  function transferRemote(
+    uint32 destination,
+    bytes32 recipient,
+    uint256 amount
+  ) public returns (bytes32 messageId);
+}
+
+```
+
+**NOTE:** The [Relayer](https://docs.hyperlane.xyz/docs/protocol/agents/relayer) shown below must be compensated. Please refer to the relevant guide on [paying for interchain gas](https://docs.hyperlane.xyz/docs/build-with-hyperlane/guides/paying-for-interchain-gas) on the `messageID` returned from the `transferRemote` call.
+
+Depending on the flavor of TokenRouter on the source and destination chain, this flow looks slightly different. The following diagrams illustrate these differences.
+
+### Transfer Alice's `amount` native ETH from Ethereum to Bob on Polygon
+
+```mermaid
+%%{ init: {
+  "theme": "neutral",
+  "themeVariables": {
+    "mainBkg": "#025AA1",
+    "textColor": "white",
+    "clusterBkg": "white"
+  },
+  "themeCSS": ".edgeLabel { color: black }"
+}}%%
+
+graph TB
+    Bob((Bob))
+    style Bob fill:black
+    Alice((Alice))
+    style Alice fill:black
+
+    Relayer([Relayer])
+
+    subgraph "Ethereum"
+        HYP_E[NativeTokenRouter]
+        style HYP_E fill:orange
+        Mailbox_E[(Mailbox)]
+    end
+
+    Alice == "transferRemote(Polygon, Bob, amount)\n{value: amount}" ==> HYP_E
+    linkStyle 0 color:green;
+    HYP_E -- "dispatch(Polygon, (Bob, amount))" --> Mailbox_E
+
+    subgraph "Polygon"
+        HYP_P[SyntheticTokenRouter]
+        style HYP_P fill:orange
+        Mailbox_P[(Mailbox)]
+    end
+
+    Mailbox_E -. "indexing" .-> Relayer
+
+    Relayer == "process(Ethereum, (Bob, amount))" ==> Mailbox_P
+    Mailbox_P -- "handle(Ethereum, (Bob, amount))" --> HYP_P
+
+    HYP_E -. "router" .- HYP_P
+
+    HYP_P -- "mint(Bob, amount)" --> Bob
+    linkStyle 6 color:green;
+```
+
+### Transfer Alice's ERC20 `amount` from Ethereum to Bob on Polygon
+
+```mermaid
+%%{ init: {
+  "theme": "neutral",
+  "themeVariables": {
+    "mainBkg": "#025AA1",
+    "textColor": "white",
+    "clusterBkg": "white"
+  },
+  "themeCSS": ".edgeLabel { color: black }"
+}}%%
+
+graph TB
+    Alice((Alice))
+    Bob((Bob))
+    style Alice fill:black
+    style Bob fill:black
+
+    Relayer([Relayer])
+
+    subgraph "Ethereum"
+        Token_E[ERC20]
+        style Token_E fill:green
+        HYP_E[CollateralTokenRouter]
+        style HYP_E fill:orange
+        Mailbox_E[(Mailbox)]
+    end
+
+    Alice == "approve(CollateralTokenRouter, infinity)" ==> Token_E
+    Alice == "transferRemote(Polygon, Bob, amount)" ==> HYP_E
+    Token_E -- "transferFrom(Alice, amount)" --> HYP_E
+    linkStyle 2 color:green;
+    HYP_E -- "dispatch(Polygon, (Bob, amount))" --> Mailbox_E
+
+    subgraph "Polygon"
+        HYP_P[SyntheticRouter]
+        style HYP_P fill:orange
+        Mailbox_P[(Mailbox)]
+    end
+
+    Mailbox_E -. "indexing" .-> Relayer
+
+    Relayer == "process(Ethereum, (Bob, amount))" ==> Mailbox_P
+    Mailbox_P -- "handle(Ethereum, (Bob, amount))" --> HYP_P
+
+    HYP_E -. "router" .- HYP_P
+    HYP_P -- "mint(Bob, amount)" --> Bob
+    linkStyle 8 color:green;
+```
+
+### Transfer Alice's `amount` synthetic MATIC from Ethereum back to Bob as native MATIC on Polygon
+
+```mermaid
+%%{ init: {
+  "theme": "neutral",
+  "themeVariables": {
+    "mainBkg": "#025AA1",
+    "textColor": "white",
+    "clusterBkg": "white"
+  },
+  "themeCSS": ".edgeLabel { color: black }"
+}}%%
+
+graph TB
+    Bob((Bob))
+    style Bob fill:black
+    Alice((Alice))
+    style Alice fill:black
+
+    Relayer([Relayer])
+
+    subgraph "Ethereum"
+        HYP_E[SyntheticTokenRouter]
+        style HYP_E fill:orange
+        Mailbox_E[(Mailbox)]
+    end
+
+    Alice == "transferRemote(Polygon, Bob, amount)" ==> HYP_E
+    Alice -- "burn(Alice, amount)" --> HYP_E
+    linkStyle 1 color:green;
+    HYP_E -- "dispatch(Polygon, (Bob, amount))" --> Mailbox_E
+
+    subgraph "Polygon"
+        HYP_P[NativeTokenRouter]
+        style HYP_P fill:orange
+        Mailbox_P[(Mailbox)]
+    end
+
+    Mailbox_E -. "indexing" .-> Relayer
+
+    Relayer == "process(Ethereum, (Bob, amount))" ==> Mailbox_P
+    Mailbox_P -- "handle(Ethereum, (Bob, amount))" --> HYP_P
+
+    HYP_E -. "router" .- HYP_P
+    HYP_P -- "transfer(){value: amount}" --> Bob
+    linkStyle 7 color:green;
+```
+
+**NOTE:** ERC721 collateral variants are assumed to [enumerable](https://docs.openzeppelin.com/contracts/4.x/api/token/erc721#IERC721Enumerable) and [metadata](https://docs.openzeppelin.com/contracts/4.x/api/token/erc721#IERC721Metadata) compliant.
+
+## Versions
+
+| Git Ref                  | Release Date | Notes                          |
+| ------------------------ | ------------ | ------------------------------ |
+| [audit-v2-remediation]() | 2023-02-15   | Hyperlane V2 Audit remediation |
+| [main]()                 | ~            | Bleeding edge                  |
+
+## Setup for local development
+
+```sh
+# Install dependencies
+yarn
+
+# Build source and generate types
+yarn build:dev
+```
+
+## Unit testing
+
+```sh
+# Run all unit tests
+yarn test
+
+# Lint check code
+yarn lint
+```
+
+## Learn more
+
+For more information, see the [Hyperlane introduction documentation](https://docs.hyperlane.xyz/docs/introduction/readme) or the [details about Warp Routes](https://docs.hyperlane.xyz/docs/deploy/deploy-warp-route).
--- a/typescript/token/configs/warp-route-chain-config.json
+++ b/typescript/token/configs/warp-route-chain-config.json
@ -0,0 +1,22 @@
+{
+  "goerli": {
+    "chainId": 5,
+    "name": "goerli",
+    "displayName": "Goerli",
+    "nativeToken": { "name": "Ether", "symbol": "ETH", "decimals": 18 },
+    "publicRpcUrls": [{ "http": "https://eth-goerli.public.blastapi.io" }],
+    "blockExplorers": [
+      {
+        "name": "Goerliscan",
+        "url": "https://goerli.etherscan.io",
+        "apiUrl": "https://api-goerli.etherscan.io",
+        "family": "etherscan"
+      }
+    ],
+    "blocks": {
+      "confirmations": 1,
+      "reorgPeriod": 2,
+      "estimateBlockTime": 13
+    }
+  }
+}
--- a/typescript/token/configs/warp-route-token-config.json
+++ b/typescript/token/configs/warp-route-token-config.json
@ -0,0 +1,27 @@
+{
+  "goerli": {
+    "type": "collateral",
+    "token": "0xb4fbf271143f4fbf7b91a5ded31805e42b2208d6",
+    "owner": "0x5bA371aeA18734Cb7195650aFdfCa4f9251aa513",
+    "mailbox": "0xCC737a94FecaeC165AbCf12dED095BB13F037685",
+    "interchainGasPaymaster": "0xF90cB82a76492614D07B82a7658917f3aC811Ac1"
+  },
+  "alfajores": {
+    "type": "synthetic",
+    "owner": "0x5bA371aeA18734Cb7195650aFdfCa4f9251aa513",
+    "mailbox": "0xCC737a94FecaeC165AbCf12dED095BB13F037685",
+    "interchainGasPaymaster": "0xF90cB82a76492614D07B82a7658917f3aC811Ac1"
+  },
+  "fuji": {
+    "type": "synthetic",
+    "owner": "0x5bA371aeA18734Cb7195650aFdfCa4f9251aa513",
+    "mailbox": "0xCC737a94FecaeC165AbCf12dED095BB13F037685",
+    "interchainGasPaymaster": "0xF90cB82a76492614D07B82a7658917f3aC811Ac1"
+  },
+  "moonbasealpha": {
+    "type": "synthetic",
+    "owner": "0x5bA371aeA18734Cb7195650aFdfCa4f9251aa513",
+    "mailbox": "0xCC737a94FecaeC165AbCf12dED095BB13F037685",
+    "interchainGasPaymaster": "0xF90cB82a76492614D07B82a7658917f3aC811Ac1"
+  }
+}
--- a/typescript/token/contracts/HypERC20.sol
+++ b/typescript/token/contracts/HypERC20.sol
@ -0,0 +1,74 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TokenRouter} from "./libs/TokenRouter.sol";
+
+import {ERC20Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
+
+/**
+ * @title Hyperlane ERC20 Token Router that extends ERC20 with remote transfer functionality.
+ * @author Abacus Works
+ * @dev Supply on each chain is not constant but the aggregate supply across all chains is.
+ */
+contract HypERC20 is ERC20Upgradeable, TokenRouter {
+    uint8 private immutable _decimals;
+
+    constructor(uint8 decimals) {
+        _decimals = decimals;
+    }
+
+    /**
+     * @notice Initializes the Hyperlane router, ERC20 metadata, and mints initial supply to deployer.
+     * @param _mailbox The address of the mailbox contract.
+     * @param _interchainGasPaymaster The address of the interchain gas paymaster contract.
+     * @param _totalSupply The initial supply of the token.
+     * @param _name The name of the token.
+     * @param _symbol The symbol of the token.
+     */
+    function initialize(
+        address _mailbox,
+        address _interchainGasPaymaster,
+        uint256 _totalSupply,
+        string memory _name,
+        string memory _symbol
+    ) external initializer {
+        // transfers ownership to `msg.sender`
+        __HyperlaneConnectionClient_initialize(
+            _mailbox,
+            _interchainGasPaymaster
+        );
+
+        // Initialize ERC20 metadata
+        __ERC20_init(_name, _symbol);
+        _mint(msg.sender, _totalSupply);
+    }
+
+    function decimals() public view override returns (uint8) {
+        return _decimals;
+    }
+
+    /**
+     * @dev Burns `_amount` of token from `msg.sender` balance.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _amount)
+        internal
+        override
+        returns (bytes memory)
+    {
+        _burn(msg.sender, _amount);
+        return bytes(""); // no metadata
+    }
+
+    /**
+     * @dev Mints `_amount` of token to `_recipient` balance.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _amount,
+        bytes calldata // no metadata
+    ) internal override {
+        _mint(_recipient, _amount);
+    }
+}
--- a/typescript/token/contracts/HypERC20Collateral.sol
+++ b/typescript/token/contracts/HypERC20Collateral.sol
@ -0,0 +1,70 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TokenRouter} from "./libs/TokenRouter.sol";
+import {Message} from "./libs/Message.sol";
+
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
+
+/**
+ * @title Hyperlane ERC20 Token Collateral that wraps an existing ERC20 with remote transfer functionality.
+ * @author Abacus Works
+ */
+contract HypERC20Collateral is TokenRouter {
+    using SafeERC20 for IERC20;
+
+    IERC20 public immutable wrappedToken;
+
+    /**
+     * @notice Constructor
+     * @param erc20 Address of the token to keep as collateral
+     */
+    constructor(address erc20) {
+        wrappedToken = IERC20(erc20);
+    }
+
+    /**
+     * @notice Initializes the Hyperlane router.
+     * @param _mailbox The address of the mailbox contract.
+     * @param _interchainGasPaymaster The address of the interchain gas paymaster contract.
+     */
+    function initialize(address _mailbox, address _interchainGasPaymaster)
+        external
+        initializer
+    {
+        __HyperlaneConnectionClient_initialize(
+            _mailbox,
+            _interchainGasPaymaster
+        );
+    }
+
+    function balanceOf(address _account) external view returns (uint256) {
+        return wrappedToken.balanceOf(_account);
+    }
+
+    /**
+     * @dev Transfers `_amount` of `wrappedToken` from `msg.sender` to this contract.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _amount)
+        internal
+        override
+        returns (bytes memory)
+    {
+        wrappedToken.safeTransferFrom(msg.sender, address(this), _amount);
+        return bytes(""); // no metadata
+    }
+
+    /**
+     * @dev Transfers `_amount` of `wrappedToken` from this contract to `_recipient`.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _amount,
+        bytes calldata // no metadata
+    ) internal override {
+        wrappedToken.safeTransfer(_recipient, _amount);
+    }
+}
--- a/typescript/token/contracts/HypERC721.sol
+++ b/typescript/token/contracts/HypERC721.sol
@ -0,0 +1,66 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TokenRouter} from "./libs/TokenRouter.sol";
+
+import {ERC721EnumerableUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
+
+/**
+ * @title Hyperlane ERC721 Token Router that extends ERC721 with remote transfer functionality.
+ * @author Abacus Works
+ */
+contract HypERC721 is ERC721EnumerableUpgradeable, TokenRouter {
+    /**
+     * @notice Initializes the Hyperlane router, ERC721 metadata, and mints initial supply to deployer.
+     * @param _mailbox The address of the mailbox contract.
+     * @param _interchainGasPaymaster The address of the interchain gas paymaster contract.
+     * @param _mintAmount The amount of NFTs to mint to `msg.sender`.
+     * @param _name The name of the token.
+     * @param _symbol The symbol of the token.
+     */
+    function initialize(
+        address _mailbox,
+        address _interchainGasPaymaster,
+        uint256 _mintAmount,
+        string memory _name,
+        string memory _symbol
+    ) external initializer {
+        // transfers ownership to `msg.sender`
+        __HyperlaneConnectionClient_initialize(
+            _mailbox,
+            _interchainGasPaymaster
+        );
+
+        __ERC721_init(_name, _symbol);
+        for (uint256 i = 0; i < _mintAmount; i++) {
+            _safeMint(msg.sender, i);
+        }
+    }
+
+    /**
+     * @dev Asserts `msg.sender` is owner and burns `_tokenId`.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _tokenId)
+        internal
+        virtual
+        override
+        returns (bytes memory)
+    {
+        require(ownerOf(_tokenId) == msg.sender, "!owner");
+        _burn(_tokenId);
+        return bytes(""); // no metadata
+    }
+
+    /**
+     * @dev Mints `_tokenId` to `_recipient`.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _tokenId,
+        bytes calldata // no metadata
+    ) internal virtual override {
+        _safeMint(_recipient, _tokenId);
+    }
+}
--- a/typescript/token/contracts/HypERC721Collateral.sol
+++ b/typescript/token/contracts/HypERC721Collateral.sol
@ -0,0 +1,73 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TokenRouter} from "./libs/TokenRouter.sol";
+import {Message} from "./libs/Message.sol";
+
+import {IERC721} from "@openzeppelin/contracts/token/ERC721/IERC721.sol";
+
+/**
+ * @title Hyperlane ERC721 Token Collateral that wraps an existing ERC721 with remote transfer functionality.
+ * @author Abacus Works
+ */
+contract HypERC721Collateral is TokenRouter {
+    IERC721 public immutable wrappedToken;
+
+    /**
+     * @notice Constructor
+     * @param erc721 Address of the token to keep as collateral
+     */
+    constructor(address erc721) {
+        wrappedToken = IERC721(erc721);
+    }
+
+    function ownerOf(uint256 _tokenId) external view returns (address) {
+        return IERC721(wrappedToken).ownerOf(_tokenId);
+    }
+
+    /**
+     * @notice Initializes the Hyperlane router.
+     * @param _mailbox The address of the mailbox contract.
+     * @param _interchainGasPaymaster The address of the interchain gas paymaster contract.
+     */
+    function initialize(address _mailbox, address _interchainGasPaymaster)
+        external
+        initializer
+    {
+        __HyperlaneConnectionClient_initialize(
+            _mailbox,
+            _interchainGasPaymaster
+        );
+    }
+
+    function balanceOf(address _account) external view returns (uint256) {
+        return IERC721(wrappedToken).balanceOf(_account);
+    }
+
+    /**
+     * @dev Transfers `_tokenId` of `wrappedToken` from `msg.sender` to this contract.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256 _tokenId)
+        internal
+        virtual
+        override
+        returns (bytes memory)
+    {
+        // safeTransferFrom not used here because recipient is this contract
+        wrappedToken.transferFrom(msg.sender, address(this), _tokenId);
+        return bytes(""); // no metadata
+    }
+
+    /**
+     * @dev Transfers `_tokenId` of `wrappedToken` from this contract to `_recipient`.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _tokenId,
+        bytes calldata // no metadata
+    ) internal override {
+        wrappedToken.safeTransferFrom(address(this), _recipient, _tokenId);
+    }
+}
--- a/typescript/token/contracts/HypNative.sol
+++ b/typescript/token/contracts/HypNative.sol
@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {TokenRouter} from "./libs/TokenRouter.sol";
+import {Message} from "./libs/Message.sol";
+import {Address} from "@openzeppelin/contracts/utils/Address.sol";
+
+/**
+ * @title Hyperlane Native Token Router that extends ERC20 with remote transfer functionality.
+ * @author Abacus Works
+ * @dev Supply on each chain is not constant but the aggregate supply across all chains is.
+ */
+contract HypNative is TokenRouter {
+    /**
+     * @notice Initializes the Hyperlane router, ERC20 metadata, and mints initial supply to deployer.
+     * @param _mailbox The address of the mailbox contract.
+     * @param _interchainGasPaymaster The address of the interchain gas paymaster contract.
+     */
+    function initialize(address _mailbox, address _interchainGasPaymaster)
+        external
+        initializer
+    {
+        // transfers ownership to `msg.sender`
+        __HyperlaneConnectionClient_initialize(
+            _mailbox,
+            _interchainGasPaymaster
+        );
+    }
+
+    /**
+     * @inheritdoc TokenRouter
+     * @dev uses (`msg.value` - `_amount`) as interchain gas payment and `msg.sender` as refund address.
+     */
+    function transferRemote(
+        uint32 _destination,
+        bytes32 _recipient,
+        uint256 _amount
+    ) public payable override returns (bytes32 messageId) {
+        require(msg.value >= _amount, "Native: amount exceeds msg.value");
+        uint256 gasPayment = msg.value - _amount;
+        messageId = _dispatchWithGas(
+            _destination,
+            Message.format(_recipient, _amount, ""),
+            gasPayment,
+            msg.sender
+        );
+        emit SentTransferRemote(_destination, _recipient, _amount);
+    }
+
+    function balanceOf(address _account) external view returns (uint256) {
+        return _account.balance;
+    }
+
+    /**
+     * @dev No-op because native amount is transferred in `msg.value`
+     * @dev Compiler will not include this in the bytecode.
+     * @inheritdoc TokenRouter
+     */
+    function _transferFromSender(uint256)
+        internal
+        pure
+        override
+        returns (bytes memory)
+    {
+        return bytes(""); // no metadata
+    }
+
+    /**
+     * @dev Sends `_amount` of native token to `_recipient` balance.
+     * @inheritdoc TokenRouter
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _amount,
+        bytes calldata // no metadata
+    ) internal override {
+        Address.sendValue(payable(_recipient), _amount);
+    }
+}
--- a/typescript/token/contracts/extensions/HypERC721URICollateral.sol
+++ b/typescript/token/contracts/extensions/HypERC721URICollateral.sol
@ -0,0 +1,33 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {HypERC721Collateral} from "../HypERC721Collateral.sol";
+
+import {IERC721MetadataUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/IERC721MetadataUpgradeable.sol";
+
+/**
+ * @title Hyperlane ERC721 Token Collateral that wraps an existing ERC721 with remote transfer and URI relay functionality.
+ * @author Abacus Works
+ */
+contract HypERC721URICollateral is HypERC721Collateral {
+    constructor(address erc721) HypERC721Collateral(erc721) {}
+
+    /**
+     * @dev Transfers `_tokenId` of `wrappedToken` from `msg.sender` to this contract.
+     * @return The URI of `_tokenId` on `wrappedToken`.
+     * @inheritdoc HypERC721Collateral
+     */
+    function _transferFromSender(uint256 _tokenId)
+        internal
+        override
+        returns (bytes memory)
+    {
+        HypERC721Collateral._transferFromSender(_tokenId);
+        return
+            bytes(
+                IERC721MetadataUpgradeable(address(wrappedToken)).tokenURI(
+                    _tokenId
+                )
+            );
+    }
+}
--- a/typescript/token/contracts/extensions/HypERC721URIStorage.sol
+++ b/typescript/token/contracts/extensions/HypERC721URIStorage.sol
@ -0,0 +1,79 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {HypERC721} from "../HypERC721.sol";
+
+import {ERC721URIStorageUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721URIStorageUpgradeable.sol";
+import {ERC721EnumerableUpgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/extensions/ERC721EnumerableUpgradeable.sol";
+import {ERC721Upgradeable} from "@openzeppelin/contracts-upgradeable/token/ERC721/ERC721Upgradeable.sol";
+
+/**
+ * @title Hyperlane ERC721 Token that extends ERC721URIStorage with remote transfer and URI relay functionality.
+ * @author Abacus Works
+ */
+contract HypERC721URIStorage is HypERC721, ERC721URIStorageUpgradeable {
+    /**
+     * @return _tokenURI The URI of `_tokenId`.
+     * @inheritdoc HypERC721
+     */
+    function _transferFromSender(uint256 _tokenId)
+        internal
+        override
+        returns (bytes memory _tokenURI)
+    {
+        _tokenURI = bytes(tokenURI(_tokenId)); // requires minted
+        HypERC721._transferFromSender(_tokenId);
+    }
+
+    /**
+     * @dev Sets the URI for `_tokenId` to `_tokenURI`.
+     * @inheritdoc HypERC721
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _tokenId,
+        bytes calldata _tokenURI
+    ) internal override {
+        HypERC721._transferTo(_recipient, _tokenId, _tokenURI);
+        _setTokenURI(_tokenId, string(_tokenURI)); // requires minted
+    }
+
+    function tokenURI(uint256 tokenId)
+        public
+        view
+        override(ERC721Upgradeable, ERC721URIStorageUpgradeable)
+        returns (string memory)
+    {
+        return ERC721URIStorageUpgradeable.tokenURI(tokenId);
+    }
+
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 tokenId,
+        uint256 batchSize
+    ) internal override(ERC721EnumerableUpgradeable, ERC721Upgradeable) {
+        ERC721EnumerableUpgradeable._beforeTokenTransfer(
+            from,
+            to,
+            tokenId,
+            batchSize
+        );
+    }
+
+    function supportsInterface(bytes4 interfaceId)
+        public
+        view
+        override(ERC721EnumerableUpgradeable, ERC721Upgradeable)
+        returns (bool)
+    {
+        return ERC721EnumerableUpgradeable.supportsInterface(interfaceId);
+    }
+
+    function _burn(uint256 tokenId)
+        internal
+        override(ERC721URIStorageUpgradeable, ERC721Upgradeable)
+    {
+        ERC721URIStorageUpgradeable._burn(tokenId);
+    }
+}
--- a/typescript/token/contracts/libs/Message.sol
+++ b/typescript/token/contracts/libs/Message.sol
@ -0,0 +1,33 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+pragma solidity >=0.8.0;
+
+library Message {
+    function format(
+        bytes32 _recipient,
+        uint256 _amount,
+        bytes memory _metadata
+    ) internal pure returns (bytes memory) {
+        return abi.encodePacked(_recipient, _amount, _metadata);
+    }
+
+    function recipient(bytes calldata message) internal pure returns (bytes32) {
+        return bytes32(message[0:32]);
+    }
+
+    function amount(bytes calldata message) internal pure returns (uint256) {
+        return uint256(bytes32(message[32:64]));
+    }
+
+    // alias for ERC721
+    function tokenId(bytes calldata message) internal pure returns (uint256) {
+        return amount(message);
+    }
+
+    function metadata(bytes calldata message)
+        internal
+        pure
+        returns (bytes calldata)
+    {
+        return message[64:];
+    }
+}
--- a/typescript/token/contracts/libs/TokenRouter.sol
+++ b/typescript/token/contracts/libs/TokenRouter.sol
@ -0,0 +1,103 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import {GasRouter} from "@hyperlane-xyz/core/contracts/GasRouter.sol";
+import {TypeCasts} from "@hyperlane-xyz/core/contracts/libs/TypeCasts.sol";
+import {Message} from "./Message.sol";
+
+/**
+ * @title Hyperlane Token Router that extends Router with abstract token (ERC20/ERC721) remote transfer functionality.
+ * @author Abacus Works
+ */
+abstract contract TokenRouter is GasRouter {
+    using TypeCasts for bytes32;
+    using TypeCasts for address;
+    using Message for bytes;
+
+    /**
+     * @dev Emitted on `transferRemote` when a transfer message is dispatched.
+     * @param destination The identifier of the destination chain.
+     * @param recipient The address of the recipient on the destination chain.
+     * @param amount The amount of tokens burnt on the origin chain.
+     */
+    event SentTransferRemote(
+        uint32 indexed destination,
+        bytes32 indexed recipient,
+        uint256 amount
+    );
+
+    /**
+     * @dev Emitted on `_handle` when a transfer message is processed.
+     * @param origin The identifier of the origin chain.
+     * @param recipient The address of the recipient on the destination chain.
+     * @param amount The amount of tokens minted on the destination chain.
+     */
+    event ReceivedTransferRemote(
+        uint32 indexed origin,
+        bytes32 indexed recipient,
+        uint256 amount
+    );
+
+    /**
+     * @notice Transfers `_amountOrId` token to `_recipient` on `_destination` domain.
+     * @dev Delegates transfer logic to `_transferFromSender` implementation.
+     * @dev Emits `SentTransferRemote` event on the origin chain.
+     * @param _destination The identifier of the destination chain.
+     * @param _recipient The address of the recipient on the destination chain.
+     * @param _amountOrId The amount or identifier of tokens to be sent to the remote recipient.
+     * @return messageId The identifier of the dispatched message.
+     */
+    function transferRemote(
+        uint32 _destination,
+        bytes32 _recipient,
+        uint256 _amountOrId
+    ) public payable virtual returns (bytes32 messageId) {
+        bytes memory metadata = _transferFromSender(_amountOrId);
+        messageId = _dispatchWithGas(
+            _destination,
+            Message.format(_recipient, _amountOrId, metadata),
+            msg.value, // interchain gas payment
+            msg.sender // refund address
+        );
+        emit SentTransferRemote(_destination, _recipient, _amountOrId);
+    }
+
+    /**
+     * @dev Should transfer `_amountOrId` of tokens from `msg.sender` to this token router.
+     * @dev Called by `transferRemote` before message dispatch.
+     * @dev Optionally returns `metadata` associated with the transfer to be passed in message.
+     */
+    function _transferFromSender(uint256 _amountOrId)
+        internal
+        virtual
+        returns (bytes memory metadata);
+
+    /**
+     * @dev Mints tokens to recipient when router receives transfer message.
+     * @dev Emits `ReceivedTransferRemote` event on the destination chain.
+     * @param _origin The identifier of the origin chain.
+     * @param _message The encoded remote transfer message containing the recipient address and amount.
+     */
+    function _handle(
+        uint32 _origin,
+        bytes32,
+        bytes calldata _message
+    ) internal override {
+        bytes32 recipient = _message.recipient();
+        uint256 amount = _message.amount();
+        bytes calldata metadata = _message.metadata();
+        _transferTo(recipient.bytes32ToAddress(), amount, metadata);
+        emit ReceivedTransferRemote(_origin, recipient, amount);
+    }
+
+    /**
+     * @dev Should transfer `_amountOrId` of tokens from this token router to `_recipient`.
+     * @dev Called by `handle` after message decoding.
+     * @dev Optionally handles `metadata` associated with transfer passed in message.
+     */
+    function _transferTo(
+        address _recipient,
+        uint256 _amountOrId,
+        bytes calldata metadata
+    ) internal virtual;
+}
--- a/typescript/token/contracts/test/ERC20Test.sol
+++ b/typescript/token/contracts/test/ERC20Test.sol
@ -0,0 +1,14 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract ERC20Test is ERC20 {
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint256 totalSupply
+    ) ERC20(name, symbol) {
+        _mint(msg.sender, totalSupply);
+    }
+}
--- a/typescript/token/contracts/test/ERC721Test.sol
+++ b/typescript/token/contracts/test/ERC721Test.sol
@ -0,0 +1,20 @@
+// SPDX-License-Identifier: Apache-2.0
+pragma solidity >=0.8.0;
+
+import "@openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol";
+
+contract ERC721Test is ERC721Enumerable {
+    constructor(
+        string memory name,
+        string memory symbol,
+        uint256 _mintAmount
+    ) ERC721(name, symbol) {
+        for (uint256 i = 0; i < _mintAmount; i++) {
+            _mint(msg.sender, i);
+        }
+    }
+
+    function _baseURI() internal pure override returns (string memory) {
+        return "TEST-BASE-URI";
+    }
+}
--- a/typescript/token/hardhat.config.ts
+++ b/typescript/token/hardhat.config.ts
@ -0,0 +1,26 @@
+import '@nomiclabs/hardhat-ethers';
+import '@nomiclabs/hardhat-waffle';
+import '@typechain/hardhat';
+import 'hardhat-gas-reporter';
+import 'solidity-coverage';
+
+/**
+ * @type import('hardhat/config').HardhatUserConfig
+ */
+module.exports = {
+  solidity: {
+    compilers: [
+      {
+        version: '0.8.16',
+      },
+    ],
+  },
+  gasReporter: {
+    currency: 'USD',
+  },
+  typechain: {
+    outDir: './src/types',
+    target: 'ethers-v5',
+    alwaysGenerateOverloads: false, // should overloads with full signatures like deposit(uint256) be generated always, even if there are no overloads?
+  },
+};
--- a/typescript/token/lcov.base.info
+++ b/typescript/token/lcov.base.info
@ -0,0 +1,192 @@
+TN:
+SF:/Users/yorhodes/hyperlane/abacus-monorepo/typescript/token/contracts/extensions/HypERC721URICollateral.sol
+FN:14,constructor
+FN:22,_transferFromSender
+FNF:2
+FNH:2
+FNDA:24,constructor
+FNDA:54,_transferFromSender
+DA:27,54
+DA:28,52
+LF:2
+LH:2
+BRF:0
+BRH:0
+end_of_record
+TN:
+SF:/Users/yorhodes/hyperlane/abacus-monorepo/typescript/token/contracts/extensions/HypERC721URIStorage.sol
+FN:19,constructor
+FN:25,_transferFromSender
+FN:38,_transferTo
+FN:47,tokenURI
+FN:56,_beforeTokenTransfer
+FN:70,supportsInterface
+FN:79,_burn
+FNF:7
+FNH:6
+FNDA:120,constructor
+FNDA:41,_transferFromSender
+FNDA:65,_transferTo
+FNDA:44,tokenURI
+FNDA:4916,_beforeTokenTransfer
+FNDA:0,supportsInterface
+FNDA:39,_burn
+DA:30,41
+DA:31,40
+DA:43,65
+DA:44,65
+DA:53,44
+DA:62,4916
+DA:76,0
+DA:83,39
+LF:8
+LH:7
+BRF:0
+BRH:0
+end_of_record
+TN:
+SF:/Users/yorhodes/hyperlane/abacus-monorepo/typescript/token/contracts/HypERC20.sol
+FN:18,constructor
+FN:34,initialize
+FN:50,_transferFromSender
+FN:63,_transferTo
+FNF:4
+FNH:4
+FNDA:99,constructor
+FNDA:429,initialize
+FNDA:10,_transferFromSender
+FNDA:48,_transferTo
+DA:36,429
+DA:42,429
+DA:43,429
+DA:55,10
+DA:56,9
+DA:68,48
+LF:6
+LH:6
+BRF:0
+BRH:0
+end_of_record
+TN:
+SF:/Users/yorhodes/hyperlane/abacus-monorepo/typescript/token/contracts/HypERC20Collateral.sol
+FN:20,constructor
+FN:31,initialize
+FN:43,_transferFromSender
+FN:59,_transferTo
+FNF:4
+FNH:3
+FNDA:18,constructor
+FNDA:72,initialize
+FNDA:40,_transferFromSender
+FNDA:0,_transferTo
+DA:21,18
+DA:33,72
+DA:48,40
+DA:52,39
+DA:64,0
+LF:5
+LH:4
+BRDA:48,1,0,39
+BRDA:48,1,1,1
+BRDA:64,2,0,0
+BRDA:64,2,1,0
+BRF:4
+BRH:2
+end_of_record
+TN:
+SF:/Users/yorhodes/hyperlane/abacus-monorepo/typescript/token/contracts/HypERC721.sol
+FN:17,constructor
+FN:33,initialize
+FN:50,_transferFromSender
+FN:65,_transferTo
+FNF:4
+FNH:4
+FNDA:234,constructor
+FNDA:998,initialize
+FNDA:81,_transferFromSender
+FNDA:117,_transferTo
+DA:35,998
+DA:40,998
+DA:41,998
+DA:42,9600
+DA:56,81
+DA:57,78
+DA:58,78
+DA:70,117
+LF:8
+LH:8
+BRDA:56,1,0,78
+BRDA:56,1,1,3
+BRF:2
+BRH:2
+end_of_record
+TN:
+SF:/Users/yorhodes/hyperlane/abacus-monorepo/typescript/token/contracts/HypERC721Collateral.sol
+FN:20,constructor
+FN:31,initialize
+FN:43,_transferFromSender
+FN:57,_transferTo
+FNF:4
+FNH:3
+FNDA:45,constructor
+FNDA:180,initialize
+FNDA:95,_transferFromSender
+FNDA:0,_transferTo
+DA:21,45
+DA:33,180
+DA:49,95
+DA:50,91
+DA:62,0
+LF:5
+LH:4
+BRF:0
+BRH:0
+end_of_record
+TN:
+SF:/Users/yorhodes/hyperlane/abacus-monorepo/typescript/token/contracts/libs/Message.sol
+FN:5,format
+FN:13,recipient
+FN:17,amount
+FN:22,tokenId
+FN:26,metadata
+FNF:5
+FNH:4
+FNDA:217,format
+FNDA:165,recipient
+FNDA:165,amount
+FNDA:0,tokenId
+FNDA:165,metadata
+DA:10,217
+DA:14,165
+DA:18,165
+DA:23,0
+DA:31,165
+LF:5
+LH:4
+BRF:0
+BRH:0
+end_of_record
+TN:
+SF:/Users/yorhodes/hyperlane/abacus-monorepo/typescript/token/contracts/libs/TokenRouter.sol
+FN:45,constructor
+FN:57,transferRemote
+FN:89,_handle
+FNF:3
+FNH:3
+FNDA:396,constructor
+FNDA:227,transferRemote
+FNDA:165,_handle
+DA:46,396
+DA:62,227
+DA:63,217
+DA:70,185
+DA:94,165
+DA:95,165
+DA:96,165
+DA:97,165
+DA:98,156
+LF:9
+LH:9
+BRF:0
+BRH:0
+end_of_record
--- a/typescript/token/package.json
+++ b/typescript/token/package.json
@ -0,0 +1,63 @@
+{
+  "name": "@hyperlane-xyz/hyperlane-token",
+  "description": "A template for interchain ERC20 and ERC721 tokens using Hyperlane",
+  "version": "1.3.5",
+  "dependencies": {
+    "@hyperlane-xyz/core": "1.3.5",
+    "@hyperlane-xyz/sdk": "1.3.5",
+    "@hyperlane-xyz/utils": "1.3.5",
+    "@openzeppelin/contracts-upgradeable": "^4.8.0",
+    "ethers": "^5.7.2"
+  },
+  "devDependencies": {
+    "@nomiclabs/hardhat-ethers": "^2.2.1",
+    "@nomiclabs/hardhat-waffle": "^2.0.3",
+    "@trivago/prettier-plugin-sort-imports": "^3.2.0",
+    "@typechain/ethers-v5": "10.0.0",
+    "@typechain/hardhat": "^6.0.0",
+    "@types/mocha": "^9.1.0",
+    "@typescript-eslint/eslint-plugin": "^5.27.0",
+    "@typescript-eslint/parser": "^5.27.0",
+    "chai": "^4.3.0",
+    "eslint": "^8.16.0",
+    "eslint-config-prettier": "^8.5.0",
+    "ethereum-waffle": "^3.4.4",
+    "hardhat": "^2.8.4",
+    "hardhat-gas-reporter": "^1.0.7",
+    "prettier": "^2.4.1",
+    "prettier-plugin-solidity": "^1.0.0-beta.5",
+    "solhint": "^3.3.2",
+    "solhint-plugin-prettier": "^0.0.5",
+    "solidity-coverage": "^0.7.14",
+    "ts-node": "^10.8.0",
+    "typechain": "8.0.0",
+    "typescript": "^4.7.2"
+  },
+  "files": [
+    "/dist",
+    "/contracts"
+  ],
+  "homepage": "https://www.hyperlane.xyz",
+  "keywords": [
+    "Hyperlane",
+    "Solidity",
+    "Token"
+  ],
+  "license": "Apache-2.0",
+  "main": "dist/index.js",
+  "packageManager": "yarn@3.2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/hyperlane-xyz/hyperlane-token"
+  },
+  "scripts": {
+    "clean": "hardhat clean && rm -rf dist cache src/types",
+    "build": "hardhat compile && tsc",
+    "coverage": "hardhat coverage",
+    "lint": "eslint . --ext .ts",
+    "prettier": "prettier --write ./contracts ./test",
+    "test": "hardhat test ./test/*.test.ts",
+    "deploy-warp-route": "DEBUG=* ts-node scripts/deploy"
+  },
+  "types": "dist/index.d.ts"
+}
--- a/typescript/token/src/app.ts
+++ b/typescript/token/src/app.ts
@ -0,0 +1,80 @@
+import { BigNumberish } from 'ethers';
+
+import { ChainName, HyperlaneContracts, RouterApp } from '@hyperlane-xyz/sdk';
+import { types } from '@hyperlane-xyz/utils';
+
+import {
+  HypERC20Factories,
+  HypERC721Factories,
+  TokenFactories,
+} from './contracts';
+import { TokenRouter } from './types';
+
+class HyperlaneTokenApp<
+  Factories extends TokenFactories,
+> extends RouterApp<Factories> {
+  router(contracts: HyperlaneContracts<TokenFactories>): TokenRouter {
+    return contracts.router;
+  }
+
+  async transfer(
+    origin: ChainName,
+    destination: ChainName,
+    recipient: types.Address,
+    amountOrId: BigNumberish,
+  ) {
+    const originRouter = this.getContracts(origin).router;
+    const destProvider = this.multiProvider.getProvider(destination);
+    const destinationNetwork = await destProvider.getNetwork();
+    const gasPayment = await originRouter.quoteGasPayment(
+      destinationNetwork.chainId,
+    );
+    return this.multiProvider.handleTx(
+      origin,
+      originRouter.transferRemote(
+        destinationNetwork.chainId,
+        recipient,
+        amountOrId,
+        {
+          value: gasPayment,
+        },
+      ),
+    );
+  }
+}
+
+export class HypERC20App extends HyperlaneTokenApp<HypERC20Factories> {
+  async transfer(
+    origin: ChainName,
+    destination: ChainName,
+    recipient: types.Address,
+    amount: BigNumberish,
+  ) {
+    const originRouter = this.getContracts(origin).router;
+    const signerAddress = await this.multiProvider.getSignerAddress(origin);
+    const balance = await originRouter.balanceOf(signerAddress);
+    if (balance.lt(amount))
+      console.warn(
+        `Signer ${signerAddress} has insufficient balance ${balance}, needs ${amount} on ${origin}`,
+      );
+    return super.transfer(origin, destination, recipient, amount);
+  }
+}
+
+export class HypERC721App extends HyperlaneTokenApp<HypERC721Factories> {
+  async transfer(
+    origin: ChainName,
+    destination: ChainName,
+    recipient: types.Address,
+    tokenId: BigNumberish,
+  ) {
+    const originRouter = this.getContracts(origin).router;
+    const signerAddress = await this.multiProvider.getSignerAddress(origin);
+    const owner = await originRouter.ownerOf(tokenId);
+    if (signerAddress != owner)
+      console.warn(
+        `Signer ${signerAddress} not owner of token ${tokenId} on ${origin}`,
+      );
+    return super.transfer(origin, destination, recipient, tokenId);
+  }
+}
--- a/typescript/token/src/config.ts
+++ b/typescript/token/src/config.ts
@ -0,0 +1,70 @@
+import { ethers } from 'ethers';
+
+import { GasRouterConfig } from '@hyperlane-xyz/sdk';
+
+export enum TokenType {
+  synthetic = 'synthetic',
+  syntheticUri = 'syntheticUri',
+  collateral = 'collateral',
+  collateralUri = 'collateralUri',
+  native = 'native',
+}
+
+export type TokenMetadata = {
+  name: string;
+  symbol: string;
+  totalSupply: ethers.BigNumberish;
+};
+
+export type ERC20Metadata = TokenMetadata & {
+  decimals: number;
+};
+
+export const isTokenMetadata = (metadata: any): metadata is TokenMetadata =>
+  metadata.name && metadata.symbol && metadata.totalSupply !== undefined; // totalSupply can be 0
+
+export const isErc20Metadata = (metadata: any): metadata is ERC20Metadata =>
+  metadata.decimals && isTokenMetadata(metadata);
+
+export type SyntheticConfig = TokenMetadata & {
+  type: TokenType.synthetic | TokenType.syntheticUri;
+};
+export type CollateralConfig = {
+  type: TokenType.collateral | TokenType.collateralUri;
+  token: string;
+};
+export type NativeConfig = {
+  type: TokenType.native;
+};
+
+export type TokenConfig = SyntheticConfig | CollateralConfig | NativeConfig;
+
+export const isCollateralConfig = (
+  config: TokenConfig,
+): config is CollateralConfig =>
+  config.type === TokenType.collateral ||
+  config.type === TokenType.collateralUri;
+
+export const isSyntheticConfig = (
+  config: TokenConfig,
+): config is SyntheticConfig =>
+  config.type === TokenType.synthetic || config.type === TokenType.syntheticUri;
+
+export const isNativeConfig = (config: TokenConfig): config is NativeConfig =>
+  config.type === TokenType.native;
+
+export const isUriConfig = (config: TokenConfig) =>
+  config.type === TokenType.syntheticUri ||
+  config.type === TokenType.collateralUri;
+
+export type HypERC20Config = GasRouterConfig & SyntheticConfig & ERC20Metadata;
+export type HypERC20CollateralConfig = GasRouterConfig & CollateralConfig;
+export type HypNativeConfig = GasRouterConfig & NativeConfig;
+export type ERC20RouterConfig =
+  | HypERC20Config
+  | HypERC20CollateralConfig
+  | HypNativeConfig;
+
+export type HypERC721Config = GasRouterConfig & SyntheticConfig;
+export type HypERC721CollateralConfig = GasRouterConfig & CollateralConfig;
+export type ERC721RouterConfig = HypERC721Config | HypERC721CollateralConfig;
--- a/typescript/token/src/contracts.ts
+++ b/typescript/token/src/contracts.ts
@ -0,0 +1,20 @@
+import {
+  HypERC20Collateral__factory,
+  HypERC20__factory,
+  HypERC721Collateral__factory,
+  HypERC721URICollateral__factory,
+  HypERC721__factory,
+  HypNative__factory,
+} from './types';
+
+export type HypERC20Factories = {
+  router: HypERC20__factory | HypERC20Collateral__factory | HypNative__factory;
+};
+export type HypERC721Factories = {
+  router:
+    | HypERC721__factory
+    | HypERC721Collateral__factory
+    | HypERC721URICollateral__factory;
+};
+
+export type TokenFactories = HypERC20Factories | HypERC721Factories;
--- a/typescript/token/src/deploy.ts
+++ b/typescript/token/src/deploy.ts
@ -0,0 +1,381 @@
+import { providers } from 'ethers';
+
+import {
+  ChainMap,
+  ChainName,
+  GasRouterDeployer,
+  HyperlaneContracts,
+  MultiProvider,
+  objMap,
+} from '@hyperlane-xyz/sdk';
+import { GasConfig, RouterConfig } from '@hyperlane-xyz/sdk/dist/router/types';
+
+import {
+  CollateralConfig,
+  ERC20Metadata,
+  ERC20RouterConfig,
+  ERC721RouterConfig,
+  HypERC20CollateralConfig,
+  HypERC20Config,
+  HypERC721CollateralConfig,
+  HypERC721Config,
+  HypNativeConfig,
+  TokenConfig,
+  TokenMetadata,
+  isCollateralConfig,
+  isErc20Metadata,
+  isNativeConfig,
+  isSyntheticConfig,
+  isTokenMetadata,
+  isUriConfig,
+} from './config';
+import { HypERC20Factories, HypERC721Factories } from './contracts';
+import {
+  ERC20__factory,
+  ERC721EnumerableUpgradeable__factory,
+  HypERC20,
+  HypERC20Collateral,
+  HypERC20Collateral__factory,
+  HypERC20__factory,
+  HypERC721,
+  HypERC721Collateral,
+  HypERC721Collateral__factory,
+  HypERC721URICollateral__factory,
+  HypERC721URIStorage__factory,
+  HypERC721__factory,
+  HypNative,
+  HypNative__factory,
+} from './types';
+
+export class HypERC20Deployer extends GasRouterDeployer<
+  ERC20RouterConfig,
+  HypERC20Factories
+> {
+  constructor(multiProvider: MultiProvider) {
+    super(multiProvider, {} as HypERC20Factories); // factories not used in deploy
+  }
+
+  static async fetchMetadata(
+    provider: providers.Provider,
+    config: CollateralConfig,
+  ): Promise<ERC20Metadata> {
+    const erc20 = ERC20__factory.connect(config.token, provider);
+
+    const [name, symbol, totalSupply, decimals] = await Promise.all([
+      erc20.name(),
+      erc20.symbol(),
+      erc20.totalSupply(),
+      erc20.decimals(),
+    ]);
+
+    return { name, symbol, totalSupply, decimals };
+  }
+
+  static gasOverheadDefault(config: TokenConfig): number {
+    switch (config.type) {
+      case 'synthetic':
+        return 64_000;
+      case 'native':
+        return 44_000;
+      case 'collateral':
+      default:
+        return 68_000;
+    }
+  }
+
+  protected async deployCollateral(
+    chain: ChainName,
+    config: HypERC20CollateralConfig,
+  ): Promise<HypERC20Collateral> {
+    const router = await this.deployContractFromFactory(
+      chain,
+      new HypERC20Collateral__factory(),
+      'HypERC20Collateral',
+      [config.token],
+    );
+    await this.multiProvider.handleTx(
+      chain,
+      router.initialize(config.mailbox, config.interchainGasPaymaster),
+    );
+    return router;
+  }
+
+  protected async deployNative(
+    chain: ChainName,
+    config: HypNativeConfig,
+  ): Promise<HypNative> {
+    const router = await this.deployContractFromFactory(
+      chain,
+      new HypNative__factory(),
+      'HypNative',
+      [],
+    );
+    await this.multiProvider.handleTx(
+      chain,
+      router.initialize(config.mailbox, config.interchainGasPaymaster),
+    );
+    return router;
+  }
+
+  protected async deploySynthetic(
+    chain: ChainName,
+    config: HypERC20Config,
+  ): Promise<HypERC20> {
+    const router = await this.deployContractFromFactory(
+      chain,
+      new HypERC20__factory(),
+      'HypERC20',
+      [config.decimals],
+    );
+    await this.multiProvider.handleTx(
+      chain,
+      router.initialize(
+        config.mailbox,
+        config.interchainGasPaymaster,
+        config.totalSupply,
+        config.name,
+        config.symbol,
+      ),
+    );
+    return router;
+  }
+
+  router(contracts: HyperlaneContracts<HypERC20Factories>) {
+    return contracts.router;
+  }
+
+  async deployContracts(chain: ChainName, config: HypERC20Config) {
+    let router: HypERC20 | HypERC20Collateral | HypNative;
+    if (isCollateralConfig(config)) {
+      router = await this.deployCollateral(chain, config);
+    } else if (isNativeConfig(config)) {
+      router = await this.deployNative(chain, config);
+    } else if (isSyntheticConfig(config)) {
+      router = await this.deploySynthetic(chain, config);
+    } else {
+      throw new Error('Invalid ERC20 token router config');
+    }
+    return { router };
+  }
+
+  async buildTokenMetadata(
+    configMap: ChainMap<TokenConfig>,
+  ): Promise<ChainMap<ERC20Metadata>> {
+    let tokenMetadata: ERC20Metadata | undefined;
+
+    for (const [chain, config] of Object.entries(configMap)) {
+      if (isCollateralConfig(config)) {
+        const collateralMetadata = await HypERC20Deployer.fetchMetadata(
+          this.multiProvider.getProvider(chain),
+          config,
+        );
+        tokenMetadata = {
+          ...collateralMetadata,
+          totalSupply: 0,
+        };
+      } else if (isNativeConfig(config)) {
+        const chainMetadata = this.multiProvider.getChainMetadata(chain);
+        if (chainMetadata.nativeToken) {
+          tokenMetadata = {
+            ...chainMetadata.nativeToken,
+            totalSupply: 0,
+          };
+        } else {
+          throw new Error(
+            `Warp route config specifies native token but chain metadata for ${chain} does not provide native token details`,
+          );
+        }
+      } else if (isErc20Metadata(config)) {
+        tokenMetadata = config;
+      }
+    }
+
+    if (!isErc20Metadata(tokenMetadata)) {
+      throw new Error('Invalid ERC20 token metadata');
+    }
+
+    return objMap(configMap, () => tokenMetadata!);
+  }
+
+  buildGasOverhead(configMap: ChainMap<TokenConfig>): ChainMap<GasConfig> {
+    return objMap(configMap, (_, config) => ({
+      gas: HypERC20Deployer.gasOverheadDefault(config),
+    }));
+  }
+
+  async deploy(configMap: ChainMap<TokenConfig & RouterConfig>) {
+    const tokenMetadata = await this.buildTokenMetadata(configMap);
+    const gasOverhead = this.buildGasOverhead(configMap);
+    const mergedConfig = objMap(configMap, (chain, config) => {
+      return {
+        ...tokenMetadata[chain],
+        ...gasOverhead[chain],
+        ...config,
+      };
+    }) as ChainMap<ERC20RouterConfig>;
+
+    return super.deploy(mergedConfig);
+  }
+}
+
+export class HypERC721Deployer extends GasRouterDeployer<
+  ERC721RouterConfig,
+  HypERC721Factories
+> {
+  constructor(multiProvider: MultiProvider) {
+    super(multiProvider, {} as HypERC721Factories); // factories not used in deploy
+  }
+
+  static async fetchMetadata(
+    provider: providers.Provider,
+    config: CollateralConfig,
+  ): Promise<TokenMetadata> {
+    const erc721 = ERC721EnumerableUpgradeable__factory.connect(
+      config.token,
+      provider,
+    );
+    const [name, symbol, totalSupply] = await Promise.all([
+      erc721.name(),
+      erc721.symbol(),
+      erc721.totalSupply(),
+    ]);
+
+    return { name, symbol, totalSupply };
+  }
+
+  static gasOverheadDefault(config: TokenConfig): number {
+    switch (config.type) {
+      case 'synthetic':
+        return 160_000;
+      case 'syntheticUri':
+        return 163_000;
+      case 'collateral':
+      case 'collateralUri':
+      default:
+        return 80_000;
+    }
+  }
+
+  protected async deployCollateral(
+    chain: ChainName,
+    config: HypERC721CollateralConfig,
+  ): Promise<HypERC721Collateral> {
+    let router: HypERC721Collateral;
+    if (isUriConfig(config)) {
+      router = await this.deployContractFromFactory(
+        chain,
+        new HypERC721URICollateral__factory(),
+        'HypERC721URICollateral',
+        [config.token],
+      );
+    } else {
+      router = await this.deployContractFromFactory(
+        chain,
+        new HypERC721Collateral__factory(),
+        'HypERC721Collateral',
+        [config.token],
+      );
+    }
+    await this.multiProvider.handleTx(
+      chain,
+      router.initialize(config.mailbox, config.interchainGasPaymaster),
+    );
+    return router;
+  }
+
+  protected async deploySynthetic(
+    chain: ChainName,
+    config: HypERC721Config,
+  ): Promise<HypERC721> {
+    let router: HypERC721;
+    if (isUriConfig(config)) {
+      router = await this.deployContractFromFactory(
+        chain,
+        new HypERC721URIStorage__factory(),
+        'HypERC721URIStorage',
+        [],
+      );
+    } else {
+      router = await this.deployContractFromFactory(
+        chain,
+        new HypERC721__factory(),
+        'HypERC721',
+        [],
+      );
+    }
+    await this.multiProvider.handleTx(
+      chain,
+      router.initialize(
+        config.mailbox,
+        config.interchainGasPaymaster,
+        config.totalSupply,
+        config.name,
+        config.symbol,
+      ),
+    );
+    return router;
+  }
+
+  router(contracts: HyperlaneContracts<HypERC721Factories>) {
+    return contracts.router;
+  }
+
+  async deployContracts(chain: ChainName, config: HypERC721Config) {
+    let router: HypERC721 | HypERC721Collateral;
+    if (isCollateralConfig(config)) {
+      router = await this.deployCollateral(chain, config);
+    } else if (isSyntheticConfig(config)) {
+      router = await this.deploySynthetic(chain, config);
+    } else {
+      throw new Error('Invalid ERC721 token router config');
+    }
+    return { router };
+  }
+
+  async buildTokenMetadata(
+    configMap: ChainMap<TokenConfig>,
+  ): Promise<ChainMap<TokenMetadata>> {
+    let tokenMetadata: TokenMetadata | undefined;
+
+    for (const [chain, config] of Object.entries(configMap)) {
+      if (isCollateralConfig(config)) {
+        const collateralMetadata = await HypERC721Deployer.fetchMetadata(
+          this.multiProvider.getProvider(chain),
+          config,
+        );
+        tokenMetadata = {
+          ...collateralMetadata,
+          totalSupply: 0,
+        };
+      } else if (isTokenMetadata(config)) {
+        tokenMetadata = config;
+      }
+    }
+
+    if (!isTokenMetadata(tokenMetadata)) {
+      throw new Error('Invalid ERC721 token metadata');
+    }
+
+    return objMap(configMap, () => tokenMetadata!);
+  }
+
+  buildGasOverhead(configMap: ChainMap<TokenConfig>): ChainMap<GasConfig> {
+    return objMap(configMap, (_, config) => ({
+      gas: HypERC721Deployer.gasOverheadDefault(config),
+    }));
+  }
+
+  async deploy(configMap: ChainMap<TokenConfig & RouterConfig>) {
+    const tokenMetadata = await this.buildTokenMetadata(configMap);
+    const gasOverhead = this.buildGasOverhead(configMap);
+    const mergedConfig = objMap(configMap, (chain, config) => {
+      return {
+        ...tokenMetadata[chain],
+        ...gasOverhead[chain],
+        ...config,
+      };
+    }) as ChainMap<ERC721RouterConfig>;
+
+    return super.deploy(mergedConfig);
+  }
+}
--- a/typescript/token/src/index.ts
+++ b/typescript/token/src/index.ts
@ -0,0 +1,16 @@
+export { HypERC20App, HypERC721App } from './app';
+export {
+  CollateralConfig,
+  HypERC20CollateralConfig,
+  HypERC20Config,
+  HypERC721CollateralConfig,
+  HypERC721Config,
+  isCollateralConfig,
+  isUriConfig,
+  SyntheticConfig,
+  TokenConfig,
+  TokenType,
+} from './config';
+export { HypERC20Factories, HypERC721Factories } from './contracts';
+export { HypERC20Deployer, HypERC721Deployer } from './deploy';
+export * from './types';
--- a/typescript/token/test/erc20.test.ts
+++ b/typescript/token/test/erc20.test.ts
@ -0,0 +1,291 @@
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
+import '@nomiclabs/hardhat-waffle';
+import { expect } from 'chai';
+import { BigNumber, BigNumberish } from 'ethers';
+import { ethers } from 'hardhat';
+
+import { InterchainGasPaymaster__factory } from '@hyperlane-xyz/core';
+import {
+  ChainMap,
+  Chains,
+  HyperlaneContractsMap,
+  MultiProvider,
+  RouterConfig,
+  TestCoreApp,
+  TestCoreDeployer,
+  deployTestIgpsAndGetRouterConfig,
+  objMap,
+} from '@hyperlane-xyz/sdk';
+import { utils } from '@hyperlane-xyz/utils';
+
+import { TokenConfig, TokenType } from '../src/config';
+import { HypERC20Factories } from '../src/contracts';
+import { HypERC20Deployer } from '../src/deploy';
+import {
+  ERC20,
+  ERC20Test__factory,
+  ERC20__factory,
+  HypERC20,
+  HypERC20Collateral,
+  HypNative,
+} from '../src/types';
+
+const localChain = Chains.test1;
+const remoteChain = Chains.test2;
+let localDomain: number;
+let remoteDomain: number;
+const totalSupply = 3000;
+const amount = 10;
+
+const tokenMetadata = {
+  name: 'HypERC20',
+  symbol: 'HYP',
+  decimals: 18,
+  totalSupply,
+};
+
+for (const variant of [
+  TokenType.synthetic,
+  TokenType.collateral,
+  TokenType.native,
+]) {
+  describe(`HypERC20${variant}`, async () => {
+    let owner: SignerWithAddress;
+    let recipient: SignerWithAddress;
+    let core: TestCoreApp;
+    let deployer: HypERC20Deployer;
+    let contracts: HyperlaneContractsMap<HypERC20Factories>;
+    let localTokenConfig: TokenConfig;
+    let local: HypERC20 | HypERC20Collateral | HypNative;
+    let remote: HypERC20;
+    let interchainGasPayment: BigNumber;
+
+    beforeEach(async () => {
+      [owner, recipient] = await ethers.getSigners();
+      const multiProvider = MultiProvider.createTestMultiProvider({
+        signer: owner,
+      });
+      localDomain = multiProvider.getDomainId(localChain);
+      remoteDomain = multiProvider.getDomainId(remoteChain);
+
+      const coreDeployer = new TestCoreDeployer(multiProvider);
+      const coreContractsMaps = await coreDeployer.deploy();
+      core = new TestCoreApp(coreContractsMaps, multiProvider);
+      const routerConfig = await deployTestIgpsAndGetRouterConfig(
+        multiProvider,
+        owner.address,
+        core.contractsMap,
+      );
+
+      let erc20: ERC20 | undefined;
+      if (variant === TokenType.collateral) {
+        erc20 = await new ERC20Test__factory(owner).deploy(
+          tokenMetadata.name,
+          tokenMetadata.symbol,
+          tokenMetadata.totalSupply,
+        );
+        localTokenConfig = {
+          type: variant,
+          token: erc20.address,
+        };
+      } else if (variant === TokenType.native) {
+        localTokenConfig = {
+          type: variant,
+        };
+      } else if (variant === TokenType.synthetic) {
+        localTokenConfig = { type: variant, ...tokenMetadata };
+      }
+
+      const config = objMap(routerConfig, (key) => ({
+        ...routerConfig[key],
+        ...(key === localChain
+          ? localTokenConfig
+          : { type: TokenType.synthetic }),
+        owner: owner.address,
+      })) as ChainMap<TokenConfig & RouterConfig>;
+
+      deployer = new HypERC20Deployer(multiProvider);
+      contracts = await deployer.deploy(config);
+      local = contracts[localChain].router;
+
+      interchainGasPayment = await local.quoteGasPayment(remoteDomain);
+
+      if (variant === TokenType.native) {
+        interchainGasPayment = interchainGasPayment.add(amount);
+      }
+
+      if (variant === TokenType.collateral) {
+        await erc20!.approve(local.address, amount);
+      }
+
+      remote = contracts[remoteChain].router as HypERC20;
+    });
+
+    it('should not be initializable again', async () => {
+      const initializeTx =
+        variant === TokenType.collateral || variant === TokenType.native
+          ? (local as HypERC20Collateral).initialize(
+              ethers.constants.AddressZero,
+              ethers.constants.AddressZero,
+            )
+          : (local as HypERC20).initialize(
+              ethers.constants.AddressZero,
+              ethers.constants.AddressZero,
+              0,
+              '',
+              '',
+            );
+      await expect(initializeTx).to.be.revertedWith(
+        'Initializable: contract is already initialized',
+      );
+    });
+
+    if (variant === TokenType.synthetic) {
+      it('should mint total supply to deployer', async () => {
+        await expectBalance(local, recipient, 0);
+        await expectBalance(local, owner, totalSupply);
+        await expectBalance(remote, recipient, 0);
+        await expectBalance(remote, owner, totalSupply);
+      });
+
+      it('should allow for local transfers', async () => {
+        await (local as HypERC20).transfer(recipient.address, amount);
+        await expectBalance(local, recipient, amount);
+        await expectBalance(local, owner, totalSupply - amount);
+        await expectBalance(remote, recipient, 0);
+        await expectBalance(remote, owner, totalSupply);
+      });
+    }
+
+    it('benchmark handle gas overhead', async () => {
+      const localRaw = local.connect(ethers.provider);
+      const mailboxAddress = core.contractsMap[localChain].mailbox.address;
+      if (variant === TokenType.collateral) {
+        const tokenAddress = await (local as HypERC20Collateral).wrappedToken();
+        const token = ERC20__factory.connect(tokenAddress, owner);
+        await token.transfer(local.address, totalSupply);
+      } else if (variant === TokenType.native) {
+        const remoteDomain = core.multiProvider.getDomainId(remoteChain);
+        // deposit amount
+        await local.transferRemote(
+          remoteDomain,
+          utils.addressToBytes32(remote.address),
+          amount,
+          { value: interchainGasPayment },
+        );
+      }
+      const message = `${utils.addressToBytes32(
+        recipient.address,
+      )}${BigNumber.from(amount).toHexString().slice(2).padStart(64, '0')}`;
+      const handleGas = await localRaw.estimateGas.handle(
+        remoteDomain,
+        utils.addressToBytes32(remote.address),
+        message,
+        { from: mailboxAddress },
+      );
+      console.log(handleGas);
+    });
+
+    it('should allow for remote transfers', async () => {
+      const localOwner = await local.balanceOf(owner.address);
+      const localRecipient = await local.balanceOf(recipient.address);
+      const remoteOwner = await remote.balanceOf(owner.address);
+      const remoteRecipient = await remote.balanceOf(recipient.address);
+
+      await local.transferRemote(
+        remoteDomain,
+        utils.addressToBytes32(recipient.address),
+        amount,
+        {
+          value: interchainGasPayment,
+        },
+      );
+
+      let expectedLocal = localOwner.sub(amount);
+
+      await expectBalance(local, recipient, localRecipient);
+      if (variant === TokenType.native) {
+        // account for tx fees, rewards, etc.
+        expectedLocal = await local.balanceOf(owner.address);
+      }
+      await expectBalance(local, owner, expectedLocal);
+      await expectBalance(remote, recipient, remoteRecipient);
+      await expectBalance(remote, owner, remoteOwner);
+
+      await core.processMessages();
+
+      await expectBalance(local, recipient, localRecipient);
+      if (variant === TokenType.native) {
+        // account for tx fees, rewards, etc.
+        expectedLocal = await local.balanceOf(owner.address);
+      }
+      await expectBalance(local, owner, expectedLocal);
+      await expectBalance(remote, recipient, remoteRecipient.add(amount));
+      await expectBalance(remote, owner, remoteOwner);
+    });
+
+    it('allows interchain gas payment for remote transfers', async () => {
+      const interchainGasPaymaster = new InterchainGasPaymaster__factory()
+        .attach(await local.interchainGasPaymaster())
+        .connect(owner);
+      await expect(
+        local.transferRemote(
+          remoteDomain,
+          utils.addressToBytes32(recipient.address),
+          amount,
+          { value: interchainGasPayment },
+        ),
+      ).to.emit(interchainGasPaymaster, 'GasPayment');
+    });
+
+    it('should prevent remote transfer of unowned balance', async () => {
+      const revertReason = (): string => {
+        switch (variant) {
+          case TokenType.synthetic:
+            return 'ERC20: burn amount exceeds balance';
+          case TokenType.collateral:
+            return 'ERC20: insufficient allowance';
+          case TokenType.native:
+            return 'Native: amount exceeds msg.value';
+        }
+        return '';
+      };
+      const value =
+        variant === TokenType.native ? amount - 1 : interchainGasPayment;
+      await expect(
+        local
+          .connect(recipient)
+          .transferRemote(
+            remoteDomain,
+            utils.addressToBytes32(recipient.address),
+            amount,
+            { value },
+          ),
+      ).to.be.revertedWith(revertReason());
+    });
+
+    it('should emit TransferRemote events', async () => {
+      expect(
+        await local.transferRemote(
+          remoteDomain,
+          utils.addressToBytes32(recipient.address),
+          amount,
+          { value: interchainGasPayment },
+        ),
+      )
+        .to.emit(local, 'SentTransferRemote')
+        .withArgs(remoteDomain, recipient.address, amount);
+      expect(await core.processMessages())
+        .to.emit(local, 'ReceivedTransferRemote')
+        .withArgs(localDomain, recipient.address, amount);
+    });
+  });
+}
+
+const expectBalance = async (
+  token: HypERC20 | HypERC20Collateral | ERC20 | HypNative,
+  signer: SignerWithAddress,
+  balance: BigNumberish,
+) => {
+  return expect(await token.balanceOf(signer.address)).to.eq(balance);
+};
--- a/typescript/token/test/erc721.test.ts
+++ b/typescript/token/test/erc721.test.ts
@ -0,0 +1,324 @@
+import { SignerWithAddress } from '@nomiclabs/hardhat-ethers/signers';
+import '@nomiclabs/hardhat-waffle';
+import { expect } from 'chai';
+import { BigNumber, BigNumberish } from 'ethers';
+import { ethers } from 'hardhat';
+
+import { InterchainGasPaymaster__factory } from '@hyperlane-xyz/core';
+import {
+  Chains,
+  HyperlaneContractsMap,
+  MultiProvider,
+  TestCoreApp,
+  TestCoreDeployer,
+  deployTestIgpsAndGetRouterConfig,
+  objMap,
+} from '@hyperlane-xyz/sdk';
+import { utils } from '@hyperlane-xyz/utils';
+
+import { TokenConfig, TokenType } from '../src/config';
+import { HypERC721Factories } from '../src/contracts';
+import { HypERC721Deployer } from '../src/deploy';
+import {
+  ERC721,
+  ERC721Test__factory,
+  ERC721__factory,
+  HypERC721,
+  HypERC721Collateral,
+  HypERC721URICollateral,
+  HypERC721URIStorage,
+} from '../src/types';
+
+const localChain = Chains.test1;
+const remoteChain = Chains.test2;
+let localDomain: number;
+let remoteDomain: number;
+const totalSupply = 50;
+const tokenId = 10;
+const tokenId2 = 20;
+const tokenId3 = 30;
+const tokenId4 = 40;
+
+const tokenMetadata = {
+  name: 'HypERC721',
+  symbol: 'HYP',
+  totalSupply,
+};
+
+for (const withCollateral of [true, false]) {
+  for (const withUri of [true, false]) {
+    const tokenConfig: TokenConfig = {
+      type: withUri ? TokenType.syntheticUri : TokenType.synthetic,
+      ...tokenMetadata,
+    };
+
+    const configMap = {
+      test1: tokenConfig,
+      test2: {
+        ...tokenConfig,
+        totalSupply: 0,
+      },
+      test3: {
+        ...tokenConfig,
+        totalSupply: 0,
+      },
+    };
+    describe(`HypERC721${withUri ? 'URI' : ''}${
+      withCollateral ? 'Collateral' : ''
+    }`, async () => {
+      let owner: SignerWithAddress;
+      let recipient: SignerWithAddress;
+      let core: TestCoreApp;
+      let deployer: HypERC721Deployer;
+      let contracts: HyperlaneContractsMap<HypERC721Factories>;
+      let local: HypERC721 | HypERC721Collateral | HypERC721URICollateral;
+      let remote: HypERC721 | HypERC721Collateral | HypERC721URIStorage;
+      let interchainGasPayment: BigNumberish;
+
+      beforeEach(async () => {
+        [owner, recipient] = await ethers.getSigners();
+        const multiProvider = MultiProvider.createTestMultiProvider({
+          signer: owner,
+        });
+        localDomain = multiProvider.getDomainId(localChain);
+        remoteDomain = multiProvider.getDomainId(remoteChain);
+
+        const coreDeployer = new TestCoreDeployer(multiProvider);
+        const coreContractsMaps = await coreDeployer.deploy();
+        core = new TestCoreApp(coreContractsMaps, multiProvider);
+        const coreConfig = await deployTestIgpsAndGetRouterConfig(
+          multiProvider,
+          owner.address,
+          core.contractsMap,
+        );
+        const configWithTokenInfo = objMap(coreConfig, (key) => ({
+          ...coreConfig[key],
+          ...configMap[key],
+          owner: owner.address,
+        }));
+
+        let erc721: ERC721 | undefined;
+        if (withCollateral) {
+          erc721 = await new ERC721Test__factory(owner).deploy(
+            tokenConfig.name,
+            tokenConfig.symbol,
+            tokenConfig.totalSupply,
+          );
+          configWithTokenInfo.test1 = {
+            type: withUri ? TokenType.collateralUri : TokenType.collateral,
+            token: erc721.address,
+            ...coreConfig.test1,
+          };
+        }
+
+        deployer = new HypERC721Deployer(multiProvider);
+        contracts = await deployer.deploy(configWithTokenInfo);
+
+        local = contracts[localChain].router;
+        if (withCollateral) {
+          // approve wrapper to transfer tokens
+          await erc721!.approve(local.address, tokenId);
+          await erc721!.approve(local.address, tokenId2);
+          await erc721!.approve(local.address, tokenId3);
+          await erc721!.approve(local.address, tokenId4);
+        }
+        interchainGasPayment = await local.quoteGasPayment(remoteDomain);
+
+        remote = contracts[remoteChain].router;
+      });
+
+      it('should not be initializable again', async () => {
+        const initializeTx = withCollateral
+          ? (local as HypERC721Collateral).initialize(
+              ethers.constants.AddressZero,
+              ethers.constants.AddressZero,
+            )
+          : (local as HypERC721).initialize(
+              ethers.constants.AddressZero,
+              ethers.constants.AddressZero,
+              0,
+              '',
+              '',
+            );
+        await expect(initializeTx).to.be.revertedWith(
+          'Initializable: contract is already initialized',
+        );
+      });
+
+      it('should mint total supply to deployer on local domain', async () => {
+        await expectBalance(local, recipient, 0);
+        await expectBalance(local, owner, totalSupply);
+        await expectBalance(remote, recipient, 0);
+        await expectBalance(remote, owner, 0);
+      });
+
+      // do not test underlying ERC721 collateral functionality
+      if (!withCollateral) {
+        it('should allow for local transfers', async () => {
+          await (local as HypERC721).transferFrom(
+            owner.address,
+            recipient.address,
+            tokenId,
+          );
+          await expectBalance(local, recipient, 1);
+          await expectBalance(local, owner, totalSupply - 1);
+          await expectBalance(remote, recipient, 0);
+          await expectBalance(remote, owner, 0);
+        });
+      }
+
+      it('should not allow transfers of nonexistent identifiers', async () => {
+        const invalidTokenId = totalSupply + 10;
+        if (!withCollateral) {
+          await expect(
+            (local as HypERC721).transferFrom(
+              owner.address,
+              recipient.address,
+              invalidTokenId,
+            ),
+          ).to.be.revertedWith('ERC721: invalid token ID');
+        }
+        await expect(
+          local.transferRemote(
+            remoteDomain,
+            utils.addressToBytes32(recipient.address),
+            invalidTokenId,
+            { value: interchainGasPayment },
+          ),
+        ).to.be.revertedWith('ERC721: invalid token ID');
+      });
+
+      it('should allow for remote transfers', async () => {
+        await local.transferRemote(
+          remoteDomain,
+          utils.addressToBytes32(recipient.address),
+          tokenId2,
+          { value: interchainGasPayment },
+        );
+
+        await expectBalance(local, recipient, 0);
+        await expectBalance(local, owner, totalSupply - 1);
+        await expectBalance(remote, recipient, 0);
+        await expectBalance(remote, owner, 0);
+
+        await core.processMessages();
+
+        await expectBalance(local, recipient, 0);
+        await expectBalance(local, owner, totalSupply - 1);
+        await expectBalance(remote, recipient, 1);
+        await expectBalance(remote, owner, 0);
+      });
+
+      if (withUri && withCollateral) {
+        it('should relay URI with remote transfer', async () => {
+          const remoteUri = remote as HypERC721URIStorage;
+          await expect(remoteUri.tokenURI(tokenId2)).to.be.revertedWith('');
+
+          await local.transferRemote(
+            remoteDomain,
+            utils.addressToBytes32(recipient.address),
+            tokenId2,
+            { value: interchainGasPayment },
+          );
+
+          await expect(remoteUri.tokenURI(tokenId2)).to.be.revertedWith('');
+
+          await core.processMessages();
+
+          expect(await remoteUri.tokenURI(tokenId2)).to.equal(
+            `TEST-BASE-URI${tokenId2}`,
+          );
+        });
+      }
+
+      it('should prevent remote transfer of unowned id', async () => {
+        const revertReason = withCollateral
+          ? 'ERC721: transfer from incorrect owner'
+          : '!owner';
+        await expect(
+          local
+            .connect(recipient)
+            .transferRemote(
+              remoteDomain,
+              utils.addressToBytes32(recipient.address),
+              tokenId2,
+              { value: interchainGasPayment },
+            ),
+        ).to.be.revertedWith(revertReason);
+      });
+
+      it('benchmark handle gas overhead', async () => {
+        const localRaw = local.connect(ethers.provider);
+        const mailboxAddress = core.contractsMap[localChain].mailbox.address;
+        let tokenIdToUse: number;
+        if (withCollateral) {
+          const tokenAddress = await (
+            local as HypERC721Collateral
+          ).wrappedToken();
+          const token = ERC721__factory.connect(tokenAddress, owner);
+          await token.transferFrom(owner.address, local.address, tokenId);
+          tokenIdToUse = tokenId;
+        } else {
+          tokenIdToUse = totalSupply + 1;
+        }
+        const message = `${utils.addressToBytes32(
+          recipient.address,
+        )}${BigNumber.from(tokenIdToUse)
+          .toHexString()
+          .slice(2)
+          .padStart(64, '0')}`;
+        try {
+          const gas = await localRaw.estimateGas.handle(
+            remoteDomain,
+            utils.addressToBytes32(remote.address),
+            message,
+            { from: mailboxAddress },
+          );
+          console.log(gas);
+        } catch (e) {
+          console.log('FAILED');
+        }
+      });
+
+      it('allows interchain gas payment for remote transfers', async () => {
+        const interchainGasPaymaster = new InterchainGasPaymaster__factory()
+          .attach(await local.interchainGasPaymaster())
+          .connect(owner);
+        await expect(
+          local.transferRemote(
+            remoteDomain,
+            utils.addressToBytes32(recipient.address),
+            tokenId3,
+            {
+              value: interchainGasPayment,
+            },
+          ),
+        ).to.emit(interchainGasPaymaster, 'GasPayment');
+      });
+
+      it('should emit TransferRemote events', async () => {
+        expect(
+          await local.transferRemote(
+            remoteDomain,
+            utils.addressToBytes32(recipient.address),
+            tokenId4,
+            { value: interchainGasPayment },
+          ),
+        )
+          .to.emit(local, 'SentTransferRemote')
+          .withArgs(remoteDomain, recipient.address, tokenId4);
+        expect(await core.processMessages())
+          .to.emit(local, 'ReceivedTransferRemote')
+          .withArgs(localDomain, recipient.address, tokenId4);
+      });
+    });
+  }
+}
+
+const expectBalance = async (
+  token: HypERC721 | HypERC721Collateral | ERC721,
+  signer: SignerWithAddress,
+  balance: number,
+) => {
+  expect(await token.balanceOf(signer.address)).to.eq(balance);
+};
--- a/typescript/token/tsconfig.json
+++ b/typescript/token/tsconfig.json
@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "incremental": false,
+    "lib": ["es2015", "es5", "dom"],
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "noEmitOnError": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitAny": false,
+    "noImplicitReturns": true,
+    "noUnusedLocals": true,
+    "preserveSymlinks": true,
+    "preserveWatchOutput": true,
+    "pretty": false,
+    "sourceMap": true,
+    "target": "es6",
+    "strict": true,
+    "resolveJsonModule": true,
+    "outDir": "./dist",
+    "rootDir": "./src",
+  },
+  "exclude": [
+    "./node_modules/",
+    "./scripts/",
+    "./test/",
+    "./dist/",
+    "./src/types/hardhat.d.ts",
+    "hardhat.config.ts"
+  ],
+}
--- a/typescript/token/yarn.lock
+++ b/typescript/token/yarn.lock
				`@ -1 +0,0 @@`
				`Subproject commit 1bcdd324f4d055a9cae6cc4648c9210e5cd9668b`