@layerzerolabs/onesig-core 0.0.7 → 0.0.9

package/dist/index.d.mts

@@ -0,0 +1,51 @@
+import { BigNumber } from 'ethers';
+import { MerkleTree } from 'merkletreejs';
+export { MerkleTree } from 'merkletreejs';
+import { TypedDataSigner } from '@ethersproject/abstract-signer';
+
+interface BaseLeafData<TargetAddressType = unknown, CallData = unknown> {
+    nonce: bigint;
+    oneSigId: bigint;
+    targetOneSigAddress: TargetAddressType;
+    calls: CallData[];
+}
+interface SigningOptions {
+    seed: string | Uint8Array;
+    expiry: number | string | BigNumber;
+}
+interface GenerateLeafsResult<Leaf extends BaseLeafData = BaseLeafData<any, any>> {
+    encodeCalls: (calls: Leaf['calls']) => Buffer;
+    encodeAddress: (address: Leaf['targetOneSigAddress']) => Buffer;
+    leafs: Leaf[];
+}
+declare function encodeLeafHeader({ targetOneSigAddress, oneSigId, nonce }: Omit<BaseLeafData<Buffer>, 'calls'>): Buffer;
+declare function encodeLeaf(gen: GenerateLeafsResult, index: number): string;
+declare function makeOneSigTree(input: GenerateLeafsResult[]): MerkleTree;
+declare function compareAddresses(a: string, b: string): number;
+type HexStringLike = `0x${string}`;
+type SignatureLike = Buffer | string | Signature | HexStringLike;
+declare class Signature {
+    #private;
+    constructor(input: SignatureLike);
+    get(): Buffer;
+    toHexString(): HexStringLike;
+    get signatureCount(): number;
+    /**
+     * Concatenate signatures without changing ordering
+     */
+    static concatenateSignatures(input: SignatureLike[], sortMethod: false): Signature;
+    /**
+     * Concatenate signatures based on addresses provided, with each signature corresponding to the address in the same index
+     */
+    static concatenateSignatures(input: SignatureLike[], addresses: string[]): Signature;
+    /**
+     * Concatenate signatures based on the signature data, ordering based on the recovered address
+     */
+    static concatenateSignatures(input: SignatureLike[], digest: Buffer | string): Signature;
+}
+declare function getSigningData(tree: MerkleTree, { seed, expiry }: SigningOptions): Parameters<TypedDataSigner['_signTypedData']>;
+declare function getDigestToSign(tree: MerkleTree, options: SigningOptions): string;
+declare function signOneSigTree(tree: MerkleTree, signers: TypedDataSigner[], options: SigningOptions, enc?: 'string'): Promise<string>;
+declare function signOneSigTree(tree: MerkleTree, signers: TypedDataSigner[], options: SigningOptions, enc: 'signature'): Promise<Signature>;
+
+export { type BaseLeafData, type GenerateLeafsResult, Signature, type SigningOptions, compareAddresses, encodeLeaf, encodeLeafHeader, getDigestToSign, getSigningData, makeOneSigTree, signOneSigTree };

package/dist/index.js

@@ -1,3 +1,4 @@
+"use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
@@ -75,16 +76,16 @@ function encodeLeafHeader({ targetOneSigAddress, oneSigId, nonce }) {
   if (targetOneSigAddress.byteLength !== 32) {
     throw new Error("Contract address must be 32 bytes");
   }
-  const storage = Buffer.alloc(73);
+  const storage = Buffer.alloc(49);
   storage[0] = 1;
   const idStr = oneSigId.toString(16).padStart(16, "0");
-  const nonceStr = nonce.toString(16).padStart(64, "0");
+  const nonceStr = nonce.toString(16).padStart(16, "0");
   for (let i = 0; i < 32; i++) {
     if (i < 8) {
       storage[i + 1] = readByteFromHex(idStr, i);
+      storage[i + 41] = readByteFromHex(nonceStr, i);
     }
     storage[i + 9] = targetOneSigAddress[i];
-    storage[i + 41] = readByteFromHex(nonceStr, i);
   }
   return storage;
 }
@@ -101,7 +102,7 @@ function encodeLeaf(gen, index) {
     }),
     gen.encodeCalls(leaf.calls)
   ]);
-  return import_ethers.ethers.utils.keccak256(leafData);
+  return import_ethers.ethers.utils.keccak256(import_ethers.ethers.utils.keccak256(leafData));
 }
 function makeOneSigTree(input) {
   const encodedLeafs = [];
@@ -184,7 +185,7 @@ var _Signature = class _Signature {
       return signature.get();
     });
     let orderedSignatures;
-    if (!sortMethod) {
+    if (sortMethod === false) {
       orderedSignatures = signatureBuffers;
     } else {
       let addresses;
@@ -208,7 +209,8 @@ var _Signature = class _Signature {
       });
       orderedSignatures = indexMapping.map((index) => signatureBuffers[index]);
     }
-    return new this(Buffer.concat(orderedSignatures));
+    const combined = Buffer.concat(orderedSignatures);
+    return new this(combined);
   }
 };
 _value = new WeakMap();

package/dist/index.mjs

@@ -0,0 +1,245 @@
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+
+// src/index.ts
+import { ethers } from "ethers";
+import { MerkleTree } from "merkletreejs";
+
+// src/error.ts
+var _code;
+var _OneSigCoreError = class _OneSigCoreError extends Error {
+  constructor(code, message) {
+    super(`[${code}] ${message}`);
+    __privateAdd(this, _code);
+    __privateSet(this, _code, code);
+  }
+  get code() {
+    return __privateGet(this, _code);
+  }
+  static is(input, code) {
+    if (input instanceof _OneSigCoreError) {
+      if (code) {
+        return input.code === code;
+      }
+      return true;
+    } else {
+      return false;
+    }
+  }
+};
+_code = new WeakMap();
+var OneSigCoreError = _OneSigCoreError;
+
+// src/index.ts
+function readByteFromHex(input, byteOffset) {
+  const charOffset = byteOffset * 2;
+  const sub = input.substring(charOffset, charOffset + 2);
+  return parseInt(sub, 16);
+}
+function encodeLeafHeader({ targetOneSigAddress, oneSigId, nonce }) {
+  if (targetOneSigAddress.byteLength !== 32) {
+    throw new Error("Contract address must be 32 bytes");
+  }
+  const storage = Buffer.alloc(49);
+  storage[0] = 1;
+  const idStr = oneSigId.toString(16).padStart(16, "0");
+  const nonceStr = nonce.toString(16).padStart(16, "0");
+  for (let i = 0; i < 32; i++) {
+    if (i < 8) {
+      storage[i + 1] = readByteFromHex(idStr, i);
+      storage[i + 41] = readByteFromHex(nonceStr, i);
+    }
+    storage[i + 9] = targetOneSigAddress[i];
+  }
+  return storage;
+}
+function encodeLeaf(gen, index) {
+  const leaf = gen.leafs[index];
+  if (!leaf) {
+    throw new Error("Leaf does not exist");
+  }
+  const leafData = Buffer.concat([
+    encodeLeafHeader({
+      nonce: leaf.nonce,
+      oneSigId: leaf.oneSigId,
+      targetOneSigAddress: gen.encodeAddress(leaf.targetOneSigAddress)
+    }),
+    gen.encodeCalls(leaf.calls)
+  ]);
+  return ethers.utils.keccak256(ethers.utils.keccak256(leafData));
+}
+function makeOneSigTree(input) {
+  const encodedLeafs = [];
+  const seenNonceIds = /* @__PURE__ */ new Set();
+  for (const gen of input) {
+    for (let i = 0; i < gen.leafs.length; i++) {
+      const leaf = gen.leafs[i];
+      const nonceIdCombo = `${leaf.nonce}.${leaf.oneSigId}`;
+      if (seenNonceIds.has(nonceIdCombo)) {
+        throw new OneSigCoreError(
+          "NONCE_ID_SEEN_TWICE",
+          "Two calls should not be made for the same chain/nonce twice"
+        );
+      }
+      seenNonceIds.add(nonceIdCombo);
+      encodedLeafs.push(encodeLeaf(gen, i));
+    }
+  }
+  const tree = new MerkleTree(encodedLeafs, ethers.utils.keccak256, { sortPairs: true });
+  return tree;
+}
+function compareAddresses(a, b) {
+  const aNumeric = BigInt(a);
+  const bNumeric = BigInt(b);
+  if (aNumeric === bNumeric) {
+    return 0;
+  } else if (aNumeric < bNumeric) {
+    return -1;
+  } else {
+    return 1;
+  }
+}
+var _value;
+var _Signature = class _Signature {
+  constructor(input) {
+    __privateAdd(this, _value);
+    let value = input;
+    if (value instanceof _Signature) {
+      value = value.get();
+    }
+    if (typeof value === "string") {
+      if (!value.startsWith("0x")) {
+        throw new OneSigCoreError(
+          "INVALID_SIGNATURE_INPUT",
+          "Signature takes in hex encoded strings prefixed with 0x only"
+        );
+      }
+      value = Buffer.from(value.substring(2), "hex");
+    }
+    if (value.length % 65 !== 0) {
+      throw new OneSigCoreError("INVALID_SIGNATURE_INPUT", "Each signature must be 65 bytes long");
+    }
+    __privateSet(this, _value, value);
+  }
+  get() {
+    return __privateGet(this, _value);
+  }
+  toHexString() {
+    return `0x${this.get().toString("hex")}`;
+  }
+  get signatureCount() {
+    const count = __privateGet(this, _value).length / 65;
+    if (Math.floor(count) !== count) {
+      throw new Error("Count is not an int");
+    }
+    return count;
+  }
+  /**
+   * Concatenate and order signatures based on data provided
+   * @param input An array of signatures to concat
+   * @param sortMethod Parameter specifing how to order each signature
+   * @returns The concatenated signature
+   */
+  static concatenateSignatures(input, sortMethod) {
+    const signatureBuffers = input.map(function(singleInput) {
+      const signature = new _Signature(singleInput);
+      if (signature.signatureCount !== 1) {
+        throw new OneSigCoreError("CANNOT_CONCAT_INPUT", "Cannot concatenate pre-concatenated signatures");
+      }
+      return signature.get();
+    });
+    let orderedSignatures;
+    if (sortMethod === false) {
+      orderedSignatures = signatureBuffers;
+    } else {
+      let addresses;
+      if (typeof sortMethod === "string" || Buffer.isBuffer(sortMethod)) {
+        addresses = [];
+        for (const signature of signatureBuffers) {
+          const recovered = ethers.utils.recoverAddress(sortMethod, signature);
+          addresses.push(recovered);
+        }
+      } else {
+        addresses = sortMethod;
+      }
+      if (addresses.length !== signatureBuffers.length) {
+        throw new OneSigCoreError(
+          "ADDRESS_SIGNATURE_LENGTH_MISMATCH",
+          "Mismatch in addresses provided signatures"
+        );
+      }
+      const indexMapping = new Array(addresses.length).fill(0).map((_, i) => i).sort(function(a, b) {
+        return compareAddresses(addresses[a], addresses[b]);
+      });
+      orderedSignatures = indexMapping.map((index) => signatureBuffers[index]);
+    }
+    const combined = Buffer.concat(orderedSignatures);
+    return new this(combined);
+  }
+};
+_value = new WeakMap();
+var Signature = _Signature;
+function getSigningData(tree, { seed, expiry }) {
+  return [
+    {
+      name: "OneSig",
+      version: "0.0.1",
+      chainId: 1,
+      // this is hardcoded to Ethereum mainnet
+      verifyingContract: "0x000000000000000000000000000000000000dEaD"
+      // this is hardcoded to a dead address
+    },
+    {
+      SignMerkleRoot: [
+        { name: "seed", type: "bytes32" },
+        { name: "merkleRoot", type: "bytes32" },
+        { name: "expiry", type: "uint256" }
+      ]
+    },
+    {
+      seed,
+      expiry,
+      merkleRoot: tree.getRoot()
+    }
+  ];
+}
+function getDigestToSign(tree, options) {
+  return ethers.utils._TypedDataEncoder.hash(...getSigningData(tree, options));
+}
+async function signOneSigTree(tree, signers, options, enc = "string") {
+  if (signers.length <= 0) {
+    throw new OneSigCoreError("ONE_SIGNER_REQUIRED", "1+ signer must be provided");
+  }
+  const toSign = getSigningData(tree, options);
+  const signatures = await Promise.all(
+    signers.map(async function(signer) {
+      const data = await signer._signTypedData(...toSign);
+      return new Signature(data);
+    })
+  );
+  const signingDigest = ethers.utils._TypedDataEncoder.hash(...toSign);
+  const sig = Signature.concatenateSignatures(signatures, signingDigest);
+  if (enc === "signature") {
+    return sig;
+  } else if (enc === "string") {
+    return sig.toHexString();
+  } else {
+    throw new Error("Invalid encoding");
+  }
+}
+export {
+  MerkleTree,
+  Signature,
+  compareAddresses,
+  encodeLeaf,
+  encodeLeafHeader,
+  getDigestToSign,
+  getSigningData,
+  makeOneSigTree,
+  signOneSigTree
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@layerzerolabs/onesig-core",
-  "version": "0.0.7",
-  "license": "MIT",
+  "version": "0.0.9",
+  "license": "GPL-3.0-only",
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
@@ -11,6 +11,7 @@
     "./package.json": "./package.json"
   },
   "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
     "dist/**/*"
   ],
@@ -58,7 +59,7 @@
     "access": "restricted"
   },
   "scripts": {
-    "build:js": "pnpm tsup",
+    "build:js": "pnpm tsup --config ../../tsup.config.ts ./src/index.ts",
     "clean": "pnpm clean:prebuild",
     "clean:prebuild": "rimraf dist",
     "lint:fix": "eslint --fix '**/*.{js,ts,json}' && prettier --write .",