@epoch-protocol/epoch-commons-sdk 0.1.0

package/dist/web3/wallet.js

@@ -0,0 +1,390 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validationEpochModuleSafeSignature = exports.getProxyAddressFromReceipt = exports.set7702DelegatorFromAuthorizationListManually = exports.set7702DelegatorManually = exports.set7702DelegatorFromAuthorizationList = exports.set7702Delegator = exports.getCreateWalletData = exports.getMetamaskDelegatorInstance = exports.calculateProxyAddress = exports.getSafeProxyFactoryInstance = void 0;
+const ethers_1 = require("ethers");
+const viem_1 = require("viem");
+const accounts_1 = require("viem/accounts");
+const chains = __importStar(require("viem/chains"));
+const constants_1 = require("../constants");
+const web3_1 = require("../utils/web3");
+const types_1 = require("../types");
+const web3_2 = require("../web3");
+const safe7702ProxyFactoryAbi_1 = __importDefault(require("./abis/safe7702ProxyFactoryAbi"));
+const safeProxyFactoryAbi_1 = __importDefault(require("./abis/safeProxyFactoryAbi"));
+const delegation_toolkit_1 = require("@metamask/delegation-toolkit");
+const epochModuleAbi_1 = __importDefault(require("./abis/epochModuleAbi"));
+const getSafeProxyFactoryInstance = (chainId, is7702) => {
+    const provider = new ethers_1.ethers.JsonRpcProvider(constants_1.RPC_ENDPOINTS[chainId]);
+    return new ethers_1.ethers.Contract(is7702
+        ? constants_1.EIP7702_SAFE_PROXY_ADDRESS[chainId]
+        : constants_1.SAFE_PROXY_FACTORY_ADDRESS[chainId], is7702 ? safe7702ProxyFactoryAbi_1.default : safeProxyFactoryAbi_1.default, provider);
+};
+exports.getSafeProxyFactoryInstance = getSafeProxyFactoryInstance;
+const calculateProxyAddress = async (walletType, options) => {
+    if (walletType === types_1.WalletType.metamask) {
+        if (!options?.metamaskOptions) {
+            throw new Error("Metamask options are required");
+        }
+        const delegatorSmartAccount = await (0, exports.getMetamaskDelegatorInstance)(options?.metamaskOptions?.userAddress, options?.metamaskOptions?.userSigner);
+        return delegatorSmartAccount.address;
+    }
+    else if (walletType === types_1.WalletType.safe) {
+        if (!options?.safeOptions) {
+            throw new Error("Safe options are required");
+        }
+        const salt = ethers_1.ethers.solidityPackedKeccak256(["bytes32", "uint256"], [
+            ethers_1.ethers.solidityPackedKeccak256(["bytes"], [options.safeOptions.inititalizer]),
+            options.safeOptions.nonce,
+        ]);
+        const factoryAddress = typeof options.safeOptions.factory.target === "string"
+            ? options.safeOptions.factory.target
+            : await options.safeOptions.factory.target;
+        const proxyCreationCode = await options.safeOptions.factory.proxyCreationCode();
+        const deploymentCode = ethers_1.ethers.solidityPacked(["bytes", "uint256"], [proxyCreationCode, options.safeOptions.singleton]);
+        return ethers_1.ethers.getCreate2Address(factoryAddress, salt, ethers_1.ethers.keccak256(deploymentCode));
+    }
+    else {
+        throw new Error("Invalid wallet type");
+    }
+};
+exports.calculateProxyAddress = calculateProxyAddress;
+const getMetamaskDelegatorInstance = async (userAddress, userSigner, is7702, isPasskey, passkey) => {
+    const walletClientwithPublic = userSigner.extend(viem_1.publicActions);
+    const deployParams = [userAddress, [], [], []];
+    if (is7702) {
+        return await (0, delegation_toolkit_1.toMetaMaskSmartAccount)({
+            client: walletClientwithPublic,
+            implementation: delegation_toolkit_1.Implementation.Stateless7702,
+            address: userAddress,
+            signatory: { walletClient: walletClientwithPublic },
+        });
+    }
+    if (isPasskey) {
+        return await (0, delegation_toolkit_1.toMetaMaskSmartAccount)({
+            client: walletClientwithPublic,
+            implementation: delegation_toolkit_1.Implementation.Hybrid,
+            deployParams: [
+                userAddress,
+                [passkey.credential.id],
+                [passkey.publicKey.x],
+                [passkey.publicKey.y],
+            ],
+            deploySalt: "0x",
+            signatory: {
+                webAuthnAccount: passkey.webAuthnAccount,
+                keyId: (0, viem_1.toHex)(passkey.credential.id),
+            },
+        });
+    }
+    return await (0, delegation_toolkit_1.toMetaMaskSmartAccount)({
+        client: walletClientwithPublic,
+        implementation: delegation_toolkit_1.Implementation.Hybrid,
+        deployParams: deployParams,
+        deploySalt: "0x",
+        signatory: { walletClient: walletClientwithPublic },
+    });
+};
+exports.getMetamaskDelegatorInstance = getMetamaskDelegatorInstance;
+const getCreateWalletData = async (userAddress, chainId, walletType, options) => {
+    console.log("walletType: ", walletType);
+    if (walletType === types_1.WalletType.metamask) {
+        console.log("WalletType.metamask: ", types_1.WalletType.metamask);
+        if (!options?.userSigner) {
+            throw new Error("only viem Client supported for Metamask");
+        }
+        const delegatorSmartAccount = await (0, exports.getMetamaskDelegatorInstance)(userAddress, options?.userSigner, options.is7702);
+        console.log("delegatorSmartAccount: ", delegatorSmartAccount);
+        const deployParams = [userAddress, [], [], []];
+        console.log("deployParams: ", deployParams);
+        return {
+            txnData: {
+                target: delegatorSmartAccount.address,
+                data: "0x",
+                value: "0",
+            },
+            proxyAddress: delegatorSmartAccount.address,
+            initializerData: (0, viem_1.encodeFunctionData)({
+                abi: delegatorSmartAccount.abi,
+                functionName: "initialize",
+                args: deployParams,
+            }),
+            isAlreadyDeployed: await delegatorSmartAccount.isDeployed(),
+        };
+    }
+    else if (walletType === types_1.WalletType.safe) {
+        const { is7702 } = { ...options };
+        const abiCoder = new ethers_1.ethers.AbiCoder();
+        let safeOwners = [userAddress];
+        const salt = 123665432;
+        const safeInitSetupABI = [
+            "function forwardSetup(address safeInitSetup, bool triggerFaucet, bytes extraData)",
+        ];
+        const safeInitSetupInterface = new ethers_1.ethers.Interface(safeInitSetupABI);
+        let extraData = "0x";
+        if (options?.passkey) {
+            safeOwners = [constants_1.SAFE_WEBAUTHN_SHARED_SIGNER[chainId]];
+            const signer = {
+                x: options?.passkey?.publicKey.x,
+                y: options?.passkey?.publicKey.y,
+                verifiers: constants_1.FCLP256Verifier[chainId],
+            };
+            const signerData = abiCoder.encode(["tuple(bytes32 x, bytes32 y, uint176 verifiers)"], [
+                {
+                    x: signer.x,
+                    y: signer.y,
+                    verifiers: signer.verifiers,
+                },
+            ]);
+            extraData = signerData;
+        }
+        const safeInitSetupData = safeInitSetupInterface.encodeFunctionData("forwardSetup", [constants_1.EPOCH_SAFE_INIT_SETUP[chainId], true, extraData]);
+        const safeSetupABI = [
+            "function setup(address[] calldata _owners, uint256 _threshold, address to, bytes calldata data, address fallbackHandler, address paymentToken, uint256 payment, address payable paymentReceiver)",
+        ];
+        const safeSetupInterface = new ethers_1.ethers.Interface(safeSetupABI);
+        const initializerData = safeSetupInterface.encodeFunctionData("setup", [
+            safeOwners,
+            1,
+            constants_1.SAFE_INIT_SETUP_FORWARDER[chainId],
+            safeInitSetupData,
+            ethers_1.ethers.ZeroAddress,
+            ethers_1.ethers.ZeroAddress,
+            0,
+            ethers_1.ethers.ZeroAddress,
+        ]);
+        const safeEIP7702ProxyFactory = (0, exports.getSafeProxyFactoryInstance)(chainId, true);
+        const proxyFactory = (0, exports.getSafeProxyFactoryInstance)(chainId);
+        const proxyAddress = await (0, exports.calculateProxyAddress)(walletType, {
+            safeOptions: {
+                factory: is7702 ? safeEIP7702ProxyFactory : proxyFactory,
+                singleton: is7702
+                    ? constants_1.SAFE_7702_SINGLETON_ADDRESS[chainId]
+                    : constants_1.SAFE_SINGLETON_ADDRESS[chainId],
+                inititalizer: initializerData,
+                nonce: salt,
+            },
+        });
+        if (!proxyAddress) {
+            throw new Error("Failed to calculate proxy address");
+        }
+        const provider = (0, web3_2.getProvider)(chainId);
+        const isContract = await provider.getCode(proxyAddress);
+        if (isContract !== "0x") {
+            return {
+                txnData: {
+                    target: "",
+                    data: "",
+                    value: "0",
+                },
+                proxyAddress,
+                initializerData,
+                isAlreadyDeployed: true,
+            };
+        }
+        if (is7702) {
+            const proxyData = await safeEIP7702ProxyFactory.createProxyWithNonce.populateTransaction(constants_1.SAFE_7702_SINGLETON_ADDRESS[chainId], initializerData, salt);
+            if (!proxyData.data) {
+                throw new Error("Failed to create proxy data");
+            }
+            const factoryTarget = typeof safeEIP7702ProxyFactory.target === "string"
+                ? safeEIP7702ProxyFactory.target
+                : await safeEIP7702ProxyFactory.target;
+            return {
+                txnData: {
+                    target: factoryTarget,
+                    data: proxyData.data,
+                    value: "0",
+                },
+                proxyAddress,
+                initializerData,
+                isAlreadyDeployed: false,
+            };
+        }
+        else {
+            const proxyData = await proxyFactory.createProxyWithNonce.populateTransaction(constants_1.SAFE_SINGLETON_ADDRESS[chainId], initializerData, salt);
+            if (!proxyData.data) {
+                throw new Error("Failed to create proxy data");
+            }
+            const factoryTarget = typeof proxyFactory.target === "string"
+                ? proxyFactory.target
+                : await proxyFactory.target;
+            return {
+                txnData: {
+                    target: factoryTarget,
+                    data: proxyData.data,
+                    value: "0",
+                },
+                proxyAddress,
+                initializerData,
+                isAlreadyDeployed: false,
+            };
+        }
+    }
+    throw new Error("Invalid wallet type");
+};
+exports.getCreateWalletData = getCreateWalletData;
+const set7702Delegator = async (chainId, userAddress, userSafeAddress, initializerData, userWalletClient, relayer) => {
+    const publicClient = (0, viem_1.createPublicClient)({
+        transport: (0, viem_1.http)(constants_1.RPC_ENDPOINTS[chainId]),
+    });
+    const account = userWalletClient.account;
+    if (!account) {
+        throw new Error("Account not found");
+    }
+    const transactionCount = await publicClient.getTransactionCount({
+        address: account.address,
+    });
+    const relayerAddress = ethers_1.ethers.computeAddress(relayer.publicKey);
+    let authorizationList;
+    if (account.address === relayerAddress) {
+        authorizationList = await userWalletClient.signAuthorization({
+            account: account,
+            contractAddress: userSafeAddress,
+            chainId: chainId,
+            executor: "self",
+        });
+    }
+    else {
+        authorizationList = await userWalletClient.signAuthorization({
+            account: account,
+            contractAddress: userSafeAddress,
+            nonce: transactionCount,
+            chainId: chainId,
+        });
+    }
+    if (!authorizationList) {
+        throw new Error("Failed to sign authorization for 7702 delegator");
+    }
+    await (0, exports.set7702DelegatorFromAuthorizationList)(chainId, userAddress, authorizationList, initializerData, relayer);
+};
+exports.set7702Delegator = set7702Delegator;
+const set7702DelegatorFromAuthorizationList = async (chainId, userAddress, authorizationList, initializerData, relayer) => {
+    const chain = (0, viem_1.extractChain)({
+        chains: Object.values(chains),
+        id: chainId,
+    });
+    const account = (0, accounts_1.privateKeyToAccount)(relayer.privateKey);
+    const publicClient = (0, viem_1.createPublicClient)({
+        transport: (0, viem_1.http)(constants_1.RPC_ENDPOINTS[chainId]),
+        chain,
+    });
+    const relayerWalletClient = (0, viem_1.createWalletClient)({
+        account,
+        transport: (0, viem_1.http)(constants_1.RPC_ENDPOINTS[chainId]),
+        chain,
+    });
+    const hash = await relayerWalletClient.sendTransaction({
+        account,
+        chain: chain,
+        to: userAddress,
+        data: initializerData,
+        value: BigInt(0),
+        authorizationList: [authorizationList],
+    });
+    const receipt = await publicClient.waitForTransactionReceipt({
+        hash: hash,
+    });
+    if (receipt.status !== "success") {
+        throw new Error("Failed to set 7702 delegator");
+    }
+};
+exports.set7702DelegatorFromAuthorizationList = set7702DelegatorFromAuthorizationList;
+const set7702DelegatorManually = async (chainId, userAddress, userSafeAddress, userSigner, relayer, initializerData) => {
+    const provider = (0, web3_2.getProvider)(chainId);
+    const authNonce = await provider.getTransactionCount(userAddress, "pending");
+    const authAddress = userSafeAddress;
+    const authorizationList = await (0, web3_1.getAuthorizationList)(chainId, BigInt(authNonce), authAddress, userSigner);
+    await (0, exports.set7702DelegatorFromAuthorizationListManually)(chainId, userAddress, userSafeAddress, authorizationList, initializerData, relayer);
+    return true;
+};
+exports.set7702DelegatorManually = set7702DelegatorManually;
+const set7702DelegatorFromAuthorizationListManually = async (chainId, userAddress, userSafeAddress, authorizationList, initializerData, relayer) => {
+    try {
+        const provider = (0, web3_2.getProvider)(chainId);
+        const encodedSignedTx = await (0, web3_1.getSignedTransaction)(provider, relayer, authorizationList);
+        const authAddress = userSafeAddress;
+        const isAlreadyDelegated = await (0, web3_1.isAccountDelegatedToAddress)(provider, userAddress, authAddress);
+        if (isAlreadyDelegated &&
+            (await provider.getStorage(userAddress, 4)) ==
+                ethers_1.ethers.zeroPadValue("0x01", 32)) {
+            throw new Error("Account already delegated to Safe Proxy and storage is setup. Returning");
+        }
+        const response = await provider.send("eth_sendRawTransaction", [
+            encodedSignedTx,
+        ]);
+        await (await provider.getTransaction(response))?.wait();
+        const relayerWallet = new ethers_1.ethers.Wallet(relayer.privateKey, provider);
+        const setupTxResponse = await relayerWallet.sendTransaction({
+            to: userAddress,
+            data: initializerData,
+        });
+        await setupTxResponse.wait();
+    }
+    catch (error) {
+        throw error;
+    }
+};
+exports.set7702DelegatorFromAuthorizationListManually = set7702DelegatorFromAuthorizationListManually;
+const getProxyAddressFromReceipt = (txnReceipt) => {
+    const proxyCreationEvent = `event ProxyCreation(address indexed proxy, address singleton)`;
+    const proxyCreationEventAbi = new ethers_1.ethers.Interface([proxyCreationEvent]);
+    let proxyAddress;
+    for (const log of txnReceipt.logs) {
+        try {
+            const parsedLog = proxyCreationEventAbi.parseLog(log);
+            if (parsedLog && parsedLog.name === "ProxyCreation") {
+                proxyAddress = parsedLog.args.proxy;
+                break;
+            }
+        }
+        catch (e) {
+            continue;
+        }
+    }
+    return proxyAddress;
+};
+exports.getProxyAddressFromReceipt = getProxyAddressFromReceipt;
+const validationEpochModuleSafeSignature = async (sender, data, signature) => {
+    const epochModule = constants_1.EPOCH_MODULE_SAFE_ADDRESS[constants_1.DEFAULT_CHAIN_ID];
+    const provider = (0, web3_2.getProvider)(constants_1.DEFAULT_CHAIN_ID);
+    const epochModuleInstance = new ethers_1.ethers.Contract(epochModule, epochModuleAbi_1.default, provider);
+    const isValid = await epochModuleInstance.verifySignature(sender, data, signature);
+    return isValid;
+};
+exports.validationEpochModuleSafeSignature = validationEpochModuleSafeSignature;

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@epoch-protocol/epoch-commons-sdk",
+  "version": "0.1.0",
+  "description": "SDK for interacting with Epoch Commons Protocol",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint . --ext .ts",
+    "format": "prettier --write \"src/**/*.ts\"",
+    "prepare": "npm run build"
+  },
+  "keywords": [
+    "blockchain",
+    "ethereum",
+    "viem",
+    "sdk"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "ethers": "^6.0.0",
+    "viem": "2.42.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^29.5.14",
+    "@types/node": "^20.11.19",
+    "@typescript-eslint/eslint-plugin": "^7.0.1",
+    "@typescript-eslint/parser": "^7.0.1",
+    "eslint": "^8.56.0",
+    "jest": "^29.7.0",
+    "prettier": "^3.2.5",
+    "ts-jest": "^29.1.2",
+    "typescript": "^5.3.3"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ]
+}