@charterlabs/rhinestone-sdk 0.0.1

package/README.md

@@ -0,0 +1,208 @@
+# Rhinestone SDK
+
+End-to-end chain abstraction and modularity toolkit
+
+## Usage
+
+### Installation
+
+```bash
+npm install viem @rhinestone/sdk
+```
+
+```bash
+pnpm install viem @rhinestone/sdk
+```
+
+```bash
+yarn add viem @rhinestone/sdk
+```
+
+```bash
+bun install viem @rhinestone/sdk
+```
+
+## Quickstart
+
+You'll need a Rhinestone API key, as well as an existing account with some testnet ETH on the source chain.
+
+### Creating a Wallet
+
+Let's create a smart account with a single owner:
+
+```ts
+import { createRhinestoneAccount } from '@rhinestone/sdk'
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
+import { baseSepolia, arbitrumSepolia, optimismSepolia } from 'viem/chains'
+import {
+  Chain,
+  createPublicClient,
+  createWalletClient,
+  encodeFunctionData,
+  erc20Abi,
+  Hex,
+  http,
+  parseEther,
+} from 'viem'
+
+const fundingPrivateKey = process.env.FUNDING_PRIVATE_KEY
+if (!fundingPrivateKey) {
+  throw new Error('FUNDING_PRIVATE_KEY is not set')
+}
+
+const rhinestoneApiKey = process.env.RHINESTONE_API_KEY
+if (!rhinestoneApiKey) {
+  throw new Error('RHINESTONE_API_KEY is not set')
+}
+
+const sourceChain = baseSepolia
+const targetChain = arbitrumSepolia
+
+// You can use an existing PK here
+const privateKey = generatePrivateKey()
+console.log(`Owner private key: ${privateKey}`)
+const account = privateKeyToAccount(privateKey)
+
+const rhinestoneAccount = await createRhinestoneAccount({
+  owners: {
+    type: 'ecdsa',
+    accounts: [account],
+  }
+  rhinestoneApiKey,
+})
+const address = await rhinestoneAccount.getAddress()
+console.log(`Smart account address: ${address}`)
+```
+
+### Funding the Account
+
+We will send some ETH from the funding account to the created smart account. The Orchestrator will use some of that ETH to deploy the account on the target chain, as well as to convert it to USDC for a transfer transaction.
+
+```ts
+const publicClient = createPublicClient({
+  chain: sourceChain,
+  transport: http(),
+});
+const fundingAccount = privateKeyToAccount(fundingPrivateKey as Hex);
+const fundingClient = createWalletClient({
+  account: fundingAccount,
+  chain: sourceChain,
+  transport: http(),
+});
+
+const txHash = await fundingClient.sendTransaction({
+  to: address,
+  value: parseEther('0.001'),
+});
+await publicClient.waitForTransactionReceipt({ hash: txHash });
+```
+
+### Sending a Cross-chain Transaction
+
+Finally, let's make a cross-chain token transfer:
+
+```ts
+const usdcTarget = '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d';
+const usdcAmount = 1n;
+
+const transaction = await rhinestoneAccount.sendTransaction({
+  sourceChain,
+  targetChain,
+  calls: [
+    {
+      to: usdcTarget,
+      value: 0n,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'transfer',
+        args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', usdcAmount],
+      }),
+    },
+  ],
+  tokenRequests: [
+    {
+      address: usdcTarget,
+      amount: usdcAmount,
+    },
+  ],
+});
+console.log('Transaction', transaction);
+
+const transactionResult = await rhinestoneAccount.waitForExecution(transaction);
+console.log('Result', transactionResult);
+```
+
+After running that, you will get a smart account deployed on both Base Sepolia and Arbitrum Sepolia, and make a cross-chain USDC transfer.
+
+### Using Smart Sessions
+
+First, define a session you want to use:
+
+```ts
+const session: Session = {
+  owners: {
+    type: 'ecdsa',
+    accounts: [sessionOwner],
+  },
+  actions: [
+    {
+      target: wethAddress,
+      selector: toFunctionSelector(
+        getAbiItem({
+          abi: wethAbi,
+          name: 'deposit',
+        }),
+      ),
+    },
+    {
+      target: wethAddress,
+      selector: toFunctionSelector(
+        getAbiItem({
+          abi: wethAbi,
+          name: 'transfer',
+        }),
+      ),
+      policies: [
+        {
+          type: 'universal-action',
+          rules: [
+            {
+              condition: 'equal',
+              calldataOffset: 0n,
+              referenceValue: '0xd8da6bf26964af9d7eed9e03e53415d37aa96045',
+            },
+          ],
+        },
+      ],
+    },
+  ],
+}
+```
+
+During account initialization, provide the session you've just created. Make sure to also provide a bundler configuration.
+
+```ts
+const rhinestoneAccount = await createRhinestoneAccount({
+  // …
+  sessions: [session],
+  bundler: {
+    // …
+  },
+})
+```
+
+When making a transaction, specify the `signers` object to sign it with the session key:
+
+```ts
+const transactionResult = await rhinestoneAccount.sendTransaction({
+  // …
+  signers: {
+    type: 'session',
+    session: session,
+  },
+})
+```
+
+## Contributing
+
+For feature or change requests, feel free to open a PR, start a discussion or get in touch with us.

package/dist/accounts/index.d.ts

@@ -0,0 +1,27 @@
+import { type Chain, type Hex, type PublicClient } from 'viem';
+import type { OwnerSet, RhinestoneAccountConfig, Session } from '../types';
+declare function getDeployArgs(config: RhinestoneAccountConfig): {
+    factory: `0x${string}`;
+    factoryData: `0x${string}`;
+    salt: `0x${string}`;
+    hashedInitcode: `0x${string}`;
+    implementation: `0x${string}`;
+    initializationCallData: `0x${string}`;
+} | {
+    factory: `0x${string}`;
+    factoryData: `0x${string}`;
+    salt: `0x${string}`;
+    hashedInitcode: `0x${string}`;
+    implementation: `0x${string}`;
+    initializationCallData: null;
+};
+declare function getAddress(config: RhinestoneAccountConfig): `0x${string}`;
+declare function isDeployed(chain: Chain, config: RhinestoneAccountConfig): Promise<boolean>;
+declare function deploySource(chain: Chain, config: RhinestoneAccountConfig): Promise<void>;
+declare function deployTarget(chain: Chain, config: RhinestoneAccountConfig, asUserOp: boolean): Promise<void>;
+declare function getBundleInitCode(config: RhinestoneAccountConfig): `0x${string}` | undefined;
+declare function getSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
+declare function getSmartSessionSmartAccount(config: RhinestoneAccountConfig, client: PublicClient, chain: Chain, session: Session): Promise<import("viem/account-abstraction").SmartAccount<import("viem/account-abstraction").SmartAccountImplementation<import("viem").Abi, "0.7">>>;
+declare function sign(validators: OwnerSet, chain: Chain, hash: Hex): Promise<`0x${string}`>;
+export { getDeployArgs, getBundleInitCode, getAddress, isDeployed, deploySource, deployTarget, getSmartAccount, getSmartSessionSmartAccount, sign, };
+//# 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,EAEL,KAAK,KAAK,EAKV,KAAK,GAAG,EAGR,KAAK,YAAY,EAIlB,MAAM,MAAM,CAAA;AAUb,OAAO,KAAK,EAEV,QAAQ,EACR,uBAAuB,EACvB,OAAO,EACR,MAAM,UAAU,CAAA;AAiBjB,iBAAS,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;;;;;;;;;EAUrD;AAED,iBAAS,UAAU,CAAC,MAAM,EAAE,uBAAuB,iBAgBlD;AAED,iBAAe,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,oBAiBtE;AAED,iBAAe,YAAY,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,iBAMxE;AAED,iBAAe,YAAY,CACzB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,uBAAuB,EAC/B,QAAQ,EAAE,OAAO,iBASlB;AAUD,iBAAS,iBAAiB,CAAC,MAAM,EAAE,uBAAuB,6BAUzD;AAgID,iBAAe,eAAe,CAC5B,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,KAAK,sJA0Bb;AAED,iBAAe,2BAA2B,CACxC,MAAM,EAAE,uBAAuB,EAC/B,MAAM,EAAE,YAAY,EACpB,KAAK,EAAE,KAAK,EACZ,OAAO,EAAE,OAAO,sJA8BjB;AAED,iBAAe,IAAI,CAAC,UAAU,EAAE,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,0BAYhE;AAgED,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,UAAU,EACV,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,eAAe,EACf,2BAA2B,EAC3B,IAAI,GACL,CAAA"}

package/dist/accounts/index.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDeployArgs = getDeployArgs;
+exports.getBundleInitCode = getBundleInitCode;
+exports.getAddress = getAddress;
+exports.isDeployed = isDeployed;
+exports.deploySource = deploySource;
+exports.deployTarget = deployTarget;
+exports.getSmartAccount = getSmartAccount;
+exports.getSmartSessionSmartAccount = getSmartSessionSmartAccount;
+exports.sign = sign;
+const viem_1 = require("viem");
+const modules_1 = require("../modules");
+const validators_1 = require("../modules/validators");
+const nexus_1 = require("./nexus");
+const safe_1 = require("./safe");
+const utils_1 = require("./utils");
+function getDeployArgs(config) {
+    const account = getAccount(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getDeployArgs)(config);
+        }
+        case 'nexus': {
+            return (0, nexus_1.getDeployArgs)(config);
+        }
+    }
+}
+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 } = getDeployArgs(config);
+    const hash = (0, viem_1.keccak256)((0, viem_1.encodePacked)(['bytes1', 'address', 'bytes32', 'bytes'], ['0xff', factory, salt, hashedInitcode]));
+    const address = (0, viem_1.slice)(hash, 12, 32);
+    return address;
+}
+async function isDeployed(chain, config) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: chain,
+        transport: (0, viem_1.http)(),
+    });
+    const address = 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 (0, viem_1.size)(code) > 0;
+}
+async function deploySource(chain, config) {
+    if (is7702(config)) {
+        return deploy7702Self(chain, config);
+    }
+    else {
+        return deployStandalone(chain, config);
+    }
+}
+async function deployTarget(chain, config, asUserOp) {
+    if (is7702(config)) {
+        return deploy7702WithBundler(chain, config);
+    }
+    if (asUserOp) {
+        return deployStandalone(chain, config);
+    }
+    // No need to deploy manually for the intent flow
+}
+async function deployStandalone(chain, config) {
+    const deployer = config.deployerAccount;
+    if (deployer) {
+        return deployStandaloneWithEoa(chain, config, deployer);
+    }
+    return deployStandaloneWithBundler(chain, config);
+}
+function getBundleInitCode(config) {
+    if (is7702(config)) {
+        return undefined;
+    }
+    else {
+        const { factory, factoryData } = getDeployArgs(config);
+        if (!factory || !factoryData) {
+            throw new Error('Factory args not available');
+        }
+        return (0, viem_1.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 account = getAccount(config);
+    const { implementation, initializationCallData } = getDeployArgs(config);
+    if (!initializationCallData) {
+        throw new Error(`Initialization call data not available for ${account.type}`);
+    }
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, viem_1.http)(),
+    });
+    const accountClient = (0, viem_1.createWalletClient)({
+        account: config.eoa,
+        chain,
+        transport: (0, viem_1.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 deployStandaloneWithEoa(chain, config, deployer) {
+    const { factory, factoryData } = getDeployArgs(config);
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain: chain,
+        transport: (0, viem_1.http)(),
+    });
+    const client = (0, viem_1.createWalletClient)({
+        account: deployer,
+        chain: chain,
+        transport: (0, viem_1.http)(),
+    });
+    const tx = await client.sendTransaction({
+        to: factory,
+        data: factoryData,
+    });
+    await publicClient.waitForTransactionReceipt({ hash: tx });
+}
+async function deployStandaloneWithBundler(chain, config) {
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, viem_1.http)(),
+    });
+    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+    const smartAccount = await getSmartAccount(config, publicClient, chain);
+    const { factory, factoryData } = getDeployArgs(config);
+    const opHash = await bundlerClient.sendUserOperation({
+        account: smartAccount,
+        factory,
+        factoryData,
+        calls: [
+            {
+                to: viem_1.zeroHash,
+                value: 0n,
+                data: '0x',
+            },
+        ],
+    });
+    await bundlerClient.waitForUserOperationReceipt({
+        hash: opHash,
+    });
+}
+async function deploy7702WithBundler(chain, config) {
+    if (!config.eoa) {
+        throw new Error('EIP-7702 accounts must have an EOA account');
+    }
+    const { implementation } = getDeployArgs(config);
+    const publicClient = (0, viem_1.createPublicClient)({
+        chain,
+        transport: (0, viem_1.http)(),
+    });
+    const accountClient = (0, viem_1.createWalletClient)({
+        account: config.eoa,
+        chain,
+        transport: (0, viem_1.http)(),
+    });
+    const bundlerClient = (0, utils_1.getBundlerClient)(config, publicClient);
+    const authorization = await accountClient.signAuthorization({
+        contractAddress: implementation,
+    });
+    // Init the account
+    const smartAccount = await get7702SmartAccount(config, publicClient);
+    const initCalls = await get7702InitCalls(config);
+    const opHash = await bundlerClient.sendUserOperation({
+        account: smartAccount,
+        calls: initCalls,
+        authorization,
+    });
+    await bundlerClient.waitForUserOperationReceipt({
+        hash: opHash,
+    });
+}
+async function getSmartAccount(config, client, chain) {
+    const account = getAccount(config);
+    const address = getAddress(config);
+    const ownerValidator = (0, validators_1.getOwnerValidator)(config);
+    const signFn = (hash) => sign(config.owners, chain, hash);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getSmartAccount)(client, address, config.owners, ownerValidator.address, signFn);
+        }
+        case 'nexus': {
+            return (0, nexus_1.getSmartAccount)(client, address, config.owners, ownerValidator.address, signFn);
+        }
+    }
+}
+async function getSmartSessionSmartAccount(config, client, chain, session) {
+    const address = getAddress(config);
+    const smartSessionValidator = (0, validators_1.getSmartSessionValidator)(config);
+    if (!smartSessionValidator) {
+        throw new Error('Smart sessions are not enabled for this account');
+    }
+    const signFn = (hash) => sign(session.owners, chain, hash);
+    const account = getAccount(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.getSessionSmartAccount)(client, address, session, smartSessionValidator.address, signFn);
+        }
+        case 'nexus': {
+            return (0, nexus_1.getSessionSmartAccount)(client, address, session, smartSessionValidator.address, signFn);
+        }
+    }
+}
+async function sign(validators, chain, hash) {
+    switch (validators.type) {
+        case 'ecdsa': {
+            const signatures = await Promise.all(validators.accounts.map((account) => signEcdsa(account, hash)));
+            return (0, viem_1.concat)(signatures);
+        }
+        case 'passkey': {
+            return await signPasskey(validators.account, chain, hash);
+        }
+    }
+}
+async function signEcdsa(account, hash) {
+    if (!account.signMessage) {
+        throw new Error('Signing not supported for the account');
+    }
+    return await account.signMessage({ message: { raw: hash } });
+}
+async function signPasskey(account, chain, hash) {
+    const { webauthn, signature } = await account.sign({ hash });
+    const usePrecompiled = (0, modules_1.isRip7212SupportedNetwork)(chain);
+    const encodedSignature = (0, modules_1.getWebauthnValidatorSignature)({
+        webauthn,
+        signature,
+        usePrecompiled,
+    });
+    return encodedSignature;
+}
+async function get7702SmartAccount(config, client) {
+    if (!config.eoa) {
+        throw new Error('EIP-7702 accounts must have an EOA account');
+    }
+    const account = getAccount(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.get7702SmartAccount)();
+        }
+        case 'nexus': {
+            return (0, nexus_1.get7702SmartAccount)(config.eoa, client);
+        }
+    }
+}
+async function get7702InitCalls(config) {
+    const account = getAccount(config);
+    switch (account.type) {
+        case 'safe': {
+            return (0, safe_1.get7702InitCalls)();
+        }
+        case 'nexus': {
+            return (0, nexus_1.get7702InitCalls)(config);
+        }
+    }
+}
+function is7702(config) {
+    return config.eoa !== undefined;
+}
+function getAccount(config) {
+    if (config.account) {
+        return config.account;
+    }
+    return {
+        type: 'nexus',
+    };
+}

package/dist/accounts/nexus.d.ts

@@ -0,0 +1,20 @@
+import type { Abi, Account, Address, Hex, PublicClient } from 'viem';
+import { type SmartAccount, type SmartAccountImplementation } from 'viem/account-abstraction';
+import type { OwnerSet, RhinestoneAccountConfig, Session } from '../types';
+declare function getDeployArgs(config: RhinestoneAccountConfig): {
+    factory: `0x${string}`;
+    factoryData: `0x${string}`;
+    salt: `0x${string}`;
+    hashedInitcode: `0x${string}`;
+    implementation: `0x${string}`;
+    initializationCallData: `0x${string}`;
+};
+declare function getSmartAccount(client: PublicClient, address: Address, owners: OwnerSet, validatorAddress: Address, sign: (hash: Hex) => Promise<Hex>): Promise<SmartAccount<SmartAccountImplementation<Abi, "0.7">>>;
+declare function getSessionSmartAccount(client: PublicClient, address: Address, session: Session, validatorAddress: Address, sign: (hash: Hex) => Promise<Hex>): Promise<SmartAccount<SmartAccountImplementation<Abi, "0.7">>>;
+declare function get7702SmartAccount(account: Account, client: PublicClient): Promise<SmartAccount<SmartAccountImplementation<Abi, "0.7">>>;
+declare function get7702InitCalls(config: RhinestoneAccountConfig): {
+    to: `0x${string}`;
+    data: `0x${string}`;
+}[];
+export { getDeployArgs, getSmartAccount, getSessionSmartAccount, get7702SmartAccount, get7702InitCalls, };
+//# sourceMappingURL=nexus.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nexus.d.ts","sourceRoot":"","sources":["../../accounts/nexus.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,MAAM,MAAM,CAAA;AAUpE,OAAO,EAIL,KAAK,YAAY,EACjB,KAAK,0BAA0B,EAEhC,MAAM,0BAA0B,CAAA;AASjC,OAAO,KAAK,EAAE,QAAQ,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAa1E,iBAAS,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;;;EA8ErD;AAED,iBAAe,eAAe,CAC5B,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,QAAQ,EAChB,gBAAgB,EAAE,OAAO,EACzB,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,iEAWlC;AAED,iBAAe,sBAAsB,CACnC,MAAM,EAAE,YAAY,EACpB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE,OAAO,EAChB,gBAAgB,EAAE,OAAO,EACzB,IAAI,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,iEAuBlC;AAED,iBAAe,mBAAmB,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,YAAY,iEAkBxE;AAgFD,iBAAS,gBAAgB,CAAC,MAAM,EAAE,uBAAuB;;;IAqDxD;AAED,OAAO,EACL,aAAa,EACb,eAAe,EACf,sBAAsB,EACtB,mBAAmB,EACnB,gBAAgB,GACjB,CAAA"}