@across-protocol/sdk 3.0.0

package/src/merkleDistributor/README.md

@@ -0,0 +1,30 @@
+# Merkle Distributor 
+
+This package contains the logic for managing Merkle trees: create leafs, generate Merkle trees and proofs.
+Also, `MerkleDistributor` is a wrapper around the Merkle tree which is used for managing the recipients of the ACX token airdrop.
+
+## Usage
+
+See tests for more documentation: [MerkleDistributor]("./test/MerkleDistributor.test.ts")
+
+```ts
+import * as across from "@across-protocol/sdk";
+
+const { MerkleDistributor, MerkleTree, DistributionRecipient } = across.merkleDistributor;
+
+const windowIndex = 0;
+const recipients: DistributionRecipient[] = [
+  {
+    account: "0x00b591bc2b682a0b30dd72bac9406bfa13e5d3cd",
+    accountIndex: 0,
+    amount: "1000000000000000000",
+    metadata: {
+      amountBreakdown: {
+        name: "5000000000000000",
+      },
+    },
+  },
+// ...other recipients data
+];
+const { merkleRoot, recipientsWithProofs } = MerkleDistributor.createMerkleDistributionProofs(recipients, windowIndex);
+```

package/src/merkleDistributor/index.ts

@@ -0,0 +1,2 @@
+export * from "./model";
+export * from "./MerkleDistributor";

package/src/merkleDistributor/model/Distribution.ts

@@ -0,0 +1,17 @@
+export type DistributionRecipientsWithProofs = { [address: string]: DistributionRecipientWithProof };
+
+export type DistributionRecipient = {
+  amount: string;
+  account: string;
+  accountIndex: number;
+  metadata: {
+    amountBreakdown: {
+      [name: string]: string;
+    };
+  };
+};
+
+export type DistributionRecipientWithProof = DistributionRecipient & {
+  windowIndex: number;
+  proof: string[];
+};

package/src/merkleDistributor/model/index.ts

@@ -0,0 +1 @@
+export * from "./Distribution";

package/src/pool/TransactionManager.ts

@@ -0,0 +1,73 @@
+import assert from "assert";
+import { Signer } from "ethers";
+import { TransactionRequest, TransactionReceipt } from "@ethersproject/abstract-provider";
+
+function makeKey(tx: TransactionRequest) {
+  return JSON.stringify(
+    Object.entries(tx).map(([key, value]) => {
+      return [key, (value || "").toString()];
+    })
+  );
+}
+
+type Config = {
+  confirmations?: number;
+};
+export type Emit = (event: string, key: string, data: TransactionReceipt | string | TransactionRequest | Error) => void;
+export default (config: Config, signer: Signer, emit: Emit = () => null) => {
+  assert(signer.provider, "signer requires a provider, use signer.connect(provider)");
+  const { confirmations = 3 } = config;
+  const requests = new Map<string, TransactionRequest>();
+  const submissions = new Map<string, string>();
+  const mined = new Map<string, TransactionReceipt>();
+  function request(unsignedTx: TransactionRequest) {
+    // this no longer calls signer.populateTransaction, to allow metamask to fill in missing details instead
+    // use overrides if you want to manually fill in other tx details, including the overrides.customData field.
+    const populated = unsignedTx;
+    const key = makeKey(populated);
+    assert(!requests.has(key), "Transaction already in progress");
+    requests.set(key, populated);
+    return key;
+  }
+  async function processRequest(key: string) {
+    const request = requests.get(key);
+    assert(request, "invalid request");
+    // always delete request, it should only be submitted once
+    requests.delete(key);
+    try {
+      const sent = await signer.sendTransaction(request);
+      submissions.set(key, sent.hash);
+      emit("submitted", key, sent.hash);
+    } catch (err) {
+      emit("error", key, err as Error);
+    }
+  }
+  async function processSubmission(key: string) {
+    const hash = submissions.get(key);
+    assert(hash, "invalid submission");
+    assert(signer.provider, "signer requires a provider, use signer.connect(provider)");
+    // we look for this transaction, but it may never find it if its sped up
+    const receipt = await signer.provider.getTransactionReceipt(hash).catch(() => undefined);
+    if (receipt == null) return;
+    if (receipt.confirmations < confirmations) return;
+    submissions.delete(key);
+    mined.set(key, receipt);
+    emit("mined", key, receipt);
+  }
+  function isMined(key: string) {
+    return mined.get(key);
+  }
+  async function update() {
+    for (const key of Object.keys(requests)) {
+      await processRequest(key);
+    }
+    for (const key of Object.keys(submissions)) {
+      await processSubmission(key);
+    }
+  }
+  return {
+    request,
+    isMined,
+    update,
+  };
+};

package/src/pool/index.ts

@@ -0,0 +1 @@
+export * from "./poolClient";