@0xsequence/replacer 2.3.18 → 2.3.20

package/dist/0xsequence-replacer.cjs.d.ts

@@ -1,2 +1,2 @@
-export * from "../src/index.js";
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMHhzZXF1ZW5jZS1yZXBsYWNlci5janMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSJ9
+export * from "./declarations/src/index.js";
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMHhzZXF1ZW5jZS1yZXBsYWNlci5janMuZC50cyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4vZGVjbGFyYXRpb25zL3NyYy9pbmRleC5kLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBIn0=

package/dist/0xsequence-replacer.cjs.dev.js

@@ -0,0 +1,127 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ethers = require('ethers');
+var abi = require('@0xsequence/abi');
+var core = require('@0xsequence/core');
+
+function useGateway(uri, gateway) {
+  const clean = uri.replace('ipfs://ipfs/', '').replace('ipfs://', '');
+  if (uri.startsWith('ipfs://')) return `${gateway}${clean}`;
+  return uri;
+}
+function isIPFS(uri) {
+  return uri.startsWith('ipfs://');
+}
+
+class CachedEIP5719 {
+  constructor(provider, solver, window = 1000) {
+    this.provider = provider;
+    this.solver = solver;
+    this.window = window;
+    this.pending = new Map();
+  }
+  async runByEIP5719(address, digest, signature) {
+    const key = `${address}-${digest}-${signature}`;
+    const now = Date.now();
+    if (this.pending.has(key) && now - this.pending.get(key).timestamp < this.window) {
+      return this.pending.get(key).promise;
+    }
+    const promise = runByEIP5719(address, this.provider, digest, signature, this.solver);
+    this.pending.set(key, {
+      timestamp: now,
+      promise
+    });
+    return promise;
+  }
+}
+
+function eip5719Contract(address, provider) {
+  // TODO: for some reason walletContracts is not being loaded from local
+  // remove this code once fixed
+  const abi = [{
+    inputs: [{
+      internalType: 'bytes32',
+      type: 'bytes32'
+    }],
+    name: 'getAlternativeSignature',
+    outputs: [{
+      internalType: 'string',
+      type: 'string'
+    }],
+    stateMutability: 'view',
+    type: 'function'
+  }];
+  return new ethers.ethers.Contract(address, abi, provider);
+}
+function eip1271Contract(address, provider) {
+  return new ethers.ethers.Contract(address, abi.walletContracts.erc1271.abi, provider);
+}
+async function isValidSignature(address, provider, digest, signature) {
+  // First we try to validate the signature using Ethers
+  try {
+    const addr = ethers.ethers.recoverAddress(digest, ethers.ethers.hexlify(signature));
+    if (addr.toLowerCase() === address.toLowerCase()) return true;
+  } catch (_unused) {}
+
+  // Then we try to validate the signature using EIP1271
+  try {
+    const contract = eip1271Contract(address, provider);
+    const value = await contract.isValidSignature(digest, signature);
+    if (value === abi.walletContracts.erc1271.returns) return true;
+  } catch (_unused2) {}
+
+  // If all else fails, we return false
+  return false;
+}
+async function tryAwait(promise) {
+  try {
+    return await promise;
+  } catch (_unused3) {
+    return undefined;
+  }
+}
+async function runByEIP5719(address, provider, digest, signature, solver, tries = 0) {
+  if (tries > 10) throw new Error('EIP5719 - Too many tries');
+  if (core.commons.signer.canRecover(signature)) {
+    const recoveredAddr = core.commons.signer.recoverSigner(digest, signature);
+    if (recoveredAddr && recoveredAddr.toLowerCase() === address.toLowerCase()) return signature;
+  }
+  try {
+    if (await core.commons.signer.isValidSignature(address, digest, signature, provider)) {
+      return signature;
+    }
+  } catch (_unused4) {}
+  const altUri = await tryAwait(eip5719Contract(address, provider).getAlternativeSignature(digest));
+  if (!altUri || altUri === '') throw new Error('EIP5719 - Invalid signature and no alternative signature');
+  const altSignature = ethers.ethers.hexlify(await (solver || new URISolverIPFS()).resolve(altUri));
+  if (!altSignature || altSignature === '') throw new Error('EIP5719 - Empty alternative signature');
+  if (altSignature === ethers.ethers.hexlify(signature)) {
+    throw new Error('EIP5719 - Alternative signature is invalid or the same');
+  }
+  return runByEIP5719(address, provider, digest, altSignature, solver, tries + 1);
+}
+class URISolverIPFS {
+  constructor(gateway = 'https://cloudflare-ipfs.com/ipfs/') {
+    var _this = this;
+    this.gateway = gateway;
+    this.uri = uri => {
+      if (isIPFS(uri)) return useGateway(uri, this.gateway);
+      return uri;
+    };
+    this.resolve = async function (uri) {
+      const url = _this.uri(uri);
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`URISolverIPFS - Failed to fetch ${url}`);
+      return await res.text();
+    };
+  }
+}
+
+exports.CachedEIP5719 = CachedEIP5719;
+exports.URISolverIPFS = URISolverIPFS;
+exports.eip1271Contract = eip1271Contract;
+exports.eip5719Contract = eip5719Contract;
+exports.isValidSignature = isValidSignature;
+exports.runByEIP5719 = runByEIP5719;

package/dist/0xsequence-replacer.cjs.js

@@ -1,16 +1,7 @@
-"use strict";
-// this file might look strange and you might be wondering what it's for
-// it's lets you import your source files by importing this entrypoint
-// as you would import it if it was built with preconstruct build
-// this file is slightly different to some others though
-// it has a require hook which compiles your code with Babel
-// this means that you don't have to set up @babel/register or anything like that
-// but you can still require this module and it'll be compiled
+'use strict';
 
-// this bit of code imports the require hook and registers it
-let unregister = require("../../../node_modules/.pnpm/@preconstruct+hook@0.4.0/node_modules/@preconstruct/hook").___internalHook(typeof __dirname === 'undefined' ? undefined : __dirname, "../../..", "..");
-
-// this re-exports the source file
-module.exports = require("../src/index.ts");
-
-unregister();
+if (process.env.NODE_ENV === "production") {
+  module.exports = require("./0xsequence-replacer.cjs.prod.js");
+} else {
+  module.exports = require("./0xsequence-replacer.cjs.dev.js");
+}

package/dist/0xsequence-replacer.cjs.prod.js

@@ -0,0 +1,127 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var ethers = require('ethers');
+var abi = require('@0xsequence/abi');
+var core = require('@0xsequence/core');
+
+function useGateway(uri, gateway) {
+  const clean = uri.replace('ipfs://ipfs/', '').replace('ipfs://', '');
+  if (uri.startsWith('ipfs://')) return `${gateway}${clean}`;
+  return uri;
+}
+function isIPFS(uri) {
+  return uri.startsWith('ipfs://');
+}
+
+class CachedEIP5719 {
+  constructor(provider, solver, window = 1000) {
+    this.provider = provider;
+    this.solver = solver;
+    this.window = window;
+    this.pending = new Map();
+  }
+  async runByEIP5719(address, digest, signature) {
+    const key = `${address}-${digest}-${signature}`;
+    const now = Date.now();
+    if (this.pending.has(key) && now - this.pending.get(key).timestamp < this.window) {
+      return this.pending.get(key).promise;
+    }
+    const promise = runByEIP5719(address, this.provider, digest, signature, this.solver);
+    this.pending.set(key, {
+      timestamp: now,
+      promise
+    });
+    return promise;
+  }
+}
+
+function eip5719Contract(address, provider) {
+  // TODO: for some reason walletContracts is not being loaded from local
+  // remove this code once fixed
+  const abi = [{
+    inputs: [{
+      internalType: 'bytes32',
+      type: 'bytes32'
+    }],
+    name: 'getAlternativeSignature',
+    outputs: [{
+      internalType: 'string',
+      type: 'string'
+    }],
+    stateMutability: 'view',
+    type: 'function'
+  }];
+  return new ethers.ethers.Contract(address, abi, provider);
+}
+function eip1271Contract(address, provider) {
+  return new ethers.ethers.Contract(address, abi.walletContracts.erc1271.abi, provider);
+}
+async function isValidSignature(address, provider, digest, signature) {
+  // First we try to validate the signature using Ethers
+  try {
+    const addr = ethers.ethers.recoverAddress(digest, ethers.ethers.hexlify(signature));
+    if (addr.toLowerCase() === address.toLowerCase()) return true;
+  } catch (_unused) {}
+
+  // Then we try to validate the signature using EIP1271
+  try {
+    const contract = eip1271Contract(address, provider);
+    const value = await contract.isValidSignature(digest, signature);
+    if (value === abi.walletContracts.erc1271.returns) return true;
+  } catch (_unused2) {}
+
+  // If all else fails, we return false
+  return false;
+}
+async function tryAwait(promise) {
+  try {
+    return await promise;
+  } catch (_unused3) {
+    return undefined;
+  }
+}
+async function runByEIP5719(address, provider, digest, signature, solver, tries = 0) {
+  if (tries > 10) throw new Error('EIP5719 - Too many tries');
+  if (core.commons.signer.canRecover(signature)) {
+    const recoveredAddr = core.commons.signer.recoverSigner(digest, signature);
+    if (recoveredAddr && recoveredAddr.toLowerCase() === address.toLowerCase()) return signature;
+  }
+  try {
+    if (await core.commons.signer.isValidSignature(address, digest, signature, provider)) {
+      return signature;
+    }
+  } catch (_unused4) {}
+  const altUri = await tryAwait(eip5719Contract(address, provider).getAlternativeSignature(digest));
+  if (!altUri || altUri === '') throw new Error('EIP5719 - Invalid signature and no alternative signature');
+  const altSignature = ethers.ethers.hexlify(await (solver || new URISolverIPFS()).resolve(altUri));
+  if (!altSignature || altSignature === '') throw new Error('EIP5719 - Empty alternative signature');
+  if (altSignature === ethers.ethers.hexlify(signature)) {
+    throw new Error('EIP5719 - Alternative signature is invalid or the same');
+  }
+  return runByEIP5719(address, provider, digest, altSignature, solver, tries + 1);
+}
+class URISolverIPFS {
+  constructor(gateway = 'https://cloudflare-ipfs.com/ipfs/') {
+    var _this = this;
+    this.gateway = gateway;
+    this.uri = uri => {
+      if (isIPFS(uri)) return useGateway(uri, this.gateway);
+      return uri;
+    };
+    this.resolve = async function (uri) {
+      const url = _this.uri(uri);
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`URISolverIPFS - Failed to fetch ${url}`);
+      return await res.text();
+    };
+  }
+}
+
+exports.CachedEIP5719 = CachedEIP5719;
+exports.URISolverIPFS = URISolverIPFS;
+exports.eip1271Contract = eip1271Contract;
+exports.eip5719Contract = eip5719Contract;
+exports.isValidSignature = isValidSignature;
+exports.runByEIP5719 = runByEIP5719;

package/dist/0xsequence-replacer.esm.js

@@ -0,0 +1,118 @@
+import { ethers } from 'ethers';
+import { walletContracts } from '@0xsequence/abi';
+import { commons } from '@0xsequence/core';
+
+function useGateway(uri, gateway) {
+  const clean = uri.replace('ipfs://ipfs/', '').replace('ipfs://', '');
+  if (uri.startsWith('ipfs://')) return `${gateway}${clean}`;
+  return uri;
+}
+function isIPFS(uri) {
+  return uri.startsWith('ipfs://');
+}
+
+class CachedEIP5719 {
+  constructor(provider, solver, window = 1000) {
+    this.provider = provider;
+    this.solver = solver;
+    this.window = window;
+    this.pending = new Map();
+  }
+  async runByEIP5719(address, digest, signature) {
+    const key = `${address}-${digest}-${signature}`;
+    const now = Date.now();
+    if (this.pending.has(key) && now - this.pending.get(key).timestamp < this.window) {
+      return this.pending.get(key).promise;
+    }
+    const promise = runByEIP5719(address, this.provider, digest, signature, this.solver);
+    this.pending.set(key, {
+      timestamp: now,
+      promise
+    });
+    return promise;
+  }
+}
+
+function eip5719Contract(address, provider) {
+  // TODO: for some reason walletContracts is not being loaded from local
+  // remove this code once fixed
+  const abi = [{
+    inputs: [{
+      internalType: 'bytes32',
+      type: 'bytes32'
+    }],
+    name: 'getAlternativeSignature',
+    outputs: [{
+      internalType: 'string',
+      type: 'string'
+    }],
+    stateMutability: 'view',
+    type: 'function'
+  }];
+  return new ethers.Contract(address, abi, provider);
+}
+function eip1271Contract(address, provider) {
+  return new ethers.Contract(address, walletContracts.erc1271.abi, provider);
+}
+async function isValidSignature(address, provider, digest, signature) {
+  // First we try to validate the signature using Ethers
+  try {
+    const addr = ethers.recoverAddress(digest, ethers.hexlify(signature));
+    if (addr.toLowerCase() === address.toLowerCase()) return true;
+  } catch (_unused) {}
+
+  // Then we try to validate the signature using EIP1271
+  try {
+    const contract = eip1271Contract(address, provider);
+    const value = await contract.isValidSignature(digest, signature);
+    if (value === walletContracts.erc1271.returns) return true;
+  } catch (_unused2) {}
+
+  // If all else fails, we return false
+  return false;
+}
+async function tryAwait(promise) {
+  try {
+    return await promise;
+  } catch (_unused3) {
+    return undefined;
+  }
+}
+async function runByEIP5719(address, provider, digest, signature, solver, tries = 0) {
+  if (tries > 10) throw new Error('EIP5719 - Too many tries');
+  if (commons.signer.canRecover(signature)) {
+    const recoveredAddr = commons.signer.recoverSigner(digest, signature);
+    if (recoveredAddr && recoveredAddr.toLowerCase() === address.toLowerCase()) return signature;
+  }
+  try {
+    if (await commons.signer.isValidSignature(address, digest, signature, provider)) {
+      return signature;
+    }
+  } catch (_unused4) {}
+  const altUri = await tryAwait(eip5719Contract(address, provider).getAlternativeSignature(digest));
+  if (!altUri || altUri === '') throw new Error('EIP5719 - Invalid signature and no alternative signature');
+  const altSignature = ethers.hexlify(await (solver || new URISolverIPFS()).resolve(altUri));
+  if (!altSignature || altSignature === '') throw new Error('EIP5719 - Empty alternative signature');
+  if (altSignature === ethers.hexlify(signature)) {
+    throw new Error('EIP5719 - Alternative signature is invalid or the same');
+  }
+  return runByEIP5719(address, provider, digest, altSignature, solver, tries + 1);
+}
+class URISolverIPFS {
+  constructor(gateway = 'https://cloudflare-ipfs.com/ipfs/') {
+    var _this = this;
+    this.gateway = gateway;
+    this.uri = uri => {
+      if (isIPFS(uri)) return useGateway(uri, this.gateway);
+      return uri;
+    };
+    this.resolve = async function (uri) {
+      const url = _this.uri(uri);
+      const res = await fetch(url);
+      if (!res.ok) throw new Error(`URISolverIPFS - Failed to fetch ${url}`);
+      return await res.text();
+    };
+  }
+}
+
+export { CachedEIP5719, URISolverIPFS, eip1271Contract, eip5719Contract, isValidSignature, runByEIP5719 };

package/dist/declarations/src/cached.d.ts

@@ -0,0 +1,10 @@
+import { ethers } from 'ethers';
+import { URISolver } from "./index.js";
+export declare class CachedEIP5719 {
+    provider: ethers.Provider;
+    solver?: URISolver | undefined;
+    window: number;
+    constructor(provider: ethers.Provider, solver?: URISolver | undefined, window?: number);
+    private pending;
+    runByEIP5719(address: string, digest: ethers.BytesLike, signature: ethers.BytesLike): Promise<ethers.BytesLike>;
+}

package/dist/declarations/src/index.d.ts

@@ -0,0 +1,15 @@
+import { ethers } from 'ethers';
+export * from "./cached.js";
+export declare function eip5719Contract(address: string, provider: ethers.Provider): ethers.Contract;
+export declare function eip1271Contract(address: string, provider: ethers.Provider): ethers.Contract;
+export declare function isValidSignature(address: string, provider: ethers.Provider, digest: ethers.BytesLike, signature: ethers.BytesLike): Promise<boolean>;
+export interface URISolver {
+    resolve: (uri: string) => Promise<string>;
+}
+export declare function runByEIP5719(address: string, provider: ethers.Provider, digest: ethers.BytesLike, signature: ethers.BytesLike, solver?: URISolver, tries?: number): Promise<ethers.BytesLike>;
+export declare class URISolverIPFS implements URISolver {
+    gateway: string;
+    constructor(gateway?: string);
+    uri: (uri: string) => string;
+    resolve: (uri: string) => Promise<string>;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0xsequence/replacer",
-  "version": "2.3.18",
+  "version": "2.3.20",
   "description": "EIP-5719 client implementation",
   "repository": "https://github.com/0xsequence/sequence.js/tree/master/packages/replacer",
   "source": "src/index.ts",
@@ -12,8 +12,8 @@
     "ethers": ">=6"
   },
   "dependencies": {
-    "@0xsequence/core": "2.3.18",
-    "@0xsequence/abi": "2.3.18"
+    "@0xsequence/core": "2.3.20",
+    "@0xsequence/abi": "2.3.20"
   },
   "devDependencies": {},
   "files": [