@rhinestone/sdk 1.0.0-alpha.8 → 1.0.0-beta.38

package/dist/src/execution/utils.js

@@ -2,13 +2,22 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareTransaction = prepareTransaction;
 exports.signTransaction = signTransaction;
+exports.signAuthorizations = signAuthorizations;
+exports.signAuthorizationsInternal = signAuthorizationsInternal;
+exports.signMessage = signMessage;
+exports.signTypedData = signTypedData;
 exports.submitTransaction = submitTransaction;
+exports.prepareUserOperation = prepareUserOperation;
+exports.signUserOperation = signUserOperation;
+exports.submitUserOperation = submitUserOperation;
 exports.getOrchestratorByChain = getOrchestratorByChain;
 exports.signIntent = signIntent;
 exports.prepareTransactionAsIntent = prepareTransactionAsIntent;
 exports.submitIntentInternal = submitIntentInternal;
 exports.getValidatorAccount = getValidatorAccount;
 exports.parseCalls = parseCalls;
+exports.getTokenRequests = getTokenRequests;
+exports.resolveCallInputs = resolveCallInputs;
 const viem_1 = require("viem");
 const account_abstraction_1 = require("viem/account-abstraction");
 const accounts_1 = require("../accounts");
@@ -18,93 +27,196 @@ const core_1 = require("../modules/validators/core");
 const orchestrator_1 = require("../orchestrator");
 const consts_1 = require("../orchestrator/consts");
 const registry_1 = require("../orchestrator/registry");
+const compact_1 = require("./compact");
 const error_1 = require("./error");
+const permit2_1 = require("./permit2");
 async function prepareTransaction(config, transaction) {
-    const { sourceChains, targetChain, tokenRequests, signers } = getTransactionParams(transaction);
+    const { sourceChains, targetChain, tokenRequests, signers, sponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds, } = getTransactionParams(transaction);
     const accountAddress = (0, accounts_1.getAddress)(config);
-    let data;
-    const asUserOp = signers?.type === 'guardians' || signers?.type === 'session';
-    if (asUserOp) {
-        if (sourceChains && sourceChains.length > 0) {
-            throw new error_1.SourceChainsNotAvailableForUserOpFlowError();
-        }
-        // Smart sessions require a UserOp flow
-        data = await prepareTransactionAsUserOp(config, targetChain, transaction.calls, signers);
-    }
-    else {
-        data = await prepareTransactionAsIntent(config, sourceChains, targetChain, transaction.calls, transaction.gasLimit, tokenRequests, accountAddress);
+    const isUserOpSigner = signers?.type === 'guardians' || signers?.type === 'session';
+    if (isUserOpSigner) {
+        throw new error_1.SignerNotSupportedError();
     }
+    const intentRoute = await prepareTransactionAsIntent(config, sourceChains, targetChain, await resolveCallInputs(transaction.calls, config, targetChain, accountAddress), transaction.gasLimit, tokenRequests, accountAddress, sponsored ?? false, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds);
     return {
-        data,
+        intentRoute,
         transaction,
     };
 }
-async function signTransaction(config, preparedTransaction) {
-    const { targetChain, signers } = getTransactionParams(preparedTransaction.transaction);
-    const data = preparedTransaction.data;
-    const asUserOp = data.type === 'userop';
-    let signature;
-    if (asUserOp) {
-        const chain = targetChain;
-        const userOp = data.userOp;
-        if (!userOp) {
-            throw new error_1.UserOperationRequiredForSmartSessionsError();
+async function prepareUserOperation(config, transaction) {
+    const chain = transaction.chain;
+    const signers = transaction.signers;
+    const accountAddress = (0, accounts_1.getAddress)(config);
+    const data = await prepareTransactionAsUserOp(config, chain, await resolveCallInputs(transaction.calls, config, chain, accountAddress), signers, transaction.gasLimit);
+    return {
+        userOperation: data.userOp,
+        hash: data.hash,
+        transaction,
+    };
+}
+async function resolveCallInputs(inputs, config, chain, accountAddress) {
+    const resolved = [];
+    for (const intent of inputs) {
+        if ('resolve' in intent) {
+            const result = await intent.resolve({ config, chain, accountAddress });
+            if (Array.isArray(result)) {
+                resolved.push(...result);
+            }
+            else if (result) {
+                resolved.push(result);
+            }
+        }
+        else {
+            resolved.push(intent);
         }
-        // Smart sessions require a UserOp flow
-        signature = await signUserOp(config, chain, signers, userOp);
-    }
-    else {
-        signature = await signIntent(config, targetChain, data.hash, signers);
     }
+    return resolved;
+}
+async function signTransaction(config, preparedTransaction) {
+    const { targetChain, signers } = getTransactionParams(preparedTransaction.transaction);
+    const intentRoute = preparedTransaction.intentRoute;
+    const signature = await signIntent(config, targetChain, intentRoute.intentOp, signers);
     return {
-        data,
+        intentRoute,
         transaction: preparedTransaction.transaction,
         signature,
     };
 }
-async function submitTransaction(config, signedTransaction) {
-    const { data, transaction, signature } = signedTransaction;
-    const { sourceChains, targetChain } = getTransactionParams(transaction);
-    const asUserOp = data.type === 'userop';
-    if (asUserOp) {
-        const chain = targetChain;
-        const userOp = data.userOp;
-        if (!userOp) {
-            throw new error_1.UserOperationRequiredForSmartSessionsError();
-        }
-        // Smart sessions require a UserOp flow
-        return await submitUserOp(config, chain, userOp, signature);
+async function signUserOperation(config, preparedUserOperation) {
+    const chain = preparedUserOperation.transaction.chain;
+    const userOp = preparedUserOperation.userOperation;
+    const signers = preparedUserOperation.transaction.signers;
+    // Smart sessions require a UserOp flow
+    const signature = await signUserOp(config, chain, signers, userOp);
+    return {
+        userOperation: preparedUserOperation.userOperation,
+        hash: preparedUserOperation.hash,
+        transaction: preparedUserOperation.transaction,
+        signature,
+    };
+}
+async function signAuthorizations(config, preparedTransaction) {
+    return await signAuthorizationsInternal(config, preparedTransaction.intentRoute);
+}
+async function signMessage(config, message, chain, signers) {
+    const validator = getValidator(config, signers);
+    if (!validator) {
+        throw new Error('Validator not available');
     }
-    else {
-        const intentOp = data.intentRoute.intentOp;
-        if (!intentOp) {
-            throw new error_1.OrderPathRequiredForIntentsError();
+    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
+    const isRoot = validator.address === ownerValidator.address;
+    const hash = (0, viem_1.hashMessage)(message);
+    const signature = await (0, accounts_1.getPackedSignature)(config, signers, chain, {
+        address: validator.address,
+        isRoot,
+    }, hash);
+    return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
+}
+async function signTypedData(config, parameters, chain, signers) {
+    const validator = getValidator(config, signers);
+    if (!validator) {
+        throw new Error('Validator not available');
+    }
+    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
+    const isRoot = validator.address === ownerValidator.address;
+    const signature = await (0, accounts_1.getTypedDataPackedSignature)(config, signers, chain, {
+        address: validator.address,
+        isRoot,
+    }, parameters);
+    return await (0, accounts_1.toErc6492Signature)(config, signature, chain);
+}
+async function signAuthorizationsInternal(config, data) {
+    const eoa = config.eoa;
+    if (!eoa) {
+        throw new Error('EIP-7702 initialization is required for EOA accounts');
+    }
+    const accountAddress = (0, accounts_1.getAddress)(config);
+    const requiredDelegations = 'intentOp' in data
+        ? data.intentOp.signedMetadata.account.requiredDelegations || {}
+        : {};
+    const authorizations = [];
+    for (const chainId in requiredDelegations) {
+        const delegation = requiredDelegations[chainId];
+        const chain = (0, registry_1.getChainById)(Number(chainId));
+        const walletClient = (0, viem_1.createWalletClient)({
+            chain,
+            account: eoa,
+            transport: (0, utils_1.createTransport)(chain, config.provider),
+        }).extend(viem_1.publicActions);
+        const code = await walletClient.getCode({
+            address: accountAddress,
+        });
+        const isDelegated = code === (0, viem_1.concat)(['0xef0100', delegation.contract.toLowerCase()]);
+        if (isDelegated) {
+            continue;
         }
-        return await submitIntent(config, sourceChains, targetChain, intentOp, signature);
+        const authorization = await walletClient.signAuthorization({
+            contractAddress: delegation.contract,
+            chainId: Number(chainId),
+        });
+        authorizations.push(authorization);
     }
+    return authorizations;
+}
+async function submitTransaction(config, signedTransaction, authorizations, dryRun = false) {
+    const { intentRoute, transaction, signature } = signedTransaction;
+    const { sourceChains, targetChain } = getTransactionParams(transaction);
+    const intentOp = intentRoute.intentOp;
+    return await submitIntent(config, sourceChains, targetChain, intentOp, signature, authorizations, dryRun);
+}
+async function submitUserOperation(config, signedUserOperation) {
+    const chain = signedUserOperation.transaction.chain;
+    const userOp = signedUserOperation.userOperation;
+    const signature = signedUserOperation.signature;
+    // Smart sessions require a UserOp flow
+    return await submitUserOp(config, chain, userOp, signature);
 }
 function getTransactionParams(transaction) {
     const sourceChains = 'chain' in transaction ? [transaction.chain] : transaction.sourceChains;
     const targetChain = 'chain' in transaction ? transaction.chain : transaction.targetChain;
     const initialTokenRequests = transaction.tokenRequests;
     const signers = transaction.signers;
-    // Across requires passing some value to repay the solvers
-    const tokenRequests = !initialTokenRequests || initialTokenRequests.length === 0
-        ? [
-            {
-                address: viem_1.zeroAddress,
-                amount: 1n,
-            },
-        ]
-        : initialTokenRequests;
+    const eip7702InitSignature = transaction.eip7702InitSignature;
+    const sponsored = transaction.sponsored;
+    const gasLimit = transaction.gasLimit;
+    const settlementLayers = transaction.settlementLayers;
+    const sourceAssets = transaction.sourceAssets;
+    const feeAsset = transaction.feeAsset;
+    const lockFunds = transaction.lockFunds;
+    const tokenRequests = getTokenRequests(sourceChains || [], targetChain, initialTokenRequests, settlementLayers);
     return {
         sourceChains,
         targetChain,
         tokenRequests,
         signers,
+        sponsored,
+        eip7702InitSignature,
+        gasLimit,
+        settlementLayers,
+        sourceAssets,
+        feeAsset,
+        lockFunds,
     };
 }
-async function prepareTransactionAsUserOp(config, chain, callInputs, signers) {
+function getTokenRequests(sourceChains, targetChain, initialTokenRequests, settlementLayers) {
+    if (initialTokenRequests) {
+        validateTokenSymbols(targetChain, initialTokenRequests.map((tokenRequest) => tokenRequest.address));
+    }
+    // Across requires passing some value to repay the solvers
+    const defaultTokenRequest = {
+        address: viem_1.zeroAddress,
+        amount: 1n,
+    };
+    const isSameChain = (settlementLayers?.length === 1 && settlementLayers[0] === 'SAME_CHAIN') ||
+        (sourceChains.length === 1 && sourceChains[0].id === targetChain.id);
+    const tokenRequests = !initialTokenRequests || initialTokenRequests.length === 0
+        ? isSameChain
+            ? []
+            : [defaultTokenRequest]
+        : initialTokenRequests;
+    return tokenRequests;
+}
+async function prepareTransactionAsUserOp(config, chain, callInputs, signers, gasLimit) {
     const publicClient = (0, viem_1.createPublicClient)({
         chain,
         transport: (0, utils_1.createTransport)(chain, config.provider),
@@ -118,9 +230,9 @@ async function prepareTransactionAsUserOp(config, chain, callInputs, signers) {
     const userOp = await bundlerClient.prepareUserOperation({
         account: validatorAccount,
         calls,
+        callGasLimit: gasLimit,
     });
     return {
-        type: 'userop',
         userOp,
         hash: (0, account_abstraction_1.getUserOperationHash)({
             userOperation: userOp,
@@ -130,14 +242,19 @@ async function prepareTransactionAsUserOp(config, chain, callInputs, signers) {
         }),
     };
 }
-async function prepareTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress) {
-    const initCode = (0, accounts_1.getInitCode)(config);
+async function prepareTransactionAsIntent(config, sourceChains, targetChain, callInputs, gasLimit, tokenRequests, accountAddress, isSponsored, eip7702InitSignature, settlementLayers, sourceAssets, feeAsset, lockFunds) {
     const calls = parseCalls(callInputs, targetChain.id);
-    const accountAccessList = sourceChains && sourceChains.length > 0
-        ? {
-            chainIds: sourceChains.map((chain) => chain.id),
+    const accountAccessList = createAccountAccessList(sourceChains, sourceAssets);
+    const { setupOps, delegations } = await getSetupOperationsAndDelegations(config, targetChain, accountAddress, eip7702InitSignature);
+    const getAccountType = (config) => {
+        if (config.account?.type === 'eoa') {
+            return 'EOA';
+        }
+        else {
+            return 'ERC7579';
         }
-        : undefined;
+    };
+    const accountType = getAccountType(config);
     const metaIntent = {
         destinationChainId: targetChain.id,
         tokenTransfers: tokenRequests.map((tokenRequest) => ({
@@ -146,46 +263,87 @@ async function prepareTransactionAsIntent(config, sourceChains, targetChain, cal
         })),
         account: {
             address: accountAddress,
-            accountType: 'ERC7579',
-            setupOps: initCode
-                ? [
-                    {
-                        to: initCode.factory,
-                        data: initCode.factoryData,
-                    },
-                ]
-                : [
-                    {
-                        to: viem_1.zeroAddress,
-                        data: '0x',
-                    },
-                ],
+            accountType: accountType,
+            setupOps,
+            delegations,
         },
         destinationExecutions: calls,
         destinationGasUnits: gasLimit,
         accountAccessList,
+        options: {
+            topupCompact: lockFunds ?? false,
+            feeToken: feeAsset,
+            sponsorSettings: {
+                gasSponsored: isSponsored,
+                bridgeFeesSponsored: isSponsored,
+                swapFeesSponsored: isSponsored,
+            },
+            settlementLayers,
+        },
     };
-    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.apiKey, config.endpointUrl);
     const intentRoute = await orchestrator.getIntentRoute(metaIntent);
-    const intentHash = (0, orchestrator_1.getIntentOpHash)(intentRoute.intentOp);
-    return {
-        type: 'intent',
-        intentRoute,
-        hash: intentHash,
-    };
+    return intentRoute;
 }
-async function signIntent(config, targetChain, intentHash, signers) {
+async function signIntent(config, targetChain, intentOp, signers) {
+    if (config.account?.type === 'eoa') {
+        let signature;
+        let digest;
+        if (config.eoa?.signTypedData) {
+            const typedData = (0, permit2_1.getTypedData)(intentOp);
+            signature = await config.eoa.signTypedData(typedData);
+        }
+        else if (config.eoa?.sign) {
+            digest = (0, compact_1.getPermit2Digest)(intentOp);
+            signature = await config.eoa.sign({ hash: digest });
+        }
+        else if (config.eoa?.signMessage) {
+            digest = (0, compact_1.getPermit2Digest)(intentOp);
+            signature = await config.eoa.signMessage({
+                message: { raw: digest },
+            });
+        }
+        else {
+            throw new accounts_1.EoaSigningMethodNotConfiguredError('signTypedData, sign, or signMessage');
+        }
+        return signature;
+    }
     const validator = getValidator(config, signers);
     if (!validator) {
         throw new Error('Validator not available');
     }
     const ownerValidator = (0, validators_1.getOwnerValidator)(config);
     const isRoot = validator.address === ownerValidator.address;
-    const signature = await (0, accounts_1.getPackedSignature)(config, signers, targetChain, {
+    const signature = await getIntentSignature(config, intentOp, signers, targetChain, validator, isRoot);
+    return signature;
+}
+async function getIntentSignature(config, intentOp, signers, targetChain, validator, isRoot) {
+    const withJitFlow = intentOp.elements.some((element) => element.mandate.qualifier.settlementContext?.usingJIT);
+    if (withJitFlow) {
+        return await getPermit2Signature(config, intentOp, signers, targetChain, validator, isRoot);
+    }
+    return await getCompactSignature(config, intentOp, signers, targetChain, validator, isRoot);
+}
+async function getPermit2Signature(config, intentOp, signers, targetChain, validator, isRoot) {
+    const typedData = (0, permit2_1.getTypedData)(intentOp);
+    return await signIntentTypedData(config, signers, targetChain, validator, isRoot, typedData);
+}
+async function getCompactSignature(config, intentOp, signers, targetChain, validator, isRoot) {
+    const typedData = (0, compact_1.getCompactTypedData)(intentOp);
+    return await signIntentTypedData(config, signers, targetChain, validator, isRoot, typedData);
+}
+async function signIntentTypedData(config, signers, targetChain, validator, isRoot, parameters) {
+    if ((0, core_1.supportsEip712)(validator)) {
+        return await (0, accounts_1.getTypedDataPackedSignature)(config, signers, targetChain, {
+            address: validator.address,
+            isRoot,
+        }, parameters);
+    }
+    const hash = (0, viem_1.hashTypedData)(parameters);
+    return await (0, accounts_1.getPackedSignature)(config, signers, targetChain, {
         address: validator.address,
         isRoot,
-    }, intentHash);
-    return signature;
+    }, hash);
 }
 async function signUserOp(config, chain, signers, userOp) {
     const validator = getValidator(config, signers);
@@ -241,23 +399,39 @@ async function submitUserOp(config, chain, userOp, signature) {
         chain: chain.id,
     };
 }
-async function submitIntent(config, sourceChains, targetChain, intentOp, signature) {
-    return submitIntentInternal(config, sourceChains, targetChain, intentOp, signature);
+async function submitIntent(config, sourceChains, targetChain, intentOp, signature, authorizations, dryRun) {
+    return submitIntentInternal(config, sourceChains, targetChain, intentOp, signature, authorizations, dryRun);
 }
-function getOrchestratorByChain(chainId, apiKey) {
-    const orchestratorUrl = (0, registry_1.isTestnet)(chainId)
+function getOrchestratorByChain(chainId, apiKey, orchestratorUrl) {
+    if (orchestratorUrl) {
+        return (0, orchestrator_1.getOrchestrator)(apiKey, orchestratorUrl);
+    }
+    const defaultOrchestratorUrl = (0, registry_1.isTestnet)(chainId)
         ? consts_1.STAGING_ORCHESTRATOR_URL
         : consts_1.PROD_ORCHESTRATOR_URL;
-    return (0, orchestrator_1.getOrchestrator)(apiKey, orchestratorUrl);
+    return (0, orchestrator_1.getOrchestrator)(apiKey, defaultOrchestratorUrl);
 }
-async function submitIntentInternal(config, sourceChains, targetChain, intentOp, signature) {
-    const signedIntentOp = {
+function createSignedIntentOp(intentOp, signature, authorizations) {
+    return {
         ...intentOp,
         originSignatures: Array(intentOp.elements.length).fill(signature),
         destinationSignature: signature,
+        signedAuthorizations: authorizations.length > 0
+            ? authorizations.map((authorization) => ({
+                chainId: authorization.chainId,
+                address: authorization.address,
+                nonce: authorization.nonce,
+                yParity: authorization.yParity ?? 0,
+                r: authorization.r,
+                s: authorization.s,
+            }))
+            : undefined,
     };
-    const orchestrator = getOrchestratorByChain(targetChain.id, config.rhinestoneApiKey);
-    const intentResults = await orchestrator.submitIntent(signedIntentOp);
+}
+async function submitIntentInternal(config, sourceChains, targetChain, intentOp, signature, authorizations, dryRun) {
+    const signedIntentOp = createSignedIntentOp(intentOp, signature, authorizations);
+    const orchestrator = getOrchestratorByChain(targetChain.id, config.apiKey, config.endpointUrl);
+    const intentResults = await orchestrator.submitIntent(signedIntentOp, dryRun);
     return {
         type: 'intent',
         id: BigInt(intentResults.result.id),
@@ -267,7 +441,7 @@ async function submitIntentInternal(config, sourceChains, targetChain, intentOp,
 }
 async function getValidatorAccount(config, signers, publicClient, chain) {
     if (!signers) {
-        return undefined;
+        return (0, accounts_1.getSmartAccount)(config, publicClient, chain);
     }
     // Owners
     const withOwner = signers.type === 'owner' ? signers : null;
@@ -298,11 +472,10 @@ function getValidator(config, signers) {
         }
         // Passkeys (WebAuthn)
         if (withOwner.kind === 'passkey') {
-            const passkeyAccount = withOwner.account;
-            return (0, core_1.getWebAuthnValidator)({
-                pubKey: passkeyAccount.publicKey,
-                authenticatorId: passkeyAccount.id,
-            });
+            return (0, core_1.getWebAuthnValidator)(1, withOwner.accounts.map((account) => ({
+                pubKey: account.publicKey,
+                authenticatorId: account.id,
+            })));
         }
         // Multi-factor
         if (withOwner.kind === 'multi-factor') {
@@ -329,3 +502,84 @@ function parseCalls(calls, chainId) {
         to: (0, registry_1.resolveTokenAddress)(call.to, chainId),
     }));
 }
+function createAccountAccessList(sourceChains, sourceAssets) {
+    if (!sourceChains && !sourceAssets)
+        return undefined;
+    const chainIds = sourceChains?.map((chain) => chain.id);
+    if (!sourceAssets) {
+        return { chainIds };
+    }
+    if (Array.isArray(sourceAssets)) {
+        return chainIds
+            ? { chainIds, tokens: sourceAssets }
+            : { tokens: sourceAssets };
+    }
+    return { chainTokens: sourceAssets };
+}
+async function getSetupOperationsAndDelegations(config, chain, accountAddress, eip7702InitSignature) {
+    const initCode = (0, accounts_1.getInitCode)(config);
+    if (config.account?.type === 'eoa') {
+        return {
+            setupOps: [],
+        };
+    }
+    else if ((0, accounts_1.is7702)(config)) {
+        // EIP-7702 initialization is only needed for EOA accounts
+        if (!eip7702InitSignature || eip7702InitSignature === '0x') {
+            throw new Error('EIP-7702 initialization signature is required for EOA accounts');
+        }
+        const { initData: eip7702InitData, contract: eip7702Contract } = await (0, accounts_1.getEip7702InitCall)(config, eip7702InitSignature);
+        return {
+            setupOps: [
+                {
+                    to: accountAddress,
+                    data: eip7702InitData,
+                },
+            ],
+            delegations: {
+                0: {
+                    contract: eip7702Contract,
+                },
+            },
+        };
+    }
+    else if (initCode) {
+        const isAccountDeployed = await (0, accounts_1.isDeployed)(config, chain);
+        if (isAccountDeployed) {
+            return {
+                setupOps: [],
+            };
+        }
+        // Contract account with init code
+        return {
+            setupOps: [
+                {
+                    to: initCode.factory,
+                    data: initCode.factoryData,
+                },
+            ],
+        };
+    }
+    else {
+        // Already deployed contract account
+        return {
+            setupOps: [],
+        };
+    }
+}
+function validateTokenSymbols(chain, tokenAddressOrSymbols) {
+    function validateTokenSymbol(chain, addressOrSymbol) {
+        // Address
+        if ((0, viem_1.isAddress)(addressOrSymbol, { strict: false })) {
+            return true;
+        }
+        // Token symbol
+        const address = (0, registry_1.getTokenAddress)(addressOrSymbol, chain.id);
+        return (0, viem_1.isAddress)(address, { strict: false });
+    }
+    for (const addressOrSymbol of tokenAddressOrSymbols) {
+        if (!validateTokenSymbol(chain, addressOrSymbol)) {
+            throw new Error(`Invalid token symbol: ${addressOrSymbol}`);
+        }
+    }
+}