@owlprotocol/contracts-account-abstraction
Version:
ERC4337 Account Abstraction support for deploying relevant smart contracts and interacting with UserOps.
217 lines (216 loc) • 8.49 kB
JavaScript
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
var PackedUserOperation_exports = {};
__export(PackedUserOperation_exports, {
packAccountGasLimits: () => packAccountGasLimits,
packPaymasterData: () => packPaymasterData,
packUserOperation: () => packUserOperation,
packedUserOperationToRandomDataUserOp: () => packedUserOperationToRandomDataUserOp,
toPackedUserOperation: () => toPackedUserOperation,
toUserOperationEncoded: () => toUserOperationEncoded,
unpackAccountGasLimits: () => unpackAccountGasLimits,
unpackGasLimits: () => unpackGasLimits,
unpackInitCode: () => unpackInitCode,
unpackPaymasterAndData: () => unpackPaymasterAndData
});
module.exports = __toCommonJS(PackedUserOperation_exports);
var import_viem = require("viem");
function toPackedUserOperation(userOp) {
const accountGasLimits = packAccountGasLimits(userOp.verificationGasLimit, userOp.callGasLimit);
const gasFees = packAccountGasLimits(userOp.maxPriorityFeePerGas, userOp.maxFeePerGas);
let paymasterAndData = "0x";
if (userOp.paymaster && userOp.paymaster !== import_viem.zeroAddress && userOp.paymasterVerificationGasLimit && userOp.paymasterPostOpGasLimit && userOp.paymasterData) {
paymasterAndData = packPaymasterData(
userOp.paymaster,
userOp.paymasterVerificationGasLimit,
userOp.paymasterPostOpGasLimit,
userOp.paymasterData
);
}
const initCode = userOp.factory && userOp.factory != import_viem.zeroAddress && userOp.factoryData ? (0, import_viem.concatHex)([userOp.factory, userOp.factoryData]) : "0x";
return {
sender: userOp.sender,
nonce: BigInt(userOp.nonce),
callData: userOp.callData,
accountGasLimits,
initCode,
preVerificationGas: BigInt(userOp.preVerificationGas),
gasFees,
paymasterAndData,
signature: userOp.signature
};
}
function toUserOperationEncoded(packedUserOperation) {
const { factory, factoryData } = unpackInitCode(packedUserOperation.initCode);
const { callGasLimit, verificationGasLimit } = unpackAccountGasLimits(packedUserOperation.accountGasLimits);
const { maxFeePerGas, maxPriorityFeePerGas } = unpackGasLimits(packedUserOperation.gasFees);
const { paymaster, paymasterVerificationGasLimit, paymasterPostOpGasLimit, paymasterData } = unpackPaymasterAndData(
packedUserOperation.paymasterAndData
);
return {
sender: packedUserOperation.sender,
nonce: (0, import_viem.numberToHex)(packedUserOperation.nonce),
factory: factory ?? import_viem.zeroAddress,
factoryData: factoryData ?? "0x",
callData: packedUserOperation.callData,
callGasLimit: (0, import_viem.numberToHex)(callGasLimit),
verificationGasLimit: (0, import_viem.numberToHex)(verificationGasLimit),
preVerificationGas: (0, import_viem.numberToHex)(packedUserOperation.preVerificationGas),
maxFeePerGas: (0, import_viem.numberToHex)(maxFeePerGas),
maxPriorityFeePerGas: (0, import_viem.numberToHex)(maxPriorityFeePerGas),
paymaster: paymaster ?? import_viem.zeroAddress,
paymasterVerificationGasLimit: (0, import_viem.numberToHex)(paymasterVerificationGasLimit ?? 0n),
paymasterPostOpGasLimit: (0, import_viem.numberToHex)(paymasterPostOpGasLimit ?? 0n),
paymasterData: paymasterData ?? "0x",
signature: packedUserOperation.signature
};
}
function packedUserOperationToRandomDataUserOp(packedUserOperation) {
return {
sender: packedUserOperation.sender,
nonce: BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
initCode: packedUserOperation.initCode,
callData: packedUserOperation.callData,
accountGasLimits: (0, import_viem.bytesToHex)(new Uint8Array(32).fill(255)),
preVerificationGas: BigInt("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF"),
gasFees: (0, import_viem.bytesToHex)(new Uint8Array(32).fill(255)),
paymasterAndData: (0, import_viem.bytesToHex)(new Uint8Array(packedUserOperation.paymasterAndData.length).fill(255)),
signature: (0, import_viem.bytesToHex)(new Uint8Array(packedUserOperation.signature.length).fill(255))
};
}
function packUserOperation(packedUserOperation) {
const randomDataUserOp = packedUserOperationToRandomDataUserOp(packedUserOperation);
return (0, import_viem.encodeAbiParameters)(
[
{
internalType: "address",
name: "sender",
type: "address"
},
{
internalType: "uint256",
name: "nonce",
type: "uint256"
},
{
internalType: "bytes",
name: "initCode",
type: "bytes"
},
{
internalType: "bytes",
name: "callData",
type: "bytes"
},
{
internalType: "uint256",
name: "accountGasLimits",
type: "bytes32"
},
{
internalType: "uint256",
name: "preVerificationGas",
type: "uint256"
},
{
internalType: "uint256",
name: "gasFees",
type: "bytes32"
},
{
internalType: "bytes",
name: "paymasterAndData",
type: "bytes"
},
{
internalType: "bytes",
name: "signature",
type: "bytes"
}
],
[
randomDataUserOp.sender,
randomDataUserOp.nonce,
// need non zero bytes to get better estimations for preVerificationGas
packedUserOperation.initCode,
packedUserOperation.callData,
randomDataUserOp.accountGasLimits,
// need non zero bytes to get better estimations for preVerificationGas
randomDataUserOp.preVerificationGas,
// need non zero bytes to get better estimations for preVerificationGas
randomDataUserOp.gasFees,
// need non zero bytes to get better estimations for preVerificationGas
randomDataUserOp.paymasterAndData,
randomDataUserOp.signature
]
);
}
function packAccountGasLimits(verificationGasLimit, callGasLimit) {
return (0, import_viem.concatHex)([
(0, import_viem.pad)(verificationGasLimit, { dir: "left", size: 16 }),
(0, import_viem.pad)(callGasLimit, { dir: "left", size: 16 })
]);
}
function unpackInitCode(initCode) {
if (initCode === "0x") {
return {
factory: null,
factoryData: null
};
}
return {
factory: (0, import_viem.getAddress)((0, import_viem.slice)(initCode, 0, 20)),
factoryData: (0, import_viem.slice)(initCode, 20)
};
}
function unpackGasLimits(gasLimits) {
return {
maxPriorityFeePerGas: BigInt((0, import_viem.slice)(gasLimits, 0, 16)),
maxFeePerGas: BigInt((0, import_viem.slice)(gasLimits, 16))
};
}
function unpackPaymasterAndData(paymasterAndData) {
if (paymasterAndData === "0x") {
return {
paymaster: null,
paymasterVerificationGasLimit: null,
paymasterPostOpGasLimit: null,
paymasterData: null
};
}
return {
paymaster: (0, import_viem.getAddress)((0, import_viem.slice)(paymasterAndData, 0, 20)),
paymasterVerificationGasLimit: BigInt((0, import_viem.slice)(paymasterAndData, 20, 36)),
paymasterPostOpGasLimit: BigInt((0, import_viem.slice)(paymasterAndData, 36, 52)),
paymasterData: (0, import_viem.slice)(paymasterAndData, 52)
};
}
function packPaymasterData(paymaster, paymasterVerificationGasLimit, postOpGasLimit, paymasterData) {
return (0, import_viem.concatHex)([
(0, import_viem.pad)(paymaster, { dir: "left", size: 20 }),
(0, import_viem.pad)(paymasterVerificationGasLimit, { dir: "left", size: 16 }),
(0, import_viem.pad)(postOpGasLimit, { dir: "left", size: 16 }),
paymasterData
]);
}
function unpackAccountGasLimits(accountGasLimits) {
return {
verificationGasLimit: parseInt(accountGasLimits.slice(2, 34), 16),
callGasLimit: parseInt(accountGasLimits.slice(34), 16)
};
}