@rhinestone/sdk 1.2.5 → 1.2.6

package/README.md

@@ -1,245 +1,76 @@
 # Rhinestone SDK
 
-End-to-end chain abstraction and modularity toolkit
+> End-to-end chain abstraction and modularity toolkit
 
-## Usage
+Rhinestone is a vertically integrated smart wallet and crosschain liquidity platform. The SDK provides a unified interface for deploying and managing self-custodial smart accounts, powered by an intent-based transaction infrastructure that enables seamless crosschain execution without bridging or gas tokens.
 
-### Installation
+The platform combines modular [smart account tooling](https://docs.rhinestone.dev/smart-wallet/core/create-account) with an intent engine ([Warp](https://docs.rhinestone.dev/home/introduction/rhinestone-intents)) that aggregates settlement layers through a unified relayer market. This handles routing, token liquidity, and crosschain orchestration across all [supported chains](https://docs.rhinestone.dev/home/resources/supported-chains).
 
-```bash
-npm install viem @rhinestone/sdk
-```
+[Documentation](https://docs.rhinestone.dev)
 
-```bash
-pnpm install viem @rhinestone/sdk
-```
+## Features
 
-```bash
-yarn add viem @rhinestone/sdk
-```
 
-```bash
-bun install viem @rhinestone/sdk
-```
+- **Crosschain Transactions** - Execute transactions on any target chain using assets from any source chain. The orchestrator handles routing and settlement. [Learn more](https://docs.rhinestone.dev/smart-wallet/chain-abstraction/multi-chain-intent)
 
-## Quickstart
+- **Swaps** - Token exchanges via solver-based swaps or injected DEX aggregator swaps, integrated into crosschain transaction execution. [Learn more](https://docs.rhinestone.dev/smart-wallet/chain-abstraction/swaps)
 
-You'll need a Rhinestone API key, as well as an existing account with some testnet ETH on the source chain.
+- **Passkeys** - WebAuthn-based authentication for smart accounts, replacing seed phrases with device biometrics. [Learn more](https://docs.rhinestone.dev/smart-wallet/core/passkeys)
 
-### SDK Initialization
+- **Smart Sessions** - Onchain permissions system for scoped transaction automation, enabling one-click UX and server-side execution with granular policies. [Learn more](https://docs.rhinestone.dev/smart-wallet/smart-sessions/overview)
 
-To initialize the SDK with your configuration:
+- **Gas Sponsorship** - Subsidize gas, bridge, and swap fees for users by depositing USDC on Base. Applies across all supported chains. [Learn more](https://docs.rhinestone.dev/smart-wallet/gas-sponsorship/overview)
 
-```ts
-import { RhinestoneSDK } from '@rhinestone/sdk'
+## Installation
 
-const sdk = new RhinestoneSDK({
-  apiKey: 'your-rhinestone-api-key',
-  // Optional: Provider configuration
-  provider: {
-    type: 'alchemy',
-    apiKey: 'your-alchemy-api-key',
-  },
-  // Optional: Bundler configuration
-  bundler: {
-    // the bundler settings
-  },
-  // Optional: Paymaster configuration
-  paymaster: {
-    // the paymaster settings
-  },
-})
+```bash
+npm install viem @rhinestone/sdk
+```
+
+```bash
+bun install viem @rhinestone/sdk
 ```
 
-### Creating a Wallet
+## Quickstart
 
-Let's create a smart account with a single owner:
+Create a smart account:
 
 ```ts
 import { RhinestoneSDK } 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.info(`Owner private key: ${privateKey}`)
-const account = privateKeyToAccount(privateKey)
-
-// Initialize the SDK
-const sdk = new RhinestoneSDK({
-  apiKey: rhinestoneApiKey,
-})
 
-// Create the Rhinestone account
-const rhinestoneAccount = await sdk.createAccount({
+const rhinestone = new RhinestoneSDK()
+const account = await rhinestone.createAccount({
   owners: {
     type: 'ecdsa',
-    accounts: [account],
+    accounts: [signer],
   },
 })
-const address = await rhinestoneAccount.getAddress()
-console.info(`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:
+Send a crosschain transaction:
 
 ```ts
-const usdcTarget = '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d';
-const usdcAmount = 1n;
-
-const transaction = await rhinestoneAccount.sendTransaction({
-  sourceChain,
-  targetChain,
+const transaction = await account.sendTransaction({
+  sourceChains: [baseSepolia],
+  targetChain: arbitrumSepolia,
   calls: [
     {
-      to: usdcTarget,
+      to: 'USDC',
       value: 0n,
       data: encodeFunctionData({
         abi: erc20Abi,
         functionName: 'transfer',
-        args: ['0xd8da6bf26964af9d7eed9e03e53415d37aa96045', usdcAmount],
+        args: [recipient, amount],
       }),
     },
   ],
-  tokenRequests: [
-    {
-      address: usdcTarget,
-      amount: usdcAmount,
-    },
-  ],
-});
-console.info('Transaction', transaction);
-
-const transactionResult = await rhinestoneAccount.waitForExecution(transaction);
-console.info('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
-// Initialize the SDK with bundler configuration
-const sdk = new RhinestoneSDK({
-  apiKey: rhinestoneApiKey,
-  bundler: {
-    // bundler configuration
-  },
+  tokenRequests: [{ address: 'USDC', amount }],
 })
 
-const rhinestoneAccount = await sdk.createAccount({
-  owners: {
-    type: 'ecdsa',
-    accounts: [account],
-  },
-  sessions: [session],
-})
+const result = await account.waitForExecution(transaction)
 ```
 
-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,
-  },
-})
-```
+For a complete walkthrough, see the [Quickstart guide](https://docs.rhinestone.dev/smart-wallet/quickstart).
 
 ## Migrating from Orchestrator SDK
 

package/dist/src/orchestrator/registry.js

@@ -81,16 +81,14 @@ function isTokenAddressSupported(address, chainId) {
     if (!chainEntry) {
         return false;
     }
-    return chainEntry.tokens
-        .filter((token) => token.supportsMultichain)
-        .some((token) => token.address.toLowerCase() === address.toLowerCase());
+    return chainEntry.tokens.some((token) => token.address.toLowerCase() === address.toLowerCase());
 }
 function getSupportedTokens(chainId) {
     const chainEntry = getChainEntry(chainId);
     if (!chainEntry) {
         throw new error_1.UnsupportedChainError(chainId);
     }
-    return chainEntry.tokens.filter((token) => token.supportsMultichain);
+    return chainEntry.tokens;
 }
 function getDefaultAccountAccessList(onTestnets) {
     const supportedChainIds = getSupportedChainIds();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rhinestone/sdk",
-  "version": "1.2.5",
+  "version": "1.2.6",
   "description": "End-to-end chain abstraction and modularity toolkit",
   "author": {
     "name": "Rhinestone",
@@ -151,7 +151,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@rhinestone/shared-configs": "1.4.56",
+    "@rhinestone/shared-configs": "1.4.74",
     "ox": "^0.9.11",
     "solady": "^0.1.26"
   },