init static method

Future<Kernel> init(EthPrivateKey credentials, String rpcUrl, { IPresetBuilderOpts? opts, })

Initializes a Kernel object and returns it.

Implementation

static Future<Kernel> init(
  EthPrivateKey credentials,
  String rpcUrl, {
  IPresetBuilderOpts? opts,
}) async {
  final instance = Kernel(credentials, rpcUrl, opts: opts);

  try {
    final List<String> inputArr = [
      instance.eCDSAKernelFactory.self.address.toString(),
      bytesToHex(
        instance.eCDSAKernelFactory.self.function('createAccount').encodeCall(
          [
            credentials.address,
            opts?.salt ?? BigInt.zero,
          ],
        ),
        include0x: true,
      ),
    ];
    instance.initCode =
        '0x${inputArr.map((hexStr) => hexStr.toString().substring(2)).join('')}';
    final ethCallData = bytesToHex(
      instance.entryPoint.self.function('getSenderAddress').encodeCall([
        hexToBytes(instance.initCode),
      ]),
      include0x: true,
    );
    await instance.entryPoint.client.makeRPCCall('eth_call', [
      {
        'to': instance.entryPoint.self.address.toString(),
        'data': ethCallData,
      }
    ]);
  } on RPCError catch (e) {
    if (e.data == 'revert') {
      rethrow;
    }
    final smartContractAddress = '0x${(e.data as String).lastChars(40)}';
    final chain = await instance.eCDSAKernelFactory.client.getChainId();
    final ms = Safe().multiSend[chain.toString()];
    if (ms == null) {
      throw Exception(
        'Multisend contract not deployed on network: ${chain.toString()}',
      );
    }
    instance.multisend = Multisend(
      address: EthereumAddress.fromHex(ms),
      client: instance.multisend.client,
    );
    instance.proxy = kernel_impl.Kernel(
      address: EthereumAddress.fromHex(smartContractAddress),
      client: instance.proxy.client,
    );
  }

  final inputArr = [
    KernelModes.SUDO,
    bytesToHex(
      credentials.signPersonalMessageToUint8List(
        Uint8List.fromList('0xdead'.codeUnits),
      ),
      include0x: true,
    ),
  ];
  final signature =
      '0x${inputArr.map((hexStr) => hexStr.toString().substring(2)).join('')}';
  final baseInstance = instance
      .useDefaults({
        'sender': instance.proxy.self.address.toString(),
        'signature': bytesToHex(hexToBytes(signature), include0x: true),
      })
      .useMiddleware(instance.resolveAccount)
      .useMiddleware(getGasPrice(
        instance.eCDSAKernelFactory.client,
      ));

  final withPM = opts?.paymasterMiddleware != null
      ? baseInstance.useMiddleware(
          opts?.paymasterMiddleware as UserOperationMiddlewareFn)
      : baseInstance.useMiddleware(
          estimateUserOperationGas(
            instance.eCDSAKernelFactory.client,
          ),
        );

  return withPM
      .useMiddleware(signUserOpHash(instance.credentials))
      .useMiddleware(instance.sudoMode) as Kernel;
}