@layerzerolabs/onesig-core 0.0.8 → 0.1.0

package/dist/index.d.mts

@@ -0,0 +1,54 @@
+import { BigNumber, TypedDataDomain, TypedDataField } 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 getOneSigTypedDataDomain(): TypedDataDomain;
+declare function getOneSigTypedDataDomainTypes(): Record<string, TypedDataField[]>;
+declare function getOneSigTypedDataPrimaryTypes(): Record<string, TypedDataField[]>;
+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, getOneSigTypedDataDomain, getOneSigTypedDataDomainTypes, getOneSigTypedDataPrimaryTypes, getSigningData, makeOneSigTree, signOneSigTree };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { BigNumber } from 'ethers';
+import { BigNumber, TypedDataDomain, TypedDataField } from 'ethers';
 import { MerkleTree } from 'merkletreejs';
 export { MerkleTree } from 'merkletreejs';
 import { TypedDataSigner } from '@ethersproject/abstract-signer';
@@ -43,9 +43,12 @@ declare class Signature {
      */
     static concatenateSignatures(input: SignatureLike[], digest: Buffer | string): Signature;
 }
+declare function getOneSigTypedDataDomain(): TypedDataDomain;
+declare function getOneSigTypedDataDomainTypes(): Record<string, TypedDataField[]>;
+declare function getOneSigTypedDataPrimaryTypes(): Record<string, TypedDataField[]>;
 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 };
+export { type BaseLeafData, type GenerateLeafsResult, Signature, type SigningOptions, compareAddresses, encodeLeaf, encodeLeafHeader, getDigestToSign, getOneSigTypedDataDomain, getOneSigTypedDataDomainTypes, getOneSigTypedDataPrimaryTypes, getSigningData, makeOneSigTree, signOneSigTree };

package/dist/index.js

@@ -33,6 +33,9 @@ __export(src_exports, {
   encodeLeaf: () => encodeLeaf,
   encodeLeafHeader: () => encodeLeafHeader,
   getDigestToSign: () => getDigestToSign,
+  getOneSigTypedDataDomain: () => getOneSigTypedDataDomain,
+  getOneSigTypedDataDomainTypes: () => getOneSigTypedDataDomainTypes,
+  getOneSigTypedDataPrimaryTypes: () => getOneSigTypedDataPrimaryTypes,
   getSigningData: () => getSigningData,
   makeOneSigTree: () => makeOneSigTree,
   signOneSigTree: () => signOneSigTree
@@ -215,27 +218,46 @@ var _Signature = class _Signature {
 };
 _value = new WeakMap();
 var Signature = _Signature;
+var ONE_SIG_TYPED_DATA_DOMAIN = {
+  name: "OneSig",
+  version: "0.0.1",
+  chainId: 1,
+  // this is hardcoded to Ethereum mainnet
+  verifyingContract: "0x000000000000000000000000000000000000dEaD"
+  // this is hardcoded to a dead address
+};
+function getOneSigTypedDataDomain() {
+  return ONE_SIG_TYPED_DATA_DOMAIN;
+}
+var ONE_SIG_TYPED_DATA_DOMAIN_TYPES = {
+  EIP712Domain: [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" }
+  ]
+};
+function getOneSigTypedDataDomainTypes() {
+  return ONE_SIG_TYPED_DATA_DOMAIN_TYPES;
+}
+var ONE_SIG_TYPED_DATA_PRIMARY_TYPES = {
+  SignMerkleRoot: [
+    { name: "seed", type: "bytes32" },
+    { name: "merkleRoot", type: "bytes32" },
+    { name: "expiry", type: "uint256" }
+  ]
+};
+function getOneSigTypedDataPrimaryTypes() {
+  return ONE_SIG_TYPED_DATA_PRIMARY_TYPES;
+}
 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" }
-      ]
-    },
+    getOneSigTypedDataDomain(),
+    getOneSigTypedDataPrimaryTypes(),
     {
       seed,
       expiry,
-      merkleRoot: tree.getRoot()
+      merkleRoot: tree.getHexRoot()
     }
   ];
 }

package/dist/index.mjs

@@ -0,0 +1,267 @@
+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;
+var ONE_SIG_TYPED_DATA_DOMAIN = {
+  name: "OneSig",
+  version: "0.0.1",
+  chainId: 1,
+  // this is hardcoded to Ethereum mainnet
+  verifyingContract: "0x000000000000000000000000000000000000dEaD"
+  // this is hardcoded to a dead address
+};
+function getOneSigTypedDataDomain() {
+  return ONE_SIG_TYPED_DATA_DOMAIN;
+}
+var ONE_SIG_TYPED_DATA_DOMAIN_TYPES = {
+  EIP712Domain: [
+    { name: "name", type: "string" },
+    { name: "version", type: "string" },
+    { name: "chainId", type: "uint256" },
+    { name: "verifyingContract", type: "address" }
+  ]
+};
+function getOneSigTypedDataDomainTypes() {
+  return ONE_SIG_TYPED_DATA_DOMAIN_TYPES;
+}
+var ONE_SIG_TYPED_DATA_PRIMARY_TYPES = {
+  SignMerkleRoot: [
+    { name: "seed", type: "bytes32" },
+    { name: "merkleRoot", type: "bytes32" },
+    { name: "expiry", type: "uint256" }
+  ]
+};
+function getOneSigTypedDataPrimaryTypes() {
+  return ONE_SIG_TYPED_DATA_PRIMARY_TYPES;
+}
+function getSigningData(tree, { seed, expiry }) {
+  return [
+    getOneSigTypedDataDomain(),
+    getOneSigTypedDataPrimaryTypes(),
+    {
+      seed,
+      expiry,
+      merkleRoot: tree.getHexRoot()
+    }
+  ];
+}
+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,
+  getOneSigTypedDataDomain,
+  getOneSigTypedDataDomainTypes,
+  getOneSigTypedDataPrimaryTypes,
+  getSigningData,
+  makeOneSigTree,
+  signOneSigTree
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/onesig-core",
-  "version": "0.0.8",
+  "version": "0.1.0",
   "license": "GPL-3.0-only",
   "exports": {
     ".": {
@@ -59,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 .",