@rhinestone/sdk 0.1.0

package/README.md

@@ -0,0 +1,168 @@
+# 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
+```
+
+### Quick Start
+
+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.
+
+## Creating a Wallet
+
+Let's create a single-owner Safe account:
+
+```ts
+import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
+import { baseSepolia, arbitrumSepolia, optimismSepolia } from 'viem/chains'
+import {
+  Chain,
+  createPublicClient,
+  createWalletClient,
+  encodeFunctionData,
+  erc20Abi,
+  Hex,
+  http,
+  parseEther,
+} from 'viem'
+
+import { createRhinestoneAccount } from '@rhinestone/sdk'
+
+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
+
+const fundingAccount = privateKeyToAccount(fundingPrivateKey as Hex)
+const publicClient = createPublicClient({
+  chain: sourceChain,
+  transport: http(),
+})
+const fundingClient = createWalletClient({
+  account: fundingAccount,
+  chain: sourceChain,
+  transport: http(),
+})
+
+// You can use an existing PK here
+const privateKey = generatePrivateKey()
+console.log('pk', privateKey)
+const account = privateKeyToAccount(privateKey)
+
+const rhinestoneAccount = await createRhinestoneAccount({
+  account: {
+    type: 'safe',
+  },
+  owners: {
+    type: 'ecdsa',
+    accounts: [account],
+  }
+  rhinestoneApiKey,
+  deployerAccount: fundingAccount,
+})
+const address = await rhinestoneAccount.getAddress(sourceChain)
+console.log(address)
+```
+
+## Funding the Account
+
+We will send some tokens from the funding account to the Safe account.
+
+```ts
+const usdc = getTokenAddress(sourceChain)
+const usdcTarget = getTokenAddress(targetChain)
+const usdcAmount = 1n
+
+const txHash = await fundingClient.sendTransaction({
+  to: address,
+  value: parseEther('0.001'),
+})
+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:
+      return '0x036cbd53842c5426634e7929541ec2318f3dcf7e'
+    case arbitrumSepolia.id:
+      return '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d'
+    case optimismSepolia.id:
+      return '0x5fd84259d66Cd46123540766Be93DFE6D43130D7'
+    default:
+      throw new Error('Unsupported chain')
+  }
+}
+```
+
+## Sending a Cross-chain Transaction
+
+Finally, let's make a cross-chain token transfer:
+
+```ts
+const bundleId = await rhinestoneAccount.sendTransactions({
+  sourceChain,
+  targetChain,
+  calls: [
+    {
+      to: usdcTarget,
+      value: 0n,
+      data: encodeFunctionData({
+        abi: erc20Abi,
+        functionName: 'transfer',
+        args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', usdcAmount],
+      }),
+    },
+  ],
+  tokenRequests: [
+    {
+      address: usdcTarget,
+      amount: usdcAmount,
+    },
+  ],
+})
+console.log('id', bundleId)
+
+const bundleResult = await rhinestoneAccount.waitForExecution({ id: bundleId })
+console.log('status', bundleResult.status)
+```
+
+## Contributing
+
+For feature or change requests, feel free to open a PR, start a discussion or get in touch with us.

package/dist/example.d.ts

@@ -0,0 +1 @@
+//# sourceMappingURL=example.d.ts.map

package/dist/example.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"example.d.ts","sourceRoot":"","sources":["../example.ts"],"names":[],"mappings":""}

package/dist/example.js

@@ -0,0 +1,129 @@
+"use strict";
+// import { generatePrivateKey, privateKeyToAccount } from 'viem/accounts'
+// import { baseSepolia, arbitrumSepolia, optimismSepolia } from 'viem/chains'
+// import {
+//   Chain,
+//   createPublicClient,
+//   createWalletClient,
+//   encodeFunctionData,
+//   erc20Abi,
+//   Hex,
+//   http,
+//   parseEther,
+//   parseUnits,
+// } from 'viem'
+// import { createRhinestoneAccount } from './index'
+// 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
+// const usdc = getTokenAddress(sourceChain)
+// const usdcTarget = getTokenAddress(targetChain)
+// const usdcAmount = 1n
+// const fundingAccount = privateKeyToAccount(fundingPrivateKey as Hex)
+// const publicClient = createPublicClient({
+//   chain: sourceChain,
+//   transport: http(),
+// })
+// const fundingClient = createWalletClient({
+//   account: fundingAccount,
+//   chain: sourceChain,
+//   transport: http(),
+// })
+// console.log('new pks', [
+//   generatePrivateKey(),
+//   generatePrivateKey(),
+//   generatePrivateKey(),
+// ])
+// const privateKeyA =
+//   '0x04ba71050a787d8b50dbe6cfd35810276699a9eb6dae8c0ac48ccbf8d891324c'
+// const accountA = privateKeyToAccount(privateKeyA)
+// const privateKeyB =
+//   '0x921e8d0b257173f92791f47c14ecb84f0545a897a7b12f477a9fb743c1d2b2e3'
+// const accountB = privateKeyToAccount(privateKeyB)
+// const privateKeyC =
+//   '0xc55f1b744fcd9781d6a711fa8347dd41cf6fb662249aede85ed77e95bb2f3aa2'
+// const accountC = privateKeyToAccount(privateKeyC)
+// const rhinestoneAccount = await createRhinestoneAccount({
+//   account: {
+//     type: 'safe',
+//   },
+//   owners: {
+//     type: 'ecdsa',
+//     accounts: [accountA, accountB],
+//   },
+//   rhinestoneApiKey,
+//   deployerAccount: fundingAccount,
+// })
+// const address = await rhinestoneAccount.getAddress()
+// console.log(address)
+// // prefund
+// const ethBalance = await publicClient.getBalance({
+//   address,
+// })
+// if (ethBalance < parseEther('0.001')) {
+//   const txHash = await fundingClient.sendTransaction({
+//     to: address,
+//     value: parseEther('0.001'),
+//   })
+//   await publicClient.waitForTransactionReceipt({ hash: txHash })
+// }
+// const usdcBalance = await publicClient.readContract({
+//   address: usdc,
+//   abi: erc20Abi,
+//   functionName: 'balanceOf',
+//   args: [address],
+// })
+// if (usdcBalance < usdcAmount) {
+//   const txHash2 = await fundingClient.sendTransaction({
+//     to: usdc,
+//     data: encodeFunctionData({
+//       abi: erc20Abi,
+//       functionName: 'transfer',
+//       args: [address, usdcAmount],
+//     }),
+//   })
+//   await publicClient.waitForTransactionReceipt({ hash: txHash2 })
+// }
+// const bundleId = await rhinestoneAccount.sendTransactions({
+//   sourceChain,
+//   targetChain,
+//   calls: [
+//     {
+//       to: usdcTarget,
+//       value: 0n,
+//       data: encodeFunctionData({
+//         abi: erc20Abi,
+//         functionName: 'transfer',
+//         args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', usdcAmount],
+//       }),
+//     },
+//   ],
+//   tokenRequests: [
+//     {
+//       address: usdcTarget,
+//       amount: usdcAmount,
+//     },
+//   ],
+// })
+// console.log('id', bundleId)
+// const bundleResult = await rhinestoneAccount.waitForExecution({ id: bundleId })
+// console.log('status', bundleResult.status)
+// function getTokenAddress(chain: Chain) {
+//   switch (chain.id) {
+//     case baseSepolia.id:
+//       return '0x036cbd53842c5426634e7929541ec2318f3dcf7e'
+//     case arbitrumSepolia.id:
+//       return '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d'
+//     case optimismSepolia.id:
+//       return '0x5fd84259d66Cd46123540766Be93DFE6D43130D7'
+//     default:
+//       throw new Error('Unsupported chain')
+//   }
+// }

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+import { RhinestoneAccountConfig, Transaction } from './types';
+declare function createRhinestoneAccount(config: RhinestoneAccountConfig): Promise<{
+    config: RhinestoneAccountConfig;
+    sendTransactions: (transaction: Transaction) => Promise<bigint>;
+    waitForExecution: ({ id }: {
+        id: bigint;
+    }) => Promise<import("./services/orchestrator").BundleResult>;
+    getAddress: () => Promise<`0x${string}`>;
+}>;
+export { createRhinestoneAccount };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,uBAAuB,EAAE,WAAW,EAAE,MAAM,SAAS,CAAA;AAO9D,iBAAe,uBAAuB,CAAC,MAAM,EAAE,uBAAuB;;oCACvB,WAAW;+BAIhB;QAAE,EAAE,EAAE,MAAM,CAAA;KAAE;;GAcvD;AAED,OAAO,EAAE,uBAAuB,EAAE,CAAA"}

package/dist/index.js

@@ -0,0 +1,20 @@
+import { sendTransactions as sendTransactionsInternal, waitForExecution as waitForExecutionInternal, } from './services/transaction';
+import { getAddress as getAddressInternal } from './services/account';
+async function createRhinestoneAccount(config) {
+    const sendTransactions = async (transaction) => {
+        return await sendTransactionsInternal(config, transaction);
+    };
+    const waitForExecution = async ({ id }) => {
+        return await waitForExecutionInternal(config, id);
+    };
+    const getAddress = async () => {
+        return await getAddressInternal(config);
+    };
+    return {
+        config,
+        sendTransactions,
+        waitForExecution,
+        getAddress,
+    };
+}
+export { createRhinestoneAccount };

package/dist/package.json

@@ -0,0 +1 @@
+{"type": "module","sideEffects":false}

package/dist/services/account.d.ts

@@ -0,0 +1,13 @@
+import { Chain, Account } from 'viem';
+import { RhinestoneAccountConfig } from '../types';
+declare function getAddress(config: RhinestoneAccountConfig): Promise<`0x${string}`>;
+declare function isDeployed(chain: Chain, config: RhinestoneAccountConfig): Promise<boolean>;
+declare function deploy(deployer: Account, chain: Chain, config: RhinestoneAccountConfig): Promise<void>;
+declare function getDeployArgs(config: RhinestoneAccountConfig): Promise<{
+    factory: `0x${string}`;
+    factoryData: `0x${string}`;
+    salt: `0x${string}`;
+    hashedInitcode: `0x${string}`;
+}>;
+export { getAddress, isDeployed, getDeployArgs, deploy };
+//# sourceMappingURL=account.d.ts.map

package/dist/services/account.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"account.d.ts","sourceRoot":"","sources":["../../services/account.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,EAQL,OAAO,EAOR,MAAM,MAAM,CAAA;AAOb,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAelD,iBAAe,UAAU,CAAC,MAAM,EAAE,uBAAuB,0BAUxD;AAED,iBAAe,UAAU,CAAC,KAAK,EAAE,KAAK,EAAE,MAAM,EAAE,uBAAuB,oBAgBtE;AAED,iBAAe,MAAM,CACnB,QAAQ,EAAE,OAAO,EACjB,KAAK,EAAE,KAAK,EACZ,MAAM,EAAE,uBAAuB,iBAiBhC;AAED,iBAAe,aAAa,CAAC,MAAM,EAAE,uBAAuB;;;;;GA6F3D;AAED,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,EAAE,CAAA"}

package/dist/services/account.js

@@ -0,0 +1,127 @@
+import { createPublicClient, http, encodeAbiParameters, encodeFunctionData, parseAbi, zeroAddress, createWalletClient, size, keccak256, encodePacked, slice, } from 'viem';
+import { HOOK_ADDRESS, SAME_CHAIN_MODULE_ADDRESS, TARGET_MODULE_ADDRESS, } from './orchestrator';
+import { getValidator, toOwners, SAFE_7579_LAUNCHPAD_ADDRESS, SAFE_7579_ADAPTER_ADDRESS, OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS, RHINESTONE_ATTESTER_ADDRESS, } from './modules';
+const SAFE_SINGLETON_ADDRESS = '0x29fcb43b46531bca003ddc8fcb67ffe91900c762';
+const SAFE_PROXY_FACTORY_ADDRESS = '0x4e1dcf7ad4e460cfd30791ccc4f9c8a4f820ec67';
+async function getAddress(config) {
+    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) {
+        throw new Error('EIP-7702 accounts are not yet supported');
+    }
+    return size(code) > 0;
+}
+async function deploy(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 getDeployArgs(config) {
+    switch (config.account.type) {
+        case 'safe': {
+            const owners = toOwners(config);
+            const initializer = encodeFunctionData({
+                abi: parseAbi([
+                    'function setup(address[] calldata _owners,uint256 _threshold,address to,bytes calldata data,address fallbackHandler,address paymentToken,uint256 payment, address paymentReceiver) external',
+                ]),
+                functionName: 'setup',
+                args: [
+                    owners,
+                    BigInt(1),
+                    SAFE_7579_LAUNCHPAD_ADDRESS,
+                    encodeFunctionData({
+                        abi: parseAbi([
+                            'struct ModuleInit {address module;bytes initData;}',
+                            'function addSafe7579(address safe7579,ModuleInit[] calldata validators,ModuleInit[] calldata executors,ModuleInit[] calldata fallbacks, ModuleInit[] calldata hooks,address[] calldata attesters,uint8 threshold) external',
+                        ]),
+                        functionName: 'addSafe7579',
+                        args: [
+                            SAFE_7579_ADAPTER_ADDRESS,
+                            [
+                                {
+                                    module: getValidator(config).address,
+                                    initData: getValidator(config).initData,
+                                },
+                            ],
+                            [
+                                {
+                                    module: SAME_CHAIN_MODULE_ADDRESS,
+                                    initData: '0x',
+                                },
+                                {
+                                    module: TARGET_MODULE_ADDRESS,
+                                    initData: '0x',
+                                },
+                                {
+                                    module: HOOK_ADDRESS,
+                                    initData: '0x',
+                                },
+                            ],
+                            [
+                                {
+                                    module: TARGET_MODULE_ADDRESS,
+                                    initData: encodeAbiParameters([
+                                        { name: 'selector', type: 'bytes4' },
+                                        { name: 'flags', type: 'bytes1' },
+                                        { name: 'data', type: 'bytes' },
+                                    ], ['0x3a5be8cb', '0x00', '0x']),
+                                },
+                            ],
+                            [],
+                            [RHINESTONE_ATTESTER_ADDRESS, OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS],
+                            1,
+                        ],
+                    }),
+                    SAFE_7579_ADAPTER_ADDRESS,
+                    zeroAddress,
+                    BigInt(0),
+                    zeroAddress,
+                ],
+            });
+            const saltNonce = 0n;
+            const factoryData = encodeFunctionData({
+                abi: parseAbi([
+                    'function createProxyWithNonce(address singleton,bytes calldata initializer,uint256 saltNonce) external payable returns (address)',
+                ]),
+                functionName: 'createProxyWithNonce',
+                args: [SAFE_SINGLETON_ADDRESS, initializer, saltNonce],
+            });
+            const salt = keccak256(encodePacked(['bytes32', 'uint256'], [keccak256(initializer), saltNonce]));
+            const hashedInitcode = '0xe298282cefe913ab5d282047161268a8222e4bd4ed106300c547894bbefd31ee';
+            return {
+                factory: SAFE_PROXY_FACTORY_ADDRESS,
+                factoryData,
+                salt,
+                hashedInitcode,
+            };
+        }
+    }
+}
+export { getAddress, isDeployed, getDeployArgs, deploy };

package/dist/services/modules.d.ts

@@ -0,0 +1,34 @@
+import { Address, Chain, Hex } from 'viem';
+import { RhinestoneAccountConfig } from '../types';
+type ModuleType = 'validator' | 'executor' | 'fallback' | 'hook';
+interface Module {
+    address: Address;
+    initData: Hex;
+    deInitData: Hex;
+    additionalContext: Hex;
+    type: ModuleType;
+}
+interface WebAuthnData {
+    authenticatorData: Hex;
+    clientDataJSON: string;
+    typeIndex: number | bigint;
+}
+interface WebauthnValidatorSignature {
+    webauthn: WebAuthnData;
+    signature: WebauthnSignature | Hex | Uint8Array;
+    usePrecompiled?: boolean;
+}
+interface WebauthnSignature {
+    r: bigint;
+    s: bigint;
+}
+declare const SAFE_7579_LAUNCHPAD_ADDRESS: Address;
+declare const SAFE_7579_ADAPTER_ADDRESS: Address;
+declare const OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS: Address;
+declare const RHINESTONE_ATTESTER_ADDRESS: Address;
+declare function toOwners(config: RhinestoneAccountConfig): `0x${string}`[];
+declare function getValidator(config: RhinestoneAccountConfig): Module;
+export declare function getWebauthnValidatorSignature({ webauthn, signature, usePrecompiled, }: WebauthnValidatorSignature): `0x${string}`;
+export declare function isRip7212SupportedNetwork(chain: Chain): boolean;
+export { getValidator, toOwners, SAFE_7579_LAUNCHPAD_ADDRESS, SAFE_7579_ADAPTER_ADDRESS, OMNI_ACCOUNT_MOCK_ATTESTER_ADDRESS, RHINESTONE_ATTESTER_ADDRESS, };
+//# sourceMappingURL=modules.d.ts.map

package/dist/services/modules.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"modules.d.ts","sourceRoot":"","sources":["../../services/modules.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,OAAO,EAEP,KAAK,EAEL,GAAG,EAIJ,MAAM,MAAM,CAAA;AAYb,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAA;AAElD,KAAK,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,UAAU,GAAG,MAAM,CAAA;AAEhE,UAAU,MAAM;IACd,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,GAAG,CAAA;IACb,UAAU,EAAE,GAAG,CAAA;IACf,iBAAiB,EAAE,GAAG,CAAA;IACtB,IAAI,EAAE,UAAU,CAAA;CACjB;AAcD,UAAU,YAAY;IACpB,iBAAiB,EAAE,GAAG,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;IACtB,SAAS,EAAE,MAAM,GAAG,MAAM,CAAA;CAC3B;AAED,UAAU,0BAA0B;IAClC,QAAQ,EAAE,YAAY,CAAA;IACtB,SAAS,EAAE,iBAAiB,GAAG,GAAG,GAAG,UAAU,CAAA;IAC/C,cAAc,CAAC,EAAE,OAAO,CAAA;CACzB;AAED,UAAU,iBAAiB;IACzB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,QAAA,MAAM,2BAA2B,EAAE,OACW,CAAA;AAC9C,QAAA,MAAM,yBAAyB,EAAE,OACa,CAAA;AAE9C,QAAA,MAAM,kCAAkC,EAAE,OACI,CAAA;AAE9C,QAAA,MAAM,2BAA2B,EAAE,OACW,CAAA;AAS9C,iBAAS,QAAQ,CAAC,MAAM,EAAE,uBAAuB,mBAQhD;AAED,iBAAS,YAAY,CAAC,MAAM,EAAE,uBAAuB,UAcpD;AAkFD,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,SAAS,EACT,cAAsB,GACvB,EAAE,0BAA0B,iBA6C5B;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,KAAK,WAarD;AA0BD,OAAO,EACL,YAAY,EACZ,QAAQ,EACR,2BAA2B,EAC3B,yBAAyB,EACzB,kCAAkC,EAClC,2BAA2B,GAC5B,CAAA"}