@layerzerolabs/onesig-core 0.0.5 → 0.0.6

package/dist/index.d.ts

@@ -5,7 +5,7 @@ import { TypedDataSigner } from '@ethersproject/abstract-signer';
 
 interface BaseLeafData<TargetAddressType = unknown, CallData = unknown> {
     nonce: bigint;
-    chainId: bigint;
+    oneSigId: bigint;
     targetOneSigAddress: TargetAddressType;
     calls: CallData[];
 }
@@ -14,9 +14,12 @@ interface SigningOptions {
     expiry: number | string | BigNumber;
 }
 interface GenerateLeafsResult<Leaf extends BaseLeafData = BaseLeafData<any, any>> {
-    encodeLeaf: (leaf: Leaf) => string;
+    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}`;
@@ -40,8 +43,9 @@ declare class Signature {
      */
     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, getDigestToSign, makeOneSigTree, signOneSigTree };
+export { type BaseLeafData, type GenerateLeafsResult, Signature, type SigningOptions, compareAddresses, encodeLeaf, encodeLeafHeader, getDigestToSign, getSigningData, makeOneSigTree, signOneSigTree };

package/dist/index.js

@@ -29,7 +29,10 @@ __export(src_exports, {
   MerkleTree: () => import_merkletreejs.MerkleTree,
   Signature: () => Signature,
   compareAddresses: () => compareAddresses,
+  encodeLeaf: () => encodeLeaf,
+  encodeLeafHeader: () => encodeLeafHeader,
   getDigestToSign: () => getDigestToSign,
+  getSigningData: () => getSigningData,
   makeOneSigTree: () => makeOneSigTree,
   signOneSigTree: () => signOneSigTree
 });
@@ -63,28 +66,59 @@ _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(97);
+  storage[0] = 1;
+  const idStr = oneSigId.toString(16).padStart(64, "0");
+  const nonceStr = nonce.toString(16).padStart(64, "0");
+  for (let i = 0; i < 32; i++) {
+    storage[i + 1] = readByteFromHex(idStr, i);
+    storage[i + 33] = targetOneSigAddress[i];
+    storage[i + 65] = readByteFromHex(nonceStr, 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 import_ethers.ethers.utils.keccak256(leafData);
+}
 function makeOneSigTree(input) {
-  const encodedLeafs = /* @__PURE__ */ new Set();
-  const seenNonceChains = /* @__PURE__ */ new Set();
-  for (const { leafs, encodeLeaf } of input) {
-    for (const leaf of leafs) {
-      const nonceChainCombo = `${leaf.nonce}.${leaf.chainId}`;
-      if (seenNonceChains.has(nonceChainCombo)) {
+  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_CHAIN_SEEN_TWICE",
+          "NONCE_ID_SEEN_TWICE",
           "Two calls should not be made for the same chain/nonce twice"
         );
       }
-      seenNonceChains.add(nonceChainCombo);
-      const encoded = encodeLeaf(leaf);
-      if (encodedLeafs.has(encoded)) {
-        throw new OneSigCoreError("LEAF_SEEN_TWICE", "Encoded leaf cannot be seen twice");
-      }
-      encodedLeafs.add(encoded);
+      seenNonceIds.add(nonceIdCombo);
+      encodedLeafs.push(encodeLeaf(gen, i));
     }
   }
-  const asArray = Array.from(encodedLeafs);
-  const tree = new import_merkletreejs.MerkleTree(asArray, import_ethers.ethers.utils.keccak256, { sortPairs: true });
+  const tree = new import_merkletreejs.MerkleTree(encodedLeafs, import_ethers.ethers.utils.keccak256, { sortPairs: true });
   return tree;
 }
 function compareAddresses(a, b) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@layerzerolabs/onesig-core",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "license": "MIT",
   "exports": {
     ".": {
@@ -31,8 +31,8 @@
   "devDependencies": {
     "@babel/core": "^7.23.9",
     "@jest/globals": "^29.7.0",
-    "@layerzerolabs/eslint-config-next": "^3.0.59",
-    "@layerzerolabs/prettier-config-next": "^3.0.59",
+    "@layerzerolabs/eslint-config-next": "^3.0.75",
+    "@layerzerolabs/prettier-config-next": "^3.0.75",
     "@openzeppelin/contracts": "5.0.2",
     "@openzeppelin/contracts-upgradeable": "5.0.2",
     "@rushstack/eslint-patch": "^1.7.0",