Merge pull request #20 from connext/transfer-onchain

add /onchain-transfer endpoint

src/client.ts

@@ -14,6 +14,7 @@ import {
   InitClientManagerOptions,
   InitOptions,
   EventSubscription,
+  transferOnChain,
 } from "./helpers";
 import Subscriber from "./subscriber";
 import { AddressZero } from "ethers/constants";
@@ -150,6 +151,22 @@ export default class ClientManager {
     };
   }
 
+  public async transferOnChain(params: {
+    amount: string;
+    assetId: string;
+    recipient: string;
+  }): Promise<{ txhash: string }> {
+    const client = await this.getClient();
+    const txhash = await transferOnChain({
+      mnemonic: this.mnemonic,
+      ethProvider: client.ethProvider,
+      assetId: params.assetId,
+      amount: params.amount,
+      recipient: params.recipient,
+    });
+    return { txhash };
+  }
+
   public async withdraw(params: PublicParams.Withdraw) {
     const client = this.getClient();
     if (params.assetId === AddressZero) {

src/helpers/ethereum.ts

@@ -1,5 +1,5 @@
 import { IConnextClient, Contract } from "@connext/types";
-import { constants } from "ethers";
+import { constants, Wallet, providers } from "ethers";
 import tokenAbi from "human-standard-token-abi";
 
 export async function getFreeBalanceOffChain(client: IConnextClient, assetId: string) {
@@ -18,8 +18,32 @@ export async function getFreeBalanceOnChain(client: IConnextClient, assetId: str
       ).toString();
 }
 
-export async function getClientBalance(client: IConnextClient, assetId) {
+export async function getClientBalance(client: IConnextClient, assetId: string) {
   const freeBalanceOffChain = await getFreeBalanceOffChain(client, assetId);
   const freeBalanceOnChain = await getFreeBalanceOnChain(client, assetId);
   return { freeBalanceOffChain, freeBalanceOnChain };
 }
+
+export async function transferOnChain(params: {
+  mnemonic: string;
+  ethProvider: providers.Provider;
+  assetId: string;
+  amount: string;
+  recipient: string;
+}): Promise<string> {
+  let tx: providers.TransactionResponse;
+  const wallet = Wallet.fromMnemonic(params.mnemonic).connect(params.ethProvider);
+  if (params.assetId === constants.AddressZero) {
+    tx = await wallet.sendTransaction({
+      to: params.recipient,
+      value: params.amount,
+    });
+  } else {
+    const token = new Contract(params.assetId, tokenAbi, params.ethProvider);
+    tx = await token.transfer([params.recipient, params.amount]);
+  }
+  if (typeof tx.hash === "undefined") {
+    throw new Error("Transaction hash is undefined");
+  }
+  return tx.hash;
+}

src/index.ts

@@ -123,6 +123,18 @@ app.post("/mnemonic", async (req, res) => {
   }
 });
 
+app.post("/onchain-transfer", async (req, res) => {
+  try {
+    await requireParam(req.body, "amount");
+    await requireParam(req.body, "assetId");
+    await requireParam(req.body, "recipient");
+    res.status(200).send(await clientManager.transferOnChain(req.body));
+  } catch (error) {
+    app.log.error(error);
+    res.status(500).send({ message: error.message });
+  }
+});
+
 app.post("/hashlock-transfer", async (req, res) => {
   try {
     await requireParam(req.body, "amount");