@epoch-protocol/epoch-commons-sdk 0.1.0

package/dist/types/index.d.ts

@@ -0,0 +1,322 @@
+import { ethers } from "ethers";
+import { Address, WalletClient } from "viem";
+export type ApiResponse<T> = {
+    data: T;
+    status: number;
+    message?: string;
+};
+export type BlockchainData = {
+    balance: string;
+};
+export type ContractInteraction = {
+    address: string;
+    functionName: string;
+    args: any[];
+};
+export type Config = {
+    apiUrl: string;
+};
+export type ChainEntity<T extends Chain | Protocol | Token = Chain | Protocol | Token> = {
+    name: string;
+    data: T;
+};
+export type Task = {
+    action?: ProtocolType;
+    tokens?: string[][];
+    chainIds?: number[][];
+    protocol?: string;
+    recipient?: string;
+    extraData?: string;
+};
+export type NonceResponse = {
+    nonce: string;
+};
+export type SolveIntentResponse = {
+    success: boolean;
+    path: Path[];
+};
+export type ErrorResponse = {
+    error: string;
+};
+export type Transaction = {
+    target: string;
+    data: string;
+    value: string;
+};
+export declare enum WalletType {
+    safe = "safe",
+    metamask = "metamask"
+}
+export type CreateWalletOptions = {
+    is7702?: boolean;
+    userSigner?: ethers.Wallet | ethers.VoidSigner | WalletClient;
+    passkey?: any;
+};
+export type AuthorizationListEntryAny = {
+    chainId: number;
+    address: string;
+    nonce: bigint;
+    yParity: any;
+    r: any;
+    s: any;
+};
+export type AuthEntry7702RLPType = [
+    Uint8Array,
+    string,
+    Uint8Array,
+    Uint8Array,
+    Uint8Array,
+    Uint8Array
+];
+export type Auth7702RLPType = Array<AuthEntry7702RLPType>;
+export type CreateWalletData = {
+    txnData: Transaction;
+    proxyAddress: string;
+    initializerData: string;
+    isAlreadyDeployed: boolean;
+};
+export declare enum ProtocolType {
+    lending = "lending:deposit",
+    bridge = "bridge",
+    swap = "swap",
+    restaking = "restaking",
+    yield = "yield",
+    swapandbridge = "swapandbridge",
+    protocolInteraction = "protocol-interaction"
+}
+export interface IntentTaskData {
+    action?: ProtocolType;
+    tokens?: string[][];
+    chainIds?: string[][];
+    protocol?: string;
+    extraData?: any;
+}
+export type Protocol = {
+    contractAddress: {
+        [chainName: string]: string;
+    };
+    type: ProtocolType[];
+};
+export type Token = {
+    contractAddress: {
+        [chainName: string]: string;
+    };
+    decimals: number;
+};
+export type Chain = {
+    chainId: number;
+    explorer: string;
+};
+export type Relationships = {
+    protocolTokensByChain: {
+        [protocolName: string]: {
+            [chainName: string]: {
+                tokensIn?: string[];
+                tokensOut?: string[];
+                tokensInAndOut?: string[];
+            };
+        };
+    };
+};
+export type Graph = {
+    protocols: {
+        [protocolName: string]: Protocol;
+    };
+    tokens: {
+        [tokenName: string]: Token;
+    };
+    chains: {
+        [chainName: string]: Chain;
+    };
+    relationships: Relationships;
+};
+export type Solver = {
+    solverAddress: string;
+    url: string;
+    modules: string[];
+    status: number;
+};
+export type Approval = {
+    tokenAddress: string;
+    spenderAddress: string;
+    amount: string;
+    chainId: number;
+};
+export type Constraint = {
+    constraintData: string;
+    constraintResponse: string;
+    constraints: string;
+    optimizationFactor: number;
+    deadline: number;
+    triggers: string;
+    preferredSolvers: string[];
+};
+export type Calldata = {
+    data: string;
+    target: string;
+    value: string;
+};
+export type Intent = {
+    sender: string;
+    approvals: Approval[];
+    task: string;
+    constraint: Constraint;
+    nonce: string;
+    proposedFeeRewards: number;
+    chainIds: number[];
+    calldatas: Calldata[];
+    recurring: boolean;
+    signature?: string;
+    executor?: string;
+    completed?: boolean;
+};
+export type PathItem = {
+    name: string;
+    chain?: Chain;
+    protocol?: Protocol;
+    token?: Token & {
+        amount: string;
+    };
+    calldata?: CalldataReturnInterface;
+    fillerData?: FillerTokenData;
+};
+export type Path = PathItem[][][];
+export interface QuoteReturnInterface {
+    asset: string;
+    tokenIn: string;
+    tokenOut: string;
+    optionalData: any;
+    quoteId: string;
+    quoteData: string;
+    callData: CalldataReturnInterface;
+    fillerData?: FillerTokenData;
+}
+export interface ExecutionResult {
+    success: boolean;
+    transactionHash?: string;
+    error?: string;
+}
+export type ExecutionTransaction = {
+    target: string;
+    value: string;
+    callData: string;
+};
+export type IntermediaryApprovals = {
+    tokenAddress: string;
+    spenderAddress: string;
+    amount: string;
+    chainId: string;
+};
+export interface IntentEvent {
+    user: string;
+    intentIndex: number;
+}
+export interface EventData {
+    abi: string[];
+    data: string[];
+    contractAddress: string;
+    chainId: string;
+}
+export interface ExecutionTransactionWithEventData {
+    userSCWalletAddress: string;
+    nonce: string;
+    transaction: ExecutionTransaction[];
+    eventData: EventData;
+    approvals: IntermediaryApprovals[];
+    fillerTokenDatas: FillerTokenData[];
+}
+export interface CalldataReturnInterface {
+    executionTransactions: ExecutionTransaction[];
+    eventData: EventData;
+}
+export interface MultisendTransaction {
+    to: string;
+    value: string;
+    data: string;
+}
+export interface IntentQuoteInterface {
+    originSettler: string;
+    user: string;
+    nonce: string;
+    originChainId: string;
+    openDeadline: number;
+    fillDeadline: number;
+    orderDataType: string;
+    orderData: string;
+}
+export type FillerTokenData = {
+    filler: string;
+    user: string;
+    token: string;
+    amount: string;
+    nonce: string;
+    fillChainId: string;
+    redeemChainId: string;
+};
+export declare enum TransactionStatus {
+    PENDING = "pending",
+    SUCCESS = "success",
+    FAILED = "failed"
+}
+export type QueuedTransactionForIntent = {
+    nonce: string;
+    transactions: ExecutionTransaction[];
+    chainId: number;
+    userSCWalletAddress: string;
+    intentNonce: string;
+    approvals: IntermediaryApprovals[];
+    fillerTokenDatas: FillerTokenData[];
+    executionType: QueueExecutionType;
+    status: TransactionStatus;
+    dependenciesTransactions: string[];
+    transactionHash: string | null;
+};
+export type CompactDataForQueue = {
+    intentNonce: string;
+    fillerTokenDatas: FillerTokenData[];
+    claimHash: string;
+    chainId: string;
+};
+export declare enum QueueExecutionType {
+    ADD_AND_EXECUTE = "addAndExecute",
+    ADD_INTENT = "addIntent",
+    SIMPLE_EXECUTION = "simpleExecution"
+}
+export declare enum TaskType {
+    GetTokenOut = "gettokenout",
+    Deposit = "deposit",
+    ProtocolInteraction = "protocol-interaction"
+}
+export type Mandate = {
+    tokenIn: string;
+    tokenInAmount: string;
+    tokenOut: string;
+    minTokenOut: string;
+    destinationChainId: string;
+    taskType: string;
+    recipient: string;
+    protocolHashIdentifier?: string;
+    [key: string]: any;
+};
+export type SerializedCompactData = {
+    arbiter: string;
+    sponsor: string;
+    nonce: string;
+    expires: string;
+    id: string;
+    lockTag: string;
+    token: string;
+    amount: string;
+    mandate?: Mandate;
+};
+export type CompactData = {
+    arbiter: Address;
+    sponsor: Address;
+    nonce: bigint | string;
+    expires: bigint | string;
+    id: bigint | string;
+    lockTag: bigint | string;
+    token: Address | bigint | string;
+    amount: bigint | string;
+    mandate?: Mandate;
+};

package/dist/types/index.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskType = exports.QueueExecutionType = exports.TransactionStatus = exports.ProtocolType = exports.WalletType = void 0;
+var WalletType;
+(function (WalletType) {
+    WalletType["safe"] = "safe";
+    WalletType["metamask"] = "metamask";
+})(WalletType || (exports.WalletType = WalletType = {}));
+// Define types for various entities
+var ProtocolType;
+(function (ProtocolType) {
+    ProtocolType["lending"] = "lending:deposit";
+    ProtocolType["bridge"] = "bridge";
+    ProtocolType["swap"] = "swap";
+    ProtocolType["restaking"] = "restaking";
+    ProtocolType["yield"] = "yield";
+    ProtocolType["swapandbridge"] = "swapandbridge";
+    ProtocolType["protocolInteraction"] = "protocol-interaction";
+})(ProtocolType || (exports.ProtocolType = ProtocolType = {}));
+var TransactionStatus;
+(function (TransactionStatus) {
+    TransactionStatus["PENDING"] = "pending";
+    TransactionStatus["SUCCESS"] = "success";
+    TransactionStatus["FAILED"] = "failed";
+})(TransactionStatus || (exports.TransactionStatus = TransactionStatus = {}));
+var QueueExecutionType;
+(function (QueueExecutionType) {
+    QueueExecutionType["ADD_AND_EXECUTE"] = "addAndExecute";
+    QueueExecutionType["ADD_INTENT"] = "addIntent";
+    QueueExecutionType["SIMPLE_EXECUTION"] = "simpleExecution";
+})(QueueExecutionType || (exports.QueueExecutionType = QueueExecutionType = {}));
+var TaskType;
+(function (TaskType) {
+    TaskType["GetTokenOut"] = "gettokenout";
+    TaskType["Deposit"] = "deposit";
+    TaskType["ProtocolInteraction"] = "protocol-interaction";
+})(TaskType || (exports.TaskType = TaskType = {}));

package/dist/utils/compact.d.ts

@@ -0,0 +1,4 @@
+import { type Hex } from 'viem';
+import { CompactData } from '../types';
+export declare function getCompactTypehash(witnessTypeString?: string): Hex;
+export declare function getClaimHash(message: CompactData, witnessTypeString: string): `0x${string}`;

package/dist/utils/compact.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCompactTypehash = getCompactTypehash;
+exports.getClaimHash = getClaimHash;
+const viem_1 = require("viem");
+const utils_1 = require("viem/utils");
+function getCompactTypehash(witnessTypeString) {
+    if (witnessTypeString) {
+        const typestring = `Compact(address arbiter,address sponsor,uint256 nonce,uint256 expires,bytes12 lockTag,address token,uint256 amount,Mandate mandate)Mandate(${witnessTypeString})`;
+        console.log('typestring: ', typestring);
+        return (0, viem_1.keccak256)((0, viem_1.toBytes)(typestring));
+    }
+    const typestring = 'Compact(address arbiter,address sponsor,uint256 nonce,uint256 expires,bytes12 lockTag,address token,uint256 amount)';
+    console.log('typestring: ', typestring);
+    return (0, viem_1.keccak256)((0, viem_1.toBytes)(typestring));
+}
+function getClaimHash(message, witnessTypeString) {
+    // Convert lockTag bigint to bytes12 hex string and token bigint to address
+    const messageWithFormattedData = {
+        ...message,
+        lockTag: `0x${message.lockTag.toString(16).padStart(24, '0')}`,
+        token: typeof message.token === 'bigint'
+            ? `0x${message.token.toString(16).padStart(40, '0')}`
+            : message.token,
+    };
+    console.log('messageWithFormattedData: ', messageWithFormattedData);
+    console.log('Hererererere');
+    console.log('getTypes(message): ', getTypes(message, witnessTypeString));
+    console.log('herererere: ');
+    return (0, utils_1.hashStruct)({
+        types: getTypes(messageWithFormattedData, witnessTypeString),
+        primaryType: 'Compact',
+        data: messageWithFormattedData,
+    });
+}
+function getTypes(message, witnessTypeString) {
+    console.log('message: ', message);
+    return {
+        Compact: [
+            { name: 'arbiter', type: 'address' },
+            { name: 'sponsor', type: 'address' },
+            { name: 'nonce', type: 'uint256' },
+            { name: 'expires', type: 'uint256' },
+            { name: 'lockTag', type: 'bytes12' },
+            { name: 'token', type: 'address' },
+            { name: 'amount', type: 'uint256' },
+            ...(message.mandate ? [{ name: 'mandate', type: 'Mandate' }] : []),
+        ],
+        ...(message.mandate
+            ? {
+                Mandate: witnessTypeString.split(',').map((field) => {
+                    const [type, name] = field.trim().split(/\s+/);
+                    return { name, type };
+                }),
+            }
+            : {}),
+    };
+}

package/dist/utils/index.d.ts

@@ -0,0 +1 @@
+export * from "./compact";

package/dist/utils/index.js

@@ -0,0 +1,17 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./compact"), exports);

package/dist/utils/web3.d.ts

@@ -0,0 +1,9 @@
+import { ethers } from "ethers";
+import { SignAuthorizationReturnType } from "viem/_types/accounts/utils/signAuthorization";
+import { AuthorizationListEntryAny } from "../types";
+export declare const encodeRLPAuthorizationEntryUnsigned: (chainId: number, address: any, nonce: bigint) => string;
+export declare const getAuthorizationList: (chainId: number, nonce: bigint, authorizer: string, signer: ethers.Wallet | ethers.VoidSigner) => Promise<AuthorizationListEntryAny[]>;
+export declare const getSignedTransaction: (provider: ethers.Provider, relayer: ethers.SigningKey, authorizationList: SignAuthorizationReturnType | AuthorizationListEntryAny[], to?: string, value?: bigint | number, data?: string, nonce?: number) => Promise<string>;
+export declare const serializeEip7702: (tx: any, _sig: null | ethers.Signature) => string;
+export declare const ACCOUNT_CODE_PREFIX = "0xef0100";
+export declare const isAccountDelegatedToAddress: (provider: ethers.Provider, account: string, authority: string) => Promise<boolean>;

package/dist/utils/web3.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isAccountDelegatedToAddress = exports.ACCOUNT_CODE_PREFIX = exports.serializeEip7702 = exports.getSignedTransaction = exports.getAuthorizationList = exports.encodeRLPAuthorizationEntryUnsigned = void 0;
+const ethers_1 = require("ethers");
+const formatNumber = (_value) => {
+    const value = typeof _value === "bigint" ? _value : BigInt(_value);
+    // Convert bigint to hex string, then to bytes for RLP encoding
+    const hexValue = ethers_1.ethers.toBeHex(value);
+    return ethers_1.ethers.getBytes(hexValue);
+};
+const encodeRLPAuthorizationEntryUnsigned = (chainId, address, nonce) => {
+    // MAGIC = "0x05" defined in ERC-7702
+    return ethers_1.ethers.concat([
+        "0x05",
+        ethers_1.ethers.encodeRlp([formatNumber(chainId), address, formatNumber(nonce)]),
+    ]);
+};
+exports.encodeRLPAuthorizationEntryUnsigned = encodeRLPAuthorizationEntryUnsigned;
+const getAuthorizationList = async (chainId, nonce, authorizer, signer) => {
+    const dataToSign = (0, exports.encodeRLPAuthorizationEntryUnsigned)(chainId, authorizer, nonce);
+    const authHash = ethers_1.ethers.keccak256(dataToSign);
+    // TODO: should be signDigest
+    const sig = await signer.signMessage(authHash);
+    // In ethers v6, splitSignature is removed, we need to parse manually
+    const sigBytes = ethers_1.ethers.getBytes(sig);
+    const r = ethers_1.ethers.hexlify(sigBytes.slice(0, 32));
+    const s = ethers_1.ethers.hexlify(sigBytes.slice(32, 64));
+    const v = sigBytes[64];
+    const yParity = v - 27;
+    return [
+        {
+            chainId: chainId,
+            address: authorizer,
+            nonce: nonce,
+            yParity: yParity,
+            r: r,
+            s: s,
+        },
+    ];
+};
+exports.getAuthorizationList = getAuthorizationList;
+const getSignedTransaction = async (provider, relayer, authorizationList, to = ethers_1.ethers.ZeroAddress, value = 0, data = "0x", nonce) => {
+    const relayerAddress = ethers_1.ethers.computeAddress(relayer.publicKey);
+    const relayerNonce = nonce || (await provider.getTransactionCount(relayerAddress));
+    const valueBigInt = typeof value === "bigint" ? value : BigInt(value);
+    const tx = {
+        from: relayerAddress,
+        nonce: relayerNonce,
+        gasLimit: 21000000,
+        gasPrice: 3100,
+        data: data,
+        to: to,
+        value: valueBigInt,
+        chainId: (await provider.getNetwork()).chainId,
+        type: 4,
+        maxFeePerGas: 30000,
+        maxPriorityFeePerGas: 30000,
+        accessList: [],
+        authorizationList: authorizationList,
+    };
+    const encodedTx = (0, exports.serializeEip7702)(tx, null);
+    const txHashToSign = ethers_1.ethers.keccak256(encodedTx);
+    const signature = relayer.sign(txHashToSign);
+    return (0, exports.serializeEip7702)(tx, signature);
+};
+exports.getSignedTransaction = getSignedTransaction;
+const serializeEip7702 = (tx, _sig) => {
+    const fields = [
+        formatNumber(tx.chainId),
+        formatNumber(tx.nonce),
+        formatNumber(tx.maxPriorityFeePerGas || 0),
+        formatNumber(tx.maxFeePerGas || 0),
+        formatNumber(tx.gasLimit),
+        tx.to,
+        formatNumber(tx.value),
+        tx.data,
+        formatAccessList(tx.accessList || []),
+        formatAuthorizationList(tx.authorizationList || []),
+    ];
+    if (_sig) {
+        // In ethers v6, Signature object has r, s, v properties
+        const yParity = _sig.v - 27;
+        fields.push(formatNumber(yParity));
+        fields.push(ethers_1.ethers.getBytes(_sig.r));
+        fields.push(ethers_1.ethers.getBytes(_sig.s));
+    }
+    return ethers_1.ethers.concat(["0x04", ethers_1.ethers.encodeRlp(fields)]);
+};
+exports.serializeEip7702 = serializeEip7702;
+const formatAccessList = (value) => {
+    return ethers_1.ethers
+        .accessListify(value)
+        .map((set) => [set.address, set.storageKeys]);
+};
+const formatAuthorizationList = (value) => {
+    return value.map((set) => formatAuthorizationEntry(set));
+};
+const formatAuthorizationEntry = (set) => {
+    return [
+        formatNumber(set.chainId),
+        set.address,
+        formatNumber(set.nonce),
+        formatNumber(set.yParity),
+        ethers_1.ethers.getBytes(set.r),
+        ethers_1.ethers.getBytes(set.s),
+    ];
+};
+exports.ACCOUNT_CODE_PREFIX = "0xef0100";
+const isAccountDelegatedToAddress = async (provider, account, authority) => {
+    const codeAtEOA = await provider.getCode(account);
+    return (codeAtEOA.length === 48 &&
+        codeAtEOA.startsWith(exports.ACCOUNT_CODE_PREFIX) &&
+        ethers_1.ethers.getAddress("0x" + codeAtEOA.slice(8)) === authority);
+};
+exports.isAccountDelegatedToAddress = isAccountDelegatedToAddress;