SDK and Contract Interactions - DeeDive

export type RemoteSignerParams = {
    account: LocalAccount,
    chainId: number,
    apiKey: string,
    sessionKey: string,
    permissionsBackendUrl?: string
}

async function signUserOp(
    account: Account, 
    chainId: number, 
    apiKey: string, 
    sessionKey: string, 
    userOp: UserOperation, 
    permissionsBackendUrl: string = PERMISSIONS_URL
): Promise<UserOperation> {
    return signUserOpWithSessionKey(account.address, chainId, apiKey, sessionKey, userOp, permissionsBackendUrl);
}

export async function toRemoteSigner({
    account,
    chainId,
    apiKey,
    sessionKey
}: RemoteSignerParams): Promise<ExtendedLocalAccount> {
    // Get sessionKey from apiKey and account
    const sessionKeyResponse = await getSessionKey(account.address, chainId, apiKey, sessionKey);

    // Create the extendedLocalAccount object and add the method
    const extendedLocalAccount: ExtendedLocalAccount = {
        ...account, // Spread the properties of the original LocalAccount
        async signUserOpWithRemoteSigner(userOp: UserOperation) {
            const signedUserOp = await signUserOp(account, chainId, apiKey, sessionKeyResponse.sessionKey, userOp);
            return signedUserOp;
        },

        async signMessage({ message }) {
            throw new Error('signMessage with sessionKey not implemented');
        },
        async signTransaction(_, __) {
            throw new Error('signTransaction with sessionKey not implemented');
        },
        async signTypedData<
            const TTypedData extends TypedData | Record<string, unknown>,
            TPrimaryType extends keyof TTypedData | 'EIP712Domain' = keyof TTypedData
        >(typedData: TypedDataDefinition<TTypedData, TPrimaryType>) {
            throw new Error('signTypedData not implemented');
        },
    };

    return extendedLocalAccount;
}

export const signUserOperation = async (
    etherspotWalletAccount: LocalAccount, 
    chainId: number, 
    apiKey: string, 
    sessionKey: string, 
    userOp: UserOperation
) => {
    const remoteSigner: ExtendedLocalAccount = await toRemoteSigner({
        account: etherspotWalletAccount,
        chainId: chainId,
        apiKey: apiKey,
        sessionKey: sessionKey,
        permissionsBackendUrl: PERMISSIONS_URL
    });

    const signedUserOp = await remoteSigner.signUserOpWithRemoteSigner(userOp);

    if (!signedUserOp || !signedUserOp.signature || signedUserOp.signature === '0x') {
        throw new Error('Failed to sign user operation');
    }

    return signedUserOp;
}

const erc20SessionKeyValidator = '';
BigNumber.from(erc20SessionKeyValidator)

function validateUserOp(
    PackedUserOperation calldata userOp,
    bytes32 userOpHash,
    uint256 missingAccountFunds
)
    external
    payable
    virtual
    override
    onlyEntryPoint
    payPrefund(missingAccountFunds)
    returns (uint256 validSignature)
{
    address validator;
    // @notice validator encoding in nonce is just an example!
    // @notice this is not part of the standard!
    // Account Vendors may choose any other way to implement validator selection
    uint256 nonce = userOp.nonce;
    assembly {
        validator := shr(96, nonce)
    }