@rhinestone/sdk 0.2.0 → 0.2.1

package/README.md

@@ -22,11 +22,9 @@ yarn add viem @rhinestone/sdk
 bun install viem @rhinestone/sdk
 ```
 
-### Quick Start
+### Quickstart
 
-You'll need a Rhinestone API key, as well as an existing account with some testnet tokens.
-
-You can get some testnet USDC using a [Circle Faucet](https://faucet.circle.com). Make sure you have the testnet ETH on the source chain as well.
+You'll need a Rhinestone API key, as well as an existing account with some testnet ETH on the source chain.
 
 ## Creating a Wallet
 
@@ -79,7 +77,7 @@ const account = privateKeyToAccount(privateKey)
 
 const rhinestoneAccount = await createRhinestoneAccount({
   account: {
-    type: 'safe',
+    type: 'nexus',
   },
   owners: {
     type: 'ecdsa',
@@ -94,7 +92,7 @@ console.log(address)
 
 ## Funding the Account
 
-We will send some tokens from the funding account to the Safe account.
+We will send some ETH from the funding account to the created Safe account. The Orchestrator will use some of that ETH to deploy the account on the target chain, as well as convert it to USDC for a transfer transaction.
 
 ```ts
 const usdc = getTokenAddress(sourceChain)
@@ -107,16 +105,6 @@ const txHash = await fundingClient.sendTransaction({
 })
 await publicClient.waitForTransactionReceipt({ hash: txHash })
 
-const txHash2 = await fundingClient.sendTransaction({
-  to: usdcSource,
-  data: encodeFunctionData({
-    abi: erc20Abi,
-    functionName: 'transfer',
-    args: [address, usdcAmount],
-  }),
-})
-await publicClient.waitForTransactionReceipt({ hash: txHash2 })
-
 function getTokenAddress(chain: Chain) {
   switch (chain.id) {
     case baseSepolia.id:

package/dist/accounts/index.d.ts

@@ -0,0 +1,24 @@
+import { Account, Chain } from 'viem';
+import { RhinestoneAccountConfig } from '../types';
+declare function getDeployArgs(config: RhinestoneAccountConfig): Promise<{
+    factory: `0x${string}`;
+    factoryData: `0x${string}`;
+    salt: `0x${string}`;
+    hashedInitcode: `0x${string}`;
+    implementation: `0x${string}`;
+    initializationCallData: null;
+} | {
+    factory: `0x${string}`;
+    factoryData: `0x${string}`;
+    salt: `0x${string}`;
+    hashedInitcode: `0x${string}`;
+    implementation: `0x${string}`;
+    initializationCallData: `0x${string}`;
+}>;
+declare function getAddress(config: RhinestoneAccountConfig): Promise<`0x${string}`>;
+declare function isDeployed(chain: Chain, config: RhinestoneAccountConfig): Promise<boolean>;
+declare function deploySource(deployer: Account, chain: Chain, config: RhinestoneAccountConfig): Promise<void>;
+declare function deployTarget(chain: Chain, config: RhinestoneAccountConfig): Promise<void>;
+declare function getBundleInitCode(config: RhinestoneAccountConfig): Promise<`0x${string}` | undefined>;
+export { getDeployArgs, getBundleInitCode, getAddress, isDeployed, deploySource, deployTarget, };
+//# sourceMappingURL=index.d.ts.map

package/dist/accounts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../accounts/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EACP,KAAK,EASN,MAAM,MAAM,CAAA;AAEb,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAclD,iBAAe,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;;;;;;;;;GAS3D;AAED,iBAAe,UAAU,CAAC,MAAM,EAAE,uBAAuB,0BAgBxD;AAED,iBAAe,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,oBAiBtE;AAED,iBAAe,YAAY,CACzB,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,uBAAuB,iBAOhC;AAED,iBAAe,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,iBAKxE;AAED,iBAAe,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,sCAU/D;AA+ID,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,YAAY,EACZ,YAAY,GACb,CAAA"}

package/dist/accounts/index.js

@@ -0,0 +1,183 @@
+import { createPublicClient, http, createWalletClient, size, keccak256, encodePacked, slice, } from 'viem';
+import { getDeployArgs as getSafeDeployArgs, get7702InitCalls as get7702SafeInitCalls, get7702SmartAccount as get7702SafeAccount, } from './safe';
+import { getDeployArgs as getNexusDeployArgs, get7702InitCalls as get7702NexusInitCalls, get7702SmartAccount as get7702NexusAccount, } from './nexus';
+import { getBundlerClient } from './utils';
+async function getDeployArgs(config) {
+    switch (config.account.type) {
+        case 'safe': {
+            return getSafeDeployArgs(config);
+        }
+        case 'nexus': {
+            return getNexusDeployArgs(config);
+        }
+    }
+}
+async function getAddress(config) {
+    if (is7702(config)) {
+        if (!config.eoa) {
+            throw new Error('EIP-7702 accounts must have an EOA account');
+        }
+        return config.eoa.address;
+    }
+    const { factory, salt, hashedInitcode } = await getDeployArgs(config);
+    const hash = keccak256(encodePacked(['bytes1', 'address', 'bytes32', 'bytes'], ['0xff', factory, salt, hashedInitcode]));
+    const address = slice(hash, 12, 32);
+    return address;
+}
+async function isDeployed(chain, config) {
+    const publicClient = createPublicClient({
+        chain: chain,
+        transport: http(),
+    });
+    const address = await getAddress(config);
+    const code = await publicClient.getCode({
+        address,
+    });
+    if (!code) {
+        return false;
+    }
+    if (code.startsWith('0xef0100') && code.length === 48) {
+        // Defensive check to ensure there's no storage conflict; can be lifted in the future
+        throw new Error('Existing EIP-7702 accounts are not yet supported');
+    }
+    return size(code) > 0;
+}
+async function deploySource(deployer, chain, config) {
+    if (is7702(config)) {
+        return deploy7702Self(chain, config);
+    }
+    else {
+        return deployStandaloneSelf(deployer, chain, config);
+    }
+}
+async function deployTarget(chain, config) {
+    if (is7702(config)) {
+        return deploy7702WithBundler(chain, config);
+    }
+    // No need to deploy manually outside of EIP-7702
+}
+async function getBundleInitCode(config) {
+    if (is7702(config)) {
+        return undefined;
+    }
+    else {
+        const { factory, factoryData } = await getDeployArgs(config);
+        if (!factory || !factoryData) {
+            throw new Error('Factory args not available');
+        }
+        return encodePacked(['address', 'bytes'], [factory, factoryData]);
+    }
+}
+async function deploy7702Self(chain, config) {
+    if (!config.eoa) {
+        throw new Error('EIP-7702 accounts must have an EOA account');
+    }
+    const { implementation, initializationCallData } = await getDeployArgs(config);
+    if (!initializationCallData) {
+        throw new Error(`Initialization call data not available for ${config.account.type}`);
+    }
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(),
+    });
+    const accountClient = createWalletClient({
+        account: config.eoa,
+        chain,
+        transport: http(),
+    });
+    const authorization = await accountClient.signAuthorization({
+        contractAddress: implementation,
+        executor: 'self',
+    });
+    const hash = await accountClient.sendTransaction({
+        chain,
+        authorizationList: [authorization],
+        to: config.eoa.address,
+        data: initializationCallData,
+    });
+    await publicClient.waitForTransactionReceipt({ hash });
+}
+async function deployStandaloneSelf(deployer, chain, config) {
+    const { factory, factoryData } = await getDeployArgs(config);
+    const publicClient = createPublicClient({
+        chain: chain,
+        transport: http(),
+    });
+    const client = createWalletClient({
+        account: deployer,
+        chain: chain,
+        transport: http(),
+    });
+    const tx = await client.sendTransaction({
+        to: factory,
+        data: factoryData,
+    });
+    await publicClient.waitForTransactionReceipt({ hash: tx });
+}
+async function deploy7702WithBundler(chain, config) {
+    if (!config.eoa) {
+        throw new Error('EIP-7702 accounts must have an EOA account');
+    }
+    const { implementation } = await getDeployArgs(config);
+    const publicClient = createPublicClient({
+        chain,
+        transport: http(),
+    });
+    const accountClient = createWalletClient({
+        account: config.eoa,
+        chain,
+        transport: http(),
+    });
+    const bundlerClient = getBundlerClient(config, publicClient);
+    const fundingClient = createWalletClient({
+        account: config.deployerAccount,
+        chain,
+        transport: http(),
+    });
+    const authorization = await accountClient.signAuthorization({
+        contractAddress: implementation,
+    });
+    // Will be replaced by a bundler in the future
+    const authTxHash = await fundingClient.sendTransaction({
+        chain: publicClient.chain,
+        authorizationList: [authorization],
+    });
+    await publicClient.waitForTransactionReceipt({ hash: authTxHash });
+    // Init the account
+    const smartAccount = await get7702SmartAccount(config, publicClient);
+    const initCalls = await get7702InitCalls(config);
+    const opHash = await bundlerClient.sendUserOperation({
+        account: smartAccount,
+        calls: initCalls,
+    });
+    await bundlerClient.waitForUserOperationReceipt({
+        hash: opHash,
+    });
+}
+async function get7702InitCalls(config) {
+    switch (config.account.type) {
+        case 'safe': {
+            return get7702SafeInitCalls();
+        }
+        case 'nexus': {
+            return get7702NexusInitCalls(config);
+        }
+    }
+}
+async function get7702SmartAccount(config, client) {
+    if (!config.eoa) {
+        throw new Error('EIP-7702 accounts must have an EOA account');
+    }
+    switch (config.account.type) {
+        case 'safe': {
+            return get7702SafeAccount();
+        }
+        case 'nexus': {
+            return get7702NexusAccount(config.eoa, client);
+        }
+    }
+}
+function is7702(config) {
+    return config.eoa !== undefined;
+}
+export { getDeployArgs, getBundleInitCode, getAddress, isDeployed, deploySource, deployTarget, };