@owlprotocol/contracts-account-abstraction
Version:
ERC4337 Account Abstraction support for deploying relevant smart contracts and interacting with UserOps.
178 lines (177 loc) • 7.99 kB
JavaScript
var import_vitest = require("vitest");
var import_viem = require("viem");
var import_chains = require("viem/chains");
var import_chains2 = require("@owlprotocol/chains");
var import_account_abstraction = require("viem/account-abstraction");
var import_viem_utils = require("@owlprotocol/viem-utils");
var import_accounts = require("viem/accounts");
var import_accounts2 = require("permissionless/accounts");
var import_clients = require("permissionless/clients");
var import_pimlico = require("permissionless/actions/pimlico");
var import_eip1193 = require("@owlprotocol/backend-public/eip1193");
var import_envvars = require("@owlprotocol/envvars");
var import_createBundlerEIP1193 = require("./createBundlerEIP1193.js");
var import_createPaymasterEIP1193 = require("./createPaymasterEIP1193.js");
var import_createBackendBundler = require("../clients/createBackendBundler.js");
var import_createBackendPaymaster = require("../clients/createBackendPaymaster.js");
var import_constants = require("../test/constants.js");
var import_SimpleAccount = require("../SimpleAccount.js");
var import_ERC1967Proxy = require("../artifacts/ERC1967Proxy.js");
var import_MyContract = require("../artifacts/MyContract.js");
var import_setupERC4337Contracts = require("../setupERC4337Contracts.js");
(0, import_vitest.describe)("eip1993/createPaymasterEIP1193.test.ts", function() {
let chain;
let account;
let transport;
if (import_envvars.NODE_ENV === "test") {
chain = {
...import_chains.localhost,
rpcUrls: {
default: {
http: [`http://127.0.0.1:${import_constants.port}`]
}
}
};
account = (0, import_viem_utils.getLocalAccount)(0, { nonceManager: import_viem.nonceManager });
transport = (0, import_viem.http)(chain.rpcUrls.default.http[0]);
} else {
chain = import_chains2.sepolia;
account = (0, import_viem_utils.getUtilityAccount)({ nonceManager: import_viem.nonceManager });
transport = (0, import_viem.http)(import_chains2.sepolia.rpcUrls.drpc.http[0]);
}
const publicClient = (0, import_viem.createPublicClient)({
chain,
transport
});
const walletClient = (0, import_viem.createWalletClient)({
account,
chain,
transport
});
const entryPointAddress = import_setupERC4337Contracts.erc4337Contracts.entrypoint;
const entryPointSimulationsAddress = import_setupERC4337Contracts.erc4337Contracts.pimlicoEntrypointSimulations;
const factoryAddress = import_setupERC4337Contracts.erc4337Contracts.simpleAccountFactory;
let paymasterAddress;
let bundlerTransport;
let bundlerClient;
let paymasterRequest;
let paymasterTransport;
let paymasterClient;
(0, import_vitest.beforeAll)(async () => {
paymasterAddress = (await (0, import_setupERC4337Contracts.setupVerifyingPaymaster)(walletClient, {
verifyingSignerAddress: (0, import_viem_utils.getPaymasterSignerAccount)({ nonceManager: import_viem.nonceManager }).address
})).address;
if (import_envvars.NODE_ENV === "test") {
const { hash: topupHash } = await (0, import_setupERC4337Contracts.topupPaymaster)(walletClient, {
paymaster: paymasterAddress,
minBalance: (0, import_viem.parseEther)("1")
});
if (topupHash) {
await publicClient.waitForTransactionReceipt({ hash: topupHash });
}
}
const requestOverride = (0, import_eip1193.createPublicEIP1193)((0, import_eip1193.createHttpEIP1193)(`http://127.0.0.1:${import_constants.port}`));
const bundlerRequest = (0, import_createBundlerEIP1193.createBackendBundlerEIP1193)(
(0, import_createBackendBundler.createBackendBundler)({
account: walletClient.account,
chain,
transport,
entryPointSimulationsAddress
}),
//viem middleware bypass
{ requestOverride }
);
bundlerTransport = (0, import_viem.custom)({
request: bundlerRequest,
config: { retryCount: 0 }
});
bundlerClient = (0, import_account_abstraction.createBundlerClient)({ transport: bundlerTransport });
paymasterRequest = (0, import_createPaymasterEIP1193.createBackendPaymasterEIP1193)(
(0, import_createBackendPaymaster.createBackendPaymaster)({
account: (0, import_viem_utils.getPaymasterSignerAccount)({ nonceManager: import_viem.nonceManager }),
chain,
transport,
paymaster: paymasterAddress
})
);
paymasterTransport = (0, import_viem.custom)({
request: paymasterRequest,
config: { retryCount: 0 }
});
paymasterClient = (0, import_account_abstraction.createPaymasterClient)({ transport: paymasterTransport });
});
(0, import_vitest.describe)("paymasterClient", () => {
(0, import_vitest.test)("pm_getPaymasterStubData", async () => {
const result = await paymasterClient.request({
method: "pm_getPaymasterStubData",
params: [{}, import_account_abstraction.entryPoint07Address, (0, import_viem.numberToHex)(chain.id), {}]
});
(0, import_vitest.expect)(result).toBeDefined();
});
});
(0, import_vitest.describe)("smartAccountClient", () => {
let owner;
let smartAccount;
let smartAccountClient;
let contractAddressExpected;
let contractDeployTransaction;
(0, import_vitest.beforeEach)(async () => {
owner = (0, import_accounts.privateKeyToAccount)((0, import_accounts.generatePrivateKey)());
const smartAccountAddress = (0, import_SimpleAccount.getSimpleAccountAddress)(
{
owner: owner.address,
salt: 0n
},
{
factoryAddress,
proxyBytecode: import_ERC1967Proxy.ERC1967Proxy.bytecode
}
);
smartAccount = await (0, import_accounts2.toSimpleSmartAccount)({
address: smartAccountAddress,
client: publicClient,
owner,
factoryAddress,
entryPoint: {
address: entryPointAddress,
version: "0.7"
}
});
smartAccountClient = (0, import_clients.createSmartAccountClient)({
account: smartAccount,
chain: publicClient.chain,
paymaster: paymasterClient,
bundlerTransport,
userOperation: {
estimateFeesPerGas: async () => (await (0, import_pimlico.getUserOperationGasPrice)(paymasterClient)).fast
}
});
const deployParams = {
// "random" salt
salt: (0, import_viem.padHex)(owner.address, { size: 32 }),
bytecode: import_MyContract.MyContract.bytecode
};
contractDeployTransaction = (0, import_viem_utils.getDeployDeterministicFunctionData)(deployParams);
contractAddressExpected = (0, import_viem_utils.getDeployDeterministicAddress)(deployParams);
});
(0, import_vitest.test)("smartAccountClient.sendTransaction", async () => {
const hash = await smartAccountClient.sendTransaction(contractDeployTransaction);
const receipt = await publicClient.waitForTransactionReceipt({ hash });
(0, import_vitest.expect)(receipt).toBeDefined();
const contractBytecode = await publicClient.getCode({ address: contractAddressExpected });
(0, import_vitest.expect)(contractBytecode).toBeDefined();
});
(0, import_vitest.test)("smartAccountClient.prepareUserOperation", async () => {
const userOperation = await smartAccountClient.prepareUserOperation({
calls: [contractDeployTransaction]
});
userOperation.signature = await smartAccount.signUserOperation(userOperation);
const userOpHash = await bundlerClient.sendUserOperation(userOperation);
const userOpReceipt = await (0, import_account_abstraction.waitForUserOperationReceipt)(bundlerClient, { hash: userOpHash });
(0, import_vitest.expect)(userOpReceipt).toBeDefined();
console.log({ contractAddressExpected });
const contractBytecode = await publicClient.getCode({ address: contractAddressExpected });
(0, import_vitest.expect)(contractBytecode).toBeDefined();
});
});
});