# Deep Dive
Source: https://build.onswig.com/deepdive

"I swig therefor I am" - Rene Descartes using Swig

# Deep Dive

Let's dive into how Swig works under the hood! I'm excited to share some of the cool technical innovations we've built to make Swig blazing fast while maintaining rock-solid security.

## The Need for Speed 🏃‍♂️

When we started building Swig, we knew that smart wallets needed to be FAST. Like, really fast. Nobody wants to wait around for their transactions, especially in DeFi where every millisecond counts. This led us down a fascinating path of optimization at every level of the stack.

## Zero-Copy Architecture

One of our proudest achievements is Swig's zero-copy architecture. Instead of constantly allocating and copying data around (which is slow and expensive), we've built Swig to work directly with data in place whenever possible. We use Rust's powerful zero-copy parsing capabilities through libraries like Pinnochio to handle instruction data and account parsing with minimal overhead.

This means when you send a transaction through Swig, we're not wasting time shuffling data around - we're getting straight to the important stuff like signature verification and permission checks.

## Smart Account Classification

A key innovation in Swig is our account classification system. When a transaction comes in, we need to know exactly what we're dealing with - is this a Swig account? A token account? Something else entirely?

We've built a lightning-fast classification engine that can identify account types and validate their structure in a single pass. This isn't just about speed - it's also a critical security feature that ensures we're always working with exactly the account types we expect.

The classification system uses a combination of:

* Account ownership checks
* Data structure validation
* PDA derivation verification

All of this happens automatically at the program entry point, so by the time we get to instruction processing, we know exactly what we're working with.

## Extensible Authority System

While speed is crucial, flexibility is just as important. That's why we built Swig with an extensible authority system that can grow with the ecosystem. Right now, we support Ed25519 and Secp256k1 signatures, but that's just the beginning.

We've designed the system so we can continuously add new authority types without breaking existing functionality. Some exciting things we're working on include:

* Program-based authorities (letting other Solana programs act as authorities)
* Groth16 zero-knowledge proof authorities (for privacy-preserving operations)
* Simplified EVM-compatible authority systems (making it easier to bridge from Ethereum)

## Permission System That Makes Sense

Security doesn't have to be complicated. We've built a permission system that's both powerful and intuitive. Whether you need to:

* Manage specific tokens
* Set spending limits
* Control program access
* Set time-based restrictions

It all just works, and more importantly, it's easy to understand and audit.

## Looking Forward 🔭

We're not stopping here! Some exciting things in the pipeline:

### Paymaster Network

We're working on a decentralized paymaster network that will make gas-less transactions accessible to everyone. This is a game-changer for user experience, especially for newcomers to Solana.

### More Authority Types

The crypto ecosystem is constantly evolving, and so is Swig. We're actively working on supporting more signature schemes and authority types to make Swig the most versatile smart wallet platform out there.

### Enhanced Performance

While we're already blazing fast, we're constantly finding new ways to optimize. Our team is obsessed with performance, and we're always looking for ways to squeeze out every last bit of efficiency.

## Wrapping Up

Swig is more than just a smart wallet - it's a platform built for the future of decentralized finance. By combining cutting-edge performance optimizations with a flexible, extensible architecture, we're creating something that can grow and evolve with the ecosystem.

Stay tuned for more updates, and feel free to dive into our docs to learn more about specific features and implementations. We're just getting started! 🚀


# Credit Card Processing with SWIG
Source: https://build.onswig.com/examples/credit_card

"Give a man a credit card, and he'll buy coffee for a day. Teach him to Swig, and he'll sign for it himself."— DeFi Proverb

SWIG provides robust support for both credit and debit card payment flows through its authority system and authorization locks feature. Watch our quick demo to see it in action:

<iframe src="https://www.loom.com/embed/faea0d83990e463ba6e62e12902332b0?sid=d7708a10-0851-4b62-a50e-3155e1ee25c3" frameborder="0" webkitallowfullscreen mozallowfullscreen allowfullscreen />

## How It Works

SWIG can handle both debit and credit card flows in a way that's both elegant and compliant. Our authority system forms the foundation, giving you complete control over who can spend what and when, while our authorization locks enable sophisticated payment flows that traditional finance demands.

### Debit Card Processing

When it comes to debit cards, things are pretty straightforward. Using our standard spending limits, you can pull funds directly into your treasury account. Think of it as an instant transfer – the money moves right away, and you can start using it immediately. Our authority system ensures that only authorized parties can initiate these transfers, and you can set custom limits that make sense for your business.

### Credit Card Magic

Credit cards are where things get interesting. Instead of immediately pulling funds, our authorization locks system lets you place a hold on the funds first. This is perfect for situations where you need to verify a card's validity and ensure funds are available, but aren't ready to complete the transaction yet. The authorization lock is incredibly fast and cost-effective, and it keeps the funds reserved until the credit card provider is ready to process the payment according to their jurisdiction's rules and requirements.

This approach is particularly valuable in industries with complex payment flows. For example, if you're running a car rental service, you can authorize a security deposit without actually charging it, then only capture the final amount once the rental period is complete. Hotels, travel companies, and any business dealing with delayed or variable charges will find this especially useful.

## Why Choose SWIG

Our payment infrastructure isn't just about moving money – it's about giving you the tools to build sophisticated financial products. With our authority system handling permissions and our authorization locks managing holds, you can focus on building your product while we handle the complex payment orchestration behind the scenes.

Ready to revolutionize your payment flows? Get in touch with our team, and we'll help you get started with SWIG's credit card processing capabilities.

contact: [info@onswig.com](mailto:info@onswig.com)


# Using Ethereum Keys with Swig
Source: https://build.onswig.com/examples/ethereum_keys

"Just use swig" - Vitalik Buterin (probably one day)

Swig supports using Ethereum-style secp256k1 keys for authorization, enabling you to use your Ethereum wallet to control assets on Solana. This guide explains how to integrate Ethereum wallets with Swig and showcases different implementation approaches.

## Current Implementation

Currently, Swig uses the compressed public key format for authentication (not the Ethereum address). A future update will introduce an `EvmAddress` authority type that uses the hashed form of the public key (the standard Ethereum address).

## Integration Examples

### Viem Integration (Recommended)

The recommended approach for Ethereum wallet integration uses the Viem library. Here's a complete example showing different signing methods:

```typescript
import { Wallet } from '@ethereumjs/wallet';
import { privateKeyToAccount } from 'viem/accounts';
import { hexToBytes, keccak256 } from 'viem';
import {
  createSecp256k1AuthorityInfo,
  signInstruction,
  Swig,
} from '@swig-wallet/classic';

// Create an Ethereum wallet account
const userWallet = Wallet.generate();
const privateKeyAccount = privateKeyToAccount(userWallet.getPrivateKeyString());

// Create Swig with secp256k1 authority
const createSwigInstruction = Swig.create({
  authorityInfo: createSecp256k1AuthorityInfo(privateKeyAccount.publicKey),
  id,
  payer: transactionPayer.publicKey,
  actions: rootActions,
});

// Different signing methods available:

// 1. Standard eth_sign
const viemSign = async (message: Uint8Array) => {
  const sig = await privateKeyAccount.sign({ hash: keccak256(message) });
  return { signature: hexToBytes(sig) };
};

// 2. eth_sign with personal_sign prefix
const viemSignWithPrefix = async (message: Uint8Array) => {
  const prefix = getEvmPersonalSignPrefix(message.length);
  const prefixedMessage = new Uint8Array(prefix.length + message.length);

  prefixedMessage.set(prefix);
  prefixedMessage.set(message, prefix.length);

  const sig = await privateKeyAccount.sign({ 
    hash: keccak256(prefixedMessage) 
  });

  return { signature: hexToBytes(sig), prefix };
};

// 3. personal_sign
const viemSignMessage = async (message: Uint8Array) => {
  const sig = await privateKeyAccount.signMessage({ 
    message: { raw: message } 
  });
  
  return {
    signature: hexToBytes(sig),
    prefix: getEvmPersonalSignPrefix(message.length),
  };
};

// Sign a transaction using any of the signing methods
const signedTransfer = await signInstruction(
  rootRole,
  transactionPayer.publicKey,
  [transfer],
  {
    currentSlot: svm.getClock().slot,
    signingFn: viemSign, // or viemSignWithPrefix, or viemSignMessage
  },
);
```

### Session-Based Authorization

For enhanced security and better UX, you can use session-based authorization with secp256k1 keys:

```typescript
import {
  createSecp256k1SessionAuthorityInfo,
  createSessionInstruction,
} from '@swig-wallet/classic';

// Create a session-based Swig
const createSwigInstruction = Swig.create({
  authorityInfo: createSecp256k1SessionAuthorityInfo(
    userWallet.getPublicKey(),
    100n, // session duration in slots
  ),
  id,
  payer: userRootKeypair.publicKey,
  actions: rootActions,
});

// Create a new session
const newSessionInstruction = await createSessionInstruction(
  rootRole,
  userRootKeypair.publicKey,
  dappSessionKeypair.publicKey,
  50n, // session duration
  { currentSlot, signingFn }
);
```

## Best Practices

1. **Wallet Integration**
   * Use the Viem example as your primary reference for Ethereum wallet integration
   * Choose the appropriate signing method based on your wallet implementation
   * Always verify the signing method (eth\_sign vs personal\_sign) matches your wallet's capabilities

2. **Security Considerations**
   * Use session-based authorities for dApp integrations to limit exposure
   * Keep session durations appropriate for your use case
   * Remember that while using Ethereum keys, you still need a Solana account for transaction fees

3. **Implementation Tips**
   * Use the provided helper functions like `createSecp256k1AuthorityInfo`
   * Implement proper error handling for signing operations
   * Consider implementing all three signing methods for maximum wallet compatibility

## Future Developments

The upcoming `EvmAddress` authority type will allow using the standard Ethereum address format (the hashed form of the public key) instead of the current compressed public key format. This will make integration even more straightforward and familiar to Ethereum developers.

## Additional Resources

For complete working examples, check out these files in the [swig-ts](https://github.com/anagrambuild/swig-ts) repository:

* [`examples/transfer/transfer-svm-viem.ts`](https://github.com/anagrambuild/swig-ts/blob/main/examples/transfer/transfer-svm-viem.ts) - Viem integration example
* [`examples/transfer/transfer-svm-secp-session.ts`](https://github.com/anagrambuild/swig-ts/blob/main/examples/transfer/transfer-svm-secp-session.ts) - Session-based authorization
* [`examples/transfer/transfer-svm-secp.ts`](https://github.com/anagrambuild/swig-ts/blob/main/examples/transfer/transfer-svm-secp.ts) - Basic secp256k1 usage
* [`examples/transfer/transfer-local-secp.ts`](https://github.com/anagrambuild/swig-ts/blob/main/examples/transfer/transfer-local-secp.ts) - Local testing example

You can also explore the full examples directory in the [swig-ts repository](https://github.com/anagrambuild/swig-ts/tree/main/examples) for more implementation patterns and use cases.


# Swig How-to's
Source: https://build.onswig.com/examples/index

"All I was asking for was a simple example" - Elon Musk on Swig(probably)

# SWIG Examples

SWIG provides a variety of examples to help developers understand and implement SWIG in different scenarios. Whether you're building a new dApp from scratch or integrating SWIG into an existing application, we have examples to guide you through the process.

## Example Categories

Our examples cover various use cases including:

* In-app wallet integration
* Legacy dApp integration
* SWIG-native dApp development
* CLI applications
* Subscription-based applications (like SwigFlix)
* Wallet Standard integration

## Finding More Examples

We maintain an ever-growing collection of examples in our [awesome-swig repository](https://github.com/anagrambuild/awesome-swig). This community-driven resource includes:

* Complete application examples
* SDK usage demonstrations (both Rust and TypeScript)
* Integration patterns
* CLI tools and utilities

The awesome-swig repository is regularly updated with new examples and best practices from the SWIG community. We encourage developers to explore these examples and contribute their own implementations to help others learn and build with SWIG.

Remember that these examples are meant to serve as starting points and can be adapted to fit your specific needs.


# Working with Sessions in Swig
Source: https://build.onswig.com/examples/sessions

\"You can fit so many sessions in this bad boy\" - Toly slapping the hood of a gently used 2012 Swig (probably)

This guide explains how to work with sessions in Swig, which allow you to create temporary authorities with limited permissions. Sessions are perfect for dApp integrations where you need to delegate authority for a specific duration.
You can find all example code in the [swig-ts/examples/transfer](https://github.com/swig-wallet/swig/tree/main/swig-ts/examples/transfer) directory.

<Tip>Examples with svm in the file name use LiteSVM for testing. Those without svm in the file name use a local validator. Which you can run with the `bun start-validator` command.</Tip>

## Creating a Basic Session

The simplest way to create a session is with Ed25519 keys. Here are the key parts:

```typescript
// Setup - Create root authority and session keypair
const userRootKeypair = Keypair.generate();
const dappSessionKeypair = Keypair.generate();

// Create Swig with session support
const rootActions = Actions.set().all().get();
await createSwig(
  connection,
  id,
  createEd25519SessionAuthorityInfo(userRootKeypair.publicKey, 100n),
  rootActions,
  userRootKeypair.publicKey,
  [userRootKeypair],
);

// Create a session that lasts 50 slots
const createSessionIx = await createSessionInstruction(
  rootRole,
  userRootKeypair.publicKey,
  dappSessionKeypair.publicKey,
  50n,
);

await sendTransaction(connection, createSessionIx, userRootKeypair);
```

## Using Session Authority

Once a session is created, you can use it to sign transactions within its duration:

```typescript
// Find the role by session key
const rootRole = swig.findRoleBySessionKey(dappSessionKeypair.publicKey);

if (!rootRole || !rootRole.isSessionBased())
  throw new Error('Role not found for authority');

// Create and sign a transfer using session authority
const transfer = SystemProgram.transfer({
  fromPubkey: swigAddress,
  toPubkey: dappTreasury,
  lamports: 0.1 * LAMPORTS_PER_SOL,
});

const signTransfer = await signInstruction(
  rootRole,
  dappSessionKeypair.publicKey,
  [transfer],
);

await sendTransaction(connection, signTransfer, dappSessionKeypair);
```

## Secp256k1 Sessions (EVM Compatible)

For EVM compatibility, you can create sessions with Secp256k1 keys:

```typescript
// Setup with Ethereum wallet
const userWallet = Wallet.generate();

// Create Swig with Secp256k1 session support
const createSwigInstruction = Swig.create({
  authorityInfo: createSecp256k1SessionAuthorityInfo(
    userWallet.getPublicKey(),
    100n,
  ),
  id,
  payer: userRootKeypair.publicKey,
  actions: rootActions,
});

// Create a session
const newSessionInstruction = await createSessionInstruction(
  rootRole,
  userRootKeypair.publicKey,
  dappSessionKeypair.publicKey,
  50n,
  {
    currentSlot,
    signingFn: getSigningFnForSecp256k1PrivateKey(
      userWallet.getPrivateKeyString(),
    ),
  },
);
```

## Revoking Sessions

You can revoke a session by creating a new session with an all-zero session key:

```typescript
// Create a zero key to revoke the session
const zeroKey = new Uint8Array(32).fill(0);

// Create revocation instruction
const revokeSessionIx = await createSessionInstruction(
  rootRole,
  userRootKeypair.publicKey,
  zeroKey,
  1n, // Duration doesn't matter for revocation
);

await sendTransaction(connection, revokeSessionIx, userRootKeypair);
```

## Key Aspects of Sessions

Sessions in Swig have several important characteristics:

* **Temporary Authority**: Sessions expire after their specified duration
* **Unique Keys**: Each session must use a unique key (can't reuse previous session keys)
* **Root Override**: The root authority can always override or revoke session permissions
* **Inheritance**: Sessions inherit permissions from their root role
* **Multiple Sessions**: You can have multiple active sessions for the same root authority

## Testing Environment Options

These examples can be run in different environments:

* **Local Validator**: Use `transfer-local-session.ts`
  * Requires running a local Solana validator
  * Real blockchain environment
  * Good for final testing

* **LiteSVM**: Use `transfer-svm-session.ts` or `transfer-svm-secp-session.ts`
  * No validator required
  * Instant transaction confirmation
  * Perfect for rapid development
  * Simulates the Solana runtime

* **Devnet**: All examples work with devnet
  * Change connection URL to `https://api.devnet.solana.com`
  * Real network environment
  * Free to use with airdropped SOL

LiteSVM is recommended for initial development as it provides the fastest feedback loop. Move to local validator or devnet for more thorough testing.


# Sub Accounts in Swig
Source: https://build.onswig.com/examples/sub_accounts

\"Its sub accounts all the way down\" - Ancient Swig Proverb

# Sub Accounts (Preview)

<Note>
  Sub account support in the TypeScript SDK is currently under development. However, full support is available in the Rust SDK. This guide provides an overview of the feature and its core concepts.
</Note>

## What are Sub Accounts?

Sub accounts in Swig allow an authority to create and manage a single sub account address and perform any actions on behalf of that sub account. This is a super high level of permission so use with care. It works for usecases like portfolio management, where you want to allow an unlimited complexity of actions on behalf of a single address, but you dont want to give the authority control over all the assets of the swig. The root authority can always pull funds SOL and tokens from the sub account back to the main Swig wallet.
A great example of this is Breeze, anagrams onchain yield optimizer. Allows breeze to optimize the yield of a users portfolio without giving them control over their whole swig.

## How Sub Accounts Work

To work with sub accounts, there are two key requirements:

1. **Sub Account Permission**: The authority must have the sub account permission to create the sub account. This permission is set when creating or modifying a role.

2. **Sub Account Sign**: Once created, sub accounts can perform on-chain actions using the `sub_account_sign` instruction.

You can find working examples in our [test suite](https://github.com/anagrambuild/swig-wallet/blob/main/program/tests/sub_account_test.rs#L33).

## Coming Soon to TypeScript

We're actively working on bringing full sub account support to our TypeScript SDK. The implementation will include:

* Easy-to-use APIs for sub account creation and management
* TypeScript-native permission management
* Event handling for sub account activities
* Comprehensive documentation and examples


# Subscriptions with Swig
Source: https://build.onswig.com/examples/subscription

"Please like and most importantly, subscribe" - Swig Content Influencers Everywhere

# Building Subscription Services with SWIG

SWIG's token limit feature provides a powerful way to implement subscription-based services on Solana. This guide demonstrates how to create a subscription service that charges users monthly using SWIG's token limit capabilities.

You can find the complete example code in the [swig-ts/examples/subscriptions.ts](https://github.com/anagrambuild/swig-ts/tree/main/examples/transfer/subscription-svm.ts) file.

<Tip>
  Examples with svm in the file name use LiteSVM for testing. Those without svm in the file name use a local validator. Which you can run with the bun start-validator command.
</Tip>

## Overview

In this example, we'll create a subscription service that:

* Charges users \$10 USDC monthly
* Uses SWIG's token limit feature to enforce the subscription amount and period
* Demonstrates how the limit resets after the specified period

## Key Concepts

### Token Limits

SWIG's token limit feature allows you to:

* Set a maximum amount of tokens that can be transferred within a specified block period
* Automatically reset the limit after the period expires
* Track limits per token mint (supporting multiple tokens)

### Block Period

In this example, we use a block period of 216,000 blocks, which approximates one month given Solana's average block time of 400ms:

```typescript
// 400ms per block
// 1 month ≈ 30 days * 24 hours * 60 minutes * 60 seconds * (1/0.4) blocks/second
// ≈ 216,000 blocks
```

## Implementation

The example demonstrates:

1. Creating a SWIG wallet with root authority
2. Setting up a subscription service authority with token limits
3. Processing subscription paymentsI
4. Handling period resets

Here's a key snippet showing how to set up the subscription authority:

```typescript
let subscriptionActions = Actions.set()
  .tokenLimit({
    mint: usdcMint,
    amount: BigInt(10_000_000), // $10 with 6 decimals
    blocks: 216000, // ~1 month at 400ms per block
  })
  .get();

let addSubscriptionAuthorityIx = await addAuthorityInstruction(
  rootRole,
  rootKeypair.publicKey,
  createEd25519AuthorityInfo(subscriptionServiceKeypair.publicKey),
  subscriptionActions,
);
```

## Use Cases

This pattern enables various subscription-based services:

1. **SaaS Applications**
   * Monthly software subscriptions
   * Tiered service plans
   * Usage-based billing

2. **Content Platforms**
   * Premium content access
   * Streaming services
   * Digital publication subscriptions

3. **Gaming Services**
   * Monthly game passes
   * Premium features access
   * In-game subscription benefits

4. **DeFi Services**
   * Trading fee subscriptions
   * Premium analytics access
   * Automated trading services

## Complete Example

For a complete working example that includes both client and server implementations, check out the [SWIG SDK Example Repository](https://github.com/anagrambuild/swig-rs-sdk-example). This repository demonstrates:

* Frontend subscription management
* Backend subscription processing
* Error handling and edge cases
* User management integration

## Best Practices

1. **Error Handling**
   * Always verify transaction success
   * Handle failed payments gracefully
   * Implement retry mechanisms

2. **User Experience**
   * Notify users before renewal
   * Provide clear subscription status
   * Implement grace periods

3. **Security**
   * Secure key management
   * Rate limiting
   * Transaction monitoring


# Jupiter Swapping with Swig
Source: https://build.onswig.com/examples/swap

"To swap or not to swap, that is the question" - Swigspere

# Swapping Tokens with Jupiter using Swig

This guide demonstrates how to perform token swaps on Solana using Jupiter Protocol with a Swig wallet. We'll create a simple example that swaps SOL for USDC using Jupiter's optimized routing.

## Prerequisites

Before you begin, make sure you have the following installed:

* [Bun](https://bun.sh) (latest version)
* A Solana wallet with some SOL for transaction fees
* A keypair file for the root user

## Setup

First, clone the swig-ts repository and navigate to the swap example:

```bash
git clone https://github.com/anagrambuild/swig-ts.git
cd swig-ts/examples/swap
bun install
```

The example already includes all necessary dependencies:

* `@jup-ag/api` for Jupiter API integration
* `@swig-wallet/classic` for Swig wallet functionality
* `@solana/web3.js` for Solana interactions
* `chalk` for colorful console output

## Understanding the Code

The example demonstrates several key concepts:

1. Setting up Swig with proper compute budget handling
2. Managing token accounts (ATAs)
3. Using Jupiter's API for quotes and swap instructions
4. Properly separating and signing instructions

Let's break down the main components:

### 1. Setting Up Token Accounts

<Note>
  This isnt technically necessary, but we leave it here for your benefit. Jupiter will create the token accounts for you if they don't exisst in the setup instructions that are returned from the Jupiter API.
</Note>

Before swapping, we need to ensure the Swig account has the necessary token accounts:

```typescript
// Check if Swig has USDC ATA
const swigUsdcAta = await getAssociatedTokenAddress(usdcMint, swigAddress, true);
let createAtaIx: TransactionInstruction | null = null;

try {
  await getAccount(connection, swigUsdcAta);
  console.log("✓ USDC token account exists");
} catch (error) {
  console.log("⚠️  Creating USDC token account for Swig...");
  createAtaIx = createAssociatedTokenAccountInstruction(
    rootUser.publicKey,
    swigUsdcAta,
    swigAddress,
    usdcMint
  );
  // Create ATA in a separate transaction
  const createAtaTx = new Transaction().add(createAtaIx);
  await sendAndConfirmTransaction(connection, createAtaTx, [rootUser]);
}
```

### 2. Getting Jupiter Quote

```typescript
const jupiterQuoteApi = createJupiterApiClient();

const quoteResponse = await jupiterQuoteApi.quoteGet({
  inputMint: "So11111111111111111111111111111111111111112", // SOL
  outputMint: usdcMint.toBase58(), // USDC
  amount: transferAmount,
  slippageBps: 50, // 0.5%
  maxAccounts: 64, // Important: Account for Swig's overhead
});
```

### 3. Handling Compute Budget and Instructions

The most critical part is properly separating and handling instructions:

```typescript
// Outer instructions (not signed by Swig)
const outerInstructions: TransactionInstruction[] = [
  ComputeBudgetProgram.setComputeUnitLimit({
    units: 150_000,
  }),
  ComputeBudgetProgram.setComputeUnitPrice({
    microLamports: 50,
  }),
];

// Instructions that need Swig signatures
const swigInstructions: TransactionInstruction[] = [
  ...(swapInstructions.setupInstructions || []).map(toTransactionInstruction),
  toTransactionInstruction(swapInstructions.swapInstruction),
];

// Sign each instruction individually
const signIxs = await Promise.all(
  swigInstructions.map(async (instruction) => {
    return await signInstruction(
      rootRole,
      rootUser.publicKey,
      [instruction]
    );
  })
);
```

### 4. Creating and Sending the Transaction

```typescript
const messageV0 = new TransactionMessage({
  payerKey: rootUser.publicKey,
  recentBlockhash: blockhash,
  instructions: [...outerInstructions, ...signIxs],
}).compileToV0Message(addressLookupTableAccounts);

const transaction = new VersionedTransaction(messageV0);
transaction.sign([rootUser]);

const signature = await connection.sendTransaction(transaction, {
  skipPreflight: true,
  preflightCommitment: 'confirmed'
});
```

## Important Considerations

1. **Compute Budget Management**:
   * Set appropriate compute unit limit and price
   * These instructions must be outside of Swig-signed instructions

2. **Account Management**:
   * Create ATAs in separate transactions before swapping
   * Account for Swig's overhead when setting `maxAccounts`

3. **Transaction Structure**:
   * Properly separate outer instructions from Swig-signed instructions
   * Sign each Swig instruction individually
   * Use versioned transactions with address lookup tables

4. **Error Handling**:
   * Verify ATA existence and creation
   * Check transaction confirmation status
   * Verify token balances after swap

## Running the Example

1. Prepare your keypair file
2. Run the example:

```bash
bun run index.ts path/to/keypair.json [optional-swig-address]
```

The example will:

* Create or use an existing Swig wallet
* Set up necessary token accounts
* Get the best swap route from Jupiter
* Execute the swap with proper instruction handling

## Production Considerations

1. **Security**:
   * Securely manage keypairs and private keys
   * Implement proper error recovery mechanisms
   * Add transaction timeout handling

2. **Performance**:
   * Adjust compute budget based on swap complexity
   * Consider using RPC endpoints with higher rate limits
   * Implement proper retry mechanisms

3. **User Experience**:
   * Add progress indicators for multi-step operations
   * Implement proper balance checking and updates
   * Add slippage protection options

For more information, check out:

* [Jupiter API Documentation](https://station.jup.ag/docs/apis/overview)
* [Swig Documentation](https://docs.swig.rs/)


# Transferring stuff with Swig
Source: https://build.onswig.com/examples/transfer

\"Give and it will be given to you\" - Ancient Green Manuscripts

This guide walks through different ways to perform transfers using Swig, progressing from basic to more advanced patterns.
You can find all example code in the [swig-ts/examples/transfer](https://github.com/swig-wallet/swig/tree/main/swig-ts/examples/transfer) directory.

<Tip>Examples with svm in the file name use LiteSVM for testing. Those without svm in the file name use a local validator. Which you can run with the `bun start-validator` command.</Tip>

## Basic Transfer with Ed25519 Keys

The simplest way to use Swig is with standard Ed25519 keypairs. Here are the key parts:

```typescript
// Key Setup - Using standard Solana keypairs
const userRootKeypair = Keypair.generate();
const signer = Keypair.generate();

// Create a new Swig account with root authority
const rootActions = Actions.set().all().get();
const createSwigInstruction = Swig.create({
  // 👇 Using Ed25519 authority
  authorityInfo: createEd25519AuthorityInfo(userRootKeypair.publicKey),
  id,
  payer: userRootKeypair.publicKey,
  actions: rootActions,
});

// Transfer SOL using Ed25519 signing
const transfer = SystemProgram.transfer({
  fromPubkey: swigAddress,
  toPubkey: dappTreasury,
  lamports: 0.1 * LAMPORTS_PER_SOL,
});

const signedTransfer = await signInstruction(
  rootRole,
  signer.publicKey,
  [transfer],
  {
    currentSlot: BigInt(slot),
    // 👇 Ed25519 signing function
    signingFn: ed25519SigningFn,
  },
);
```

You can find the complete example in `transfer-local.ts` and `transfer-svm.ts` for local and LiteSVM environments respectively.

## Using Secp256k1 Keys (EVM Compatible)

For EVM compatibility, Swig supports Secp256k1 keys. Note the key differences from the Ed25519 example:

```typescript
// Key Setup - Using Ethereum wallet
const userWallet = Wallet.generate(); // 👈 EVM wallet instead of Solana Keypair

// Create Swig with Secp256k1 authority
const createSwigInstruction = Swig.create({
  // 👇 Using Secp256k1 authority instead of Ed25519
  authorityInfo: createSecp256k1AuthorityInfo(userWallet.getPublicKey()),
  id,
  payer: payer.publicKey, // Still needs a Solana account for fees
  actions: rootActions,
});

// Sign using the Secp256k1 private key
const signingFn = getSigningFnForSecp256k1PrivateKey(
  userWallet.getPrivateKey(), // 👈 Different signing function
);

// Transfer remains the same, but uses Secp256k1 signing
const signedTransfer = await signInstruction(
  rootRole,
  signer.publicKey,
  [transfer],
  {
    currentSlot: BigInt(slot),
    signingFn, // 👈 Using Secp256k1 signing function
  },
);
```

Check out `transfer-local-secp.ts` and `transfer-svm-secp.ts` for complete examples.

## Using Viem for Ethereum Wallet Integration

For a more complete Ethereum wallet integration using Viem, here are the key differences:

```typescript
// Key Setup - Using Viem account
const privateKeyAccount = privateKeyToAccount(userWallet.getPrivateKeyString());

// Create Swig remains similar to Secp256k1 example
const createSwigInstruction = Swig.create({
  authorityInfo: createSecp256k1AuthorityInfo(privateKeyAccount.publicKey),
  id,
  payer: transactionPayer.publicKey,
  actions: rootActions,
});

// Sign transactions using Viem
const signTransfer = await signInstruction(
  rootRole,
  transactionPayer.publicKey,
  [transfer],
  {
    currentSlot: svm.getClock().slot,
    signingFn: viemSign, // 👈 Using Viem signing function
  },
);
```

The complete example is available in `transfer-svm-viem.ts`.

## Using Sessions for Enhanced Security

Sessions allow you to delegate limited authority for a specific duration. You can create sessions with any authority type:

### Ed25519 Sessions

```typescript
// Create an Ed25519 session
const sessionAuthority = Keypair.generate();
const sessionDuration = 100n; // slots

const addSessionInstruction = await addAuthorityInstruction(
  rootRole,
  signer.publicKey,
  {
    currentSlot: BigInt(slot),
    signingFn: ed25519SigningFn,
    // 👇 Ed25519 session authority
    authorityInfo: createEd25519AuthorityInfo(sessionAuthority.publicKey),
    actions: sessionActions,
    duration: sessionDuration,
  },
);
```

### Secp256k1 Sessions

```typescript
// Create a Secp256k1 session
const sessionWallet = Wallet.generate();
const sessionDuration = 100n; // slots

const addSessionInstruction = await addAuthorityInstruction(
  rootRole,
  signer.publicKey,
  {
    currentSlot: BigInt(slot),
    signingFn: secp256k1SigningFn,
    // 👇 Secp256k1 session authority
    authorityInfo: createSecp256k1AuthorityInfo(sessionWallet.getPublicKey()),
    actions: sessionActions,
    duration: sessionDuration,
  },
);
```

Key aspects of sessions:

* Can be created with any supported authority type (Ed25519, Secp256k1)
* Limited duration specified in slots
* Restricted set of actions (defined by `sessionActions`)
* Perfect for dApp integrations where temporary access is needed

You can find complete session examples in:

* `transfer-local-session.ts` (Ed25519)
* `transfer-svm-session.ts` (Ed25519)
* `transfer-svm-secp-session.ts` (Secp256k1)

For more detailed information about sessions, check out the [Creating Sessions Guide](../guides/sessions).

## Testing Environment Options

These examples can be run in different environments:

* **Local Validator**: Use the `transfer-local-*` examples
  * Requires running a local Solana validator
  * Real blockchain environment
  * Good for final testing

* **LiteSVM**: Use the `transfer-svm-*` examples
  * No validator required
  * Instant transaction confirmation
  * Perfect for rapid development
  * Simulates the Solana runtime

* **Devnet**: All examples work with devnet
  * Change connection URL to `https://api.devnet.solana.com`
  * Real network environment
  * Free to use with airdropped SOL

LiteSVM is recommended for initial development as it provides the fastest feedback loop. Move to local validator or devnet for more thorough testing.


# Swig: Smart Wallet Tooling for Solana
Source: https://build.onswig.com/index

Swig is a powerful account abstraction toolkit that enables developers to create advanced, programmable Solana smart wallets with features like delegated access controls, fine-grained permissions, social recovery, and cross-chain compatibility.

## **What is Swig?**

Swig is an account abstraction toolkit that empowers developers to create sophisticated, programmable smart wallets on Solana. It’s powerful, open-sourced, and fast to build on - most use cases can be built on Swig in \<30 minutes.

Smart wallet functionality has been popular on EVM chains, but less developed on Solana. Swig changes that. Developers can now build smarter on Solana with Swig. See how below.

<Note>
  SWIG is on mainnet and devnet but should be considered AT YOUR OWN RISK RIGHT NOW.\
  Our first audit is in progress and we are busy hardening the program to bring you Solana Wallet Interface Greatness.
</Note>

### **Current Market Problems**

Developments in Web3 have brought many benefits, but simultaneously some table stakes Web2 functions have been lost along the way. Traditional crypto wallets are part of this problem:

* **Poor UX:** Traditional wallets force users to either give up full control or do everything manually themselves. You could be the best dev, but your app’s experience would inherently be downgraded as a result.
* **Payments:** While crypto solves many payments challenges, the automated and configurable transaction tooling critical for most payments use cases is still limited.
* **General Abstraction:** Developers need to rely on users who are blockchain experts to gain traction on their apps due to limited abstraction tooling in the market.
* **Onboarding:** Seed phrases, onramps, and gas all make onboarding to a new app complicated. Devs are losing the battle before it even starts.

Smart wallets solve these problems, but while smart wallets have seen widespread adoption on Ethereum, Solana has remained underserved - until now.

### **How Swig Solves These Problems**

A Swig wallet is an on-chain account built inside a Solana program that can perform all standard wallet functions while adding powerful programmable features:

| Swig Features                                                                                                                       | Pre-Swig Paradigm                                                                                                                                     | Post-Swig Paradigm                                                                                                                                        |
| :---------------------------------------------------------------------------------------------------------------------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **🗝️ Non-Custodial Smart Wallets** <br /> *Devs can create Web2 UX without sacrificing on Web3 self-custody standards*             | **Custody vs. UX Tradeoff** <br />❌ Devs choose between: Self-custody, but complex UX <br />Or<br />❌ Custodial services, but security risks          | **Web2 UX + Web3 Self-Custody Control** <br />✅ Create embedded wallets with no intermediaries <br />✅ Apps can request permissions without managing keys |
| **⏳ Session-Based Authorization** <br /> *Enable temporary, permissioned app access without constant manual approvals*              | **Manual Approval Friction** <br />❌ Users manually approve every transaction <br />❌ Apps lose traction due to “approve fatigue”                     | **Seamless Session Mgmt**<br />✅ Users approve once per session period <br />✅ Configurable time limited permissions                                      |
| **🔓 Granular Permissions** <br /> *Delegate specific transaction permissions rather than full wallet control*                      | **All-or-Nothing Access** <br />❌ Wallets require full signing authority                                                                              | **Fine-Grained Controls** <br />✅ Role-based permissions <br />✅ Transaction-type permissions                                                             |
| **🔄 Automated Transactions** <br /> *Power subscription payments, payment streaming, and conditional transactions*                 | **Manual Payments**<br />❌ Payments are not programmable <br />❌ Advanced payment logic done off-chain                                                | **Programmable Payments**<br />✅ Subscription billing <br />✅ Payment streaming <br />✅ Automated rebalancing <br />✅ Dollar-cost averaging               |
| **🌐 Social Recovery & Authentication** <br /> *Manage wallets using social accounts like Google, X, or Facebook through ZK proofs* | **Seed Phrase Vulnerability & Onboarding Frictions** <br />❌ Complicated user onboarding <br />❌ No key recovery options                              | **Familiar Recovery & Onboarding Methods** <br />✅ Seamless Web2 user onboarding <br />✅ Multi-guardian recovery with trusted contacts                    |
| **⛓️ Chain Abstraction** <br /> *Operate seamlessly across multiple chains*                                                         | **Single Chain Limitations** <br />❌ Separate wallets needed for different chains                                                                     | **Unified Multi-Chain Experience**<br />✅ 1 wallet operates across all SVM chains <br />✅ Sign SVM transactions with EVM Keys                             |
| **⛽ Paymaster Integration** <br /> *Cover gas fees for users through a central account*                                             | **Gas Fee Barriers** <br />❌ Users must hold native SOL tokens for every trx <br />❌ High-friction onboarding <br />❌ App experiences can’t be “free” | **No Gas, No Problem** <br />✅ Apps cover gas for users <br />✅ Users can pay gas with other tokens <br />✅ “Freemium” app experiences possible           |

***

## **Why Swig Makes Solana More Powerful**

Solana combined with Swig is a game changer for developers.

|                             | Solana                                                                                                                                                                                                                                                               | Solana + Swig                                                                                                                                                |
| :-------------------------- | :------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :----------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Payments Infrastructure** | Solana is emerging as a leader in payments due in large part to its fast transaction settlement speed                                                                                                                                                                | Swig expands on this by allowing developers to **abstract complexity** and create **powerful non-custodial payments solutions** for consumers and businesses |
| **Consumer Adoption**       | Solana is the hub for consumer apps                                                                                                                                                                                                                                  | Swig **dramatically improves UX** for Solana app developers by enhancing key management systems to enable **simple and secure product flows**                |
| **Performance at Scale**    | Solana’s fast transaction speeds and low fees make it particularly attractive for high-velocity trading and payment use cases But, legacy wallet experiences limit this performance advantage with constant manual approvals and limited transaction programmability | Swig’s optimized design **maintains Solana’s high speed and low fees**, even with advanced wallet features                                                   |

***

## **How Swig Works**

The Swig protocol operates through a role-based system that enables seamless interaction with various services and platforms on Solana. Each role has:

* An authority mechanism that can include social logins, blockchain keypairs, and other authentication methods
* A set of configurable permissions that control what actions can be taken
* Optional session-based authentication for enhanced security

This flexible architecture allows developers to create custom wallet solutions while maintaining security and user control. Whether you’re building DeFi apps, payment solutions, or next-generation consumer wallets, Swig provides the infrastructure needed to create powerful, user-friendly experiences.


# Swig MCP Support
Source: https://build.onswig.com/mcp-support



## Overview

The Model Context Protocol (MCP) is an open protocol that connects your functions to LLMs and AI applications. With Mintlify's integration, you can automatically generate an MCP server for Swig's docs, enabling seamless AI-powered interactions with your product.

## Generating your MCP server

Swig docs can be converted into an MCP server using the following command:

```bash
npx mint-mcp add build.onswig.com
```

You can also view an llms-full.txt file [here](https://build.onswig.com/llms-full.txt)

<Note>
  You can view the full documentation for Mintlify's MCP Configuration [here](https://mintlify.com/docs/mcp).
</Note>


# null
Source: https://build.onswig.com/reference/index



# SWIG SDKs: TypeScript and Rust

SWIG provides powerful SDKs in both TypeScript and Rust, each optimized for different use cases in the blockchain development ecosystem. Let's explore how these SDKs can enhance your development experience.

## TypeScript SDK

The TypeScript SDK is specifically designed for frontend applications and wallet integrations. It excels in:

* **Wallet Integration**: Seamlessly connect with web-based wallets and handle user interactions
* **Frontend Development**: Build responsive and interactive dApp interfaces
* **Browser Compatibility**: Optimized for web environments and modern browsers
* **User Experience**: Provides smooth, asynchronous operations for blockchain interactions

Perfect for:

* Web-based dApps
* Wallet interfaces
* User-facing blockchain applications
* Interactive frontend experiences

## Rust SDK

The Rust SDK is engineered for high-performance backend applications and command-line tools. Its strengths include:

* **Server Applications**: Build robust backend services with native performance
* **CLI Tools**: Create powerful command-line interfaces for blockchain interactions
* **Performance**: Leverage Rust's zero-cost abstractions and memory safety
* **System Integration**: Deep integration with system-level resources

Ideal for:

* Backend services
* Command-line tools
* High-performance applications
* System-level blockchain integration

## Choosing the Right SDK

When building your blockchain application:

* Choose the **TypeScript SDK** when you need to:
  * Build user interfaces
  * Integrate with web wallets
  * Create frontend applications
  * Handle user interactions

* Choose the **Rust SDK** when you need to:
  * Develop backend services
  * Create CLI tools
  * Optimize for performance
  * Build system-level applications

Both SDKs provide comprehensive tooling for blockchain development, allowing you to choose the best tool for your specific use case while maintaining full compatibility with the SWIG ecosystem.


# Rust SDK
Source: https://build.onswig.com/reference/rust/index

Typesafe, Memory Safe wallet anyone?

The Rust SDK is a powerful toolkit designed for backend use cases, providing developers with robust tools for blockchain interaction and wallet management. The SDK is built on three main pillars:

## Instruction Builder

The Instruction Builder is a core component that helps developers construct and manage blockchain instructions. It provides a type-safe and intuitive way to build transaction instructions, making it easier to interact with the blockchain while maintaining security and reliability.

Key features:

* Type-safe instruction building
* Transaction composition
* Built-in validation

## Swig Rust Wallet

The Swig Rust Wallet component provides comprehensive wallet management capabilities. It handles key management, transaction signing, and account operations with a focus on security and performance.

Key features:

* Secure key management
* Transaction signing
* Account operations
* Balance tracking

## Swig CLI

The Swig CLI is a command-line interface tool that provides direct access to wallet functionality from the terminal. It's built on top of the Rust SDK and offers a convenient way to interact with the blockchain for testing, development, and automation purposes.

Key features:

* Command-line wallet management
* Transaction creation and signing
* Account information retrieval
* Network interaction utilities

## Code References

The SDK's source code can be found in the following locations:

* [Instruction Builder/Rust Wallet Source](https://github.com/anagrambuild/swig-wallet/tree/main/rust-sdk)
* [Swig CLI Documentation](https://github.com/anagrambuild/swig-wallet/blob/main/cli-x/README.md)
* [Rust SDK Documentation](https://github.com/anagrambuild/swig-wallet/tree/main/docs/rust-sdk)

## Getting Started

To start using the Rust SDK, you'll need to add it as a dependency to your Rust project. The SDK provides a modular architecture allowing you to use only the components you need for your specific use case.

For detailed implementation examples and API documentation, please refer to the individual component documentation linked above.


# Instruction Builder
Source: https://build.onswig.com/reference/rust/instruction_builder

Sometimes you just need to build an instruction

The `SwigInstructionBuilder` is a fundamental component of the Swig SDK that handles the creation and management of Solana instructions for the Swig protocol.

## Overview

The instruction builder provides low-level functionality for creating various types of instructions needed to interact with Swig wallets on the Solana blockchain.

## Core Components

### AuthorityManager

```rust
pub enum AuthorityManager {
    Ed25519(Pubkey),
    Secp256k1(Box<[u8]>, Box<dyn Fn(&[u8]) -> [u8; 65]>),
    Ed25519Session(CreateEd25519SessionAuthority),
    Secp256k1Session(CreateSecp256k1SessionAuthority, Box<dyn Fn(&[u8]) -> [u8; 65]>),
}
```

The `AuthorityManager` enum represents different types of signing authorities supported by the Swig protocol.

### SwigInstructionBuilder

```rust
pub struct SwigInstructionBuilder {
    swig_id: [u8; 32],
    swig_account: Pubkey,
    authority_manager: AuthorityManager,
    payer: Pubkey,
    role_id: u32,
}
```

## Core Functions

### Creating a New Instance

```rust
pub fn new(
    swig_id: [u8; 32],
    authority_manager: AuthorityManager,
    payer: Pubkey,
    role_id: u32,
) -> Self
```

Creates a new instance of the instruction builder with the specified parameters.

### Building a Swig Account

```rust
pub fn build_swig_account(&self) -> Result<Instruction, SwigError>
```

Creates an instruction to initialize a new Swig account on-chain.

### Signing Instructions

```rust
pub fn sign_instruction(
    &mut self,
    instructions: Vec<Instruction>,
    current_slot: Option<u64>,
) -> Result<Vec<Instruction>, SwigError>
```

Creates signed instructions for the provided transaction instructions.

## Authority Management

### Adding Authorities

```rust
pub fn add_authority_instruction(
    &mut self,
    new_authority_type: AuthorityType,
    new_authority: &[u8],
    permissions: Vec<ClientPermission>,
    current_slot: Option<u64>,
) -> Result<Instruction, SwigError>
```

Creates an instruction to add a new authority with specified permissions.

### Removing Authorities

```rust
pub fn remove_authority(
    &mut self,
    authority_to_remove_id: u32,
    current_slot: Option<u64>,
) -> Result<Instruction, SwigError>
```

Creates an instruction to remove an existing authority.

### Replacing Authorities

```rust
pub fn replace_authority(
    &mut self,
    authority_to_replace_id: u32,
    new_authority_type: AuthorityType,
    new_authority: &[u8],
    permissions: Vec<ClientPermission>,
    current_slot: Option<u64>,
) -> Result<Vec<Instruction>, SwigError>
```

Creates instructions to replace an existing authority with a new one.

## Session Management

### Creating Sessions

```rust
pub fn create_session_instruction(
    &self,
    session_key: Pubkey,
    session_duration: u64,
    current_slot: Option<u64>,
) -> Result<Instruction, SwigError>
```

Creates an instruction to create a new session for temporary authority delegation.

## Utility Functions

### Getting the Swig Account

```rust
pub fn get_swig_account(&self) -> Result<Pubkey, SwigError>
```

Returns the public key of the Swig account.

### Getting the Role ID

```rust
pub fn get_role_id(&self) -> u32
```

Returns the current role ID of the Swig account.

### Switching Authority

```rust
pub fn switch_authority(&mut self, role_id: u32, authority: Pubkey) -> Result<(), SwigError>
```

Switches the current authority and role ID.

## Examples

### Creating a New Swig Account

```rust
let instruction_builder = SwigInstructionBuilder::new(
    swig_id,
    AuthorityManager::Ed25519(authority_pubkey),
    payer_pubkey,
    0
);

let create_ix = instruction_builder.build_swig_account()?;
```

### Adding a New Authority

```rust
let add_authority_ix = instruction_builder.add_authority_instruction(
    AuthorityType::Ed25519,
    new_authority_bytes,
    vec![Permission::All],
    Some(current_slot)
)?;
```


# Rust Wallet
Source: https://build.onswig.com/reference/rust/rust_wallet

A iron wallet, with a little rust

The `SwigWallet` is an abstraction for interacting with Swig wallets on chain. It provides a user-friendly interface for managing wallets, authorities, and transactions.

## Overview

The Wallet SDK builds upon the instruction builder to provide comprehensive Swig wallet management. It handles RPC communication, transaction building, and wallet state management.

## Core Components

### SwigWallet Structure

```rust
pub struct SwigWallet<'a> {
    instruction_builder: SwigInstructionBuilder,
    rpc_client: RpcClient,
    fee_payer: &'a Keypair,
    authority: &'a Keypair,
}
```

## Core Functions

### Creating a New Wallet

```rust
pub fn new(
    swig_id: [u8; 32],
    authority_manager: AuthorityManager,
    fee_payer: &'c Keypair,
    authority: &'c Keypair,
    rpc_url: String,
) -> Result<Self, SwigError>
```

Creates a new Swig wallet or initializes an existing one.

## Authority Management

### Adding Authorities

```rust
pub fn add_authority(
    &mut self,
    new_authority_type: AuthorityType,
    new_authority: &[u8],
    permissions: Vec<Permission>,
) -> Result<Signature, SwigError>
```

Adds a new authority to the wallet with specified permissions.

### Removing Authorities

```rust
pub fn remove_authority(
    &mut self,
    authority: &[u8]
) -> Result<Signature, SwigError>
```

Removes an existing authority from the wallet.

### Replacing Authorities

```rust
pub fn replace_authority(
    &mut self,
    authority_to_replace_id: u32,
    new_authority_type: AuthorityType,
    new_authority: &[u8],
    permissions: Vec<Permission>,
) -> Result<Signature, SwigError>
```

Replaces an existing authority with a new one.

## Transaction Management

### Signing Transactions

```rust
pub fn sign(
    &mut self,
    inner_instructions: Vec<Instruction>,
    alt: Option<&[AddressLookupTableAccount]>,
) -> Result<Signature, SwigError>
```

Signs and sends a transaction containing the provided instructions.

## Session Management

### Creating Sessions

```rust
pub fn create_session(
    &mut self,
    session_key: Pubkey,
    duration: u64
) -> Result<(), SwigError>
```

Creates a new session for temporary authority delegation.

## Wallet Information

### Displaying Wallet Details

```rust
pub fn display_swig(&self) -> Result<(), SwigError>
```

Displays detailed information about the wallet, including:

* Account address
* Total roles
* Balance
* Authority details
* Permissions

### Getting Wallet Balance

```rust
pub fn get_balance(&self) -> Result<u64, SwigError>
```

Returns the SOL balance of the Swig account.

### Getting Authority Permissions

```rust
pub fn get_current_authority_permissions(&self) -> Result<Vec<Permission>, SwigError>
```

Retrieves the current authority's permissions from the Swig account.

## Utility Functions

### Switching Authority

```rust
pub fn switch_authority(
    &mut self,
    role_id: u32,
    authority: Pubkey
) -> Result<(), SwigError>
```

Switches to a different authority for the wallet.

### Switching Fee Payer

```rust
pub fn switch_payer(
    &mut self,
    payer: &'c Keypair
) -> Result<(), SwigError>
```

Updates the fee payer for the wallet.

## Examples

### Creating a New Wallet

```rust
let wallet = SwigWallet::new(
    swig_id,
    AuthorityManager::Ed25519(authority_pubkey),
    &fee_payer,
    &authority,
    "https://api.mainnet-beta.solana.com".to_string(),
)?;
```

### Adding an Authority with Permissions

```rust
let signature = wallet.add_authority(
    AuthorityType::Ed25519,
    &new_authority_bytes,
    vec![
        Permission::All,
        Permission::Sol {
            amount: 1_000_000_000, // 1 SOL
            recurring: None,
        },
    ],
)?;
```

### Creating a Session

```rust
wallet.create_session(
    session_keypair.pubkey(),
    1000, // Duration in slots
)?;
```

### Signing a Transaction

```rust
let signature = wallet.sign(
    vec![transfer_instruction],
    None, // No address lookup tables
)?;
```


# Swig TypeScript SDK
Source: https://build.onswig.com/reference/typescript/index

The Swig TypeScript SDK provides a robust interface for interacting with Solana smart contracts and wallets.

The Swig TypeScript SDK provides a robust interface for interacting with Solana smart contracts and wallets.Built on top of the Web3.js 1.0 line of Solana SDK, it offers developers a streamlined experience for building decentralized applications on Solana.

## API Reference

The canonical source for the Swig TypeScript SDK API documentation can be found at:
[https://anagrambuild.github.io/swig-ts/modules.html](https://anagrambuild.github.io/swig-ts/modules.html)

This comprehensive reference includes detailed documentation for all modules, including:

* `@swig-wallet/classic`
  * `@swig-wallet/coder`

## Future Development

We are actively working on expanding the SDK's capabilities. Upcoming features include:

* Support for Web3.js 2.0
  * Integration with Gill

These additions will provide developers with even more flexibility and enhanced capabilities for building on Solana.

Stay tuned for updates as we continue to evolve the SDK to meet the growing needs of the Solana development community.


# Build an Embedded Wallet with Swig and Para
Source: https://build.onswig.com/tutorials/embeded_wallet_para/index

"The best wallet is the one your users don't even know they're using" - Web3 UX Manifesto

Welcome to the Para Embedded Wallet tutorial! This guide will walk you through setting up a Swig account with Para's solution for embedded wallets. Para provides a modal that makes authentication simple and easy for both developers and users.

## What You'll Learn

In this tutorial, you'll learn how to:

* Set up a Para developer account
* Create a React + Vite project with Para integration
* Implement Para's authentication modal
* Create a Swig account using the Para-generated wallet

## Live Demos

* [Para Modal Example](https://para-modal-example-git-main-anagram.vercel.app/)
* [In App Wallet Example](https://in-app-wallet-example.vercel.app/)

## Time Commitment

This tutorial is designed to be completed in approximately 45 minutes.

## Prerequisites

Before starting this tutorial:

1. Set up a Para account on their [developer portal](https://developer.getpara.com)
2. Generate an API Key
3. Enable Solana as a supported network

## Tutorial Sections

1. Project Setup
2. Para SDK Integration
3. Creating the UI Components
4. Implementing Swig Account Creation

## 1. Project Setup

First, let's create a new Vite project and install the necessary dependencies.

### Create a Vite Project

Follow the [Vite docs](https://vite.dev/guide) to create a new project.

### Install Dependencies

```bash
yarn add @getpara/react-sdk @tanstack/react-query @getpara/solana-web3.js-v1-integration @solana/web3.js @swig-wallet/classic @swig-wallet/coder
```

### Set up Vite Polyfills

Install the polyfills package:

```bash
yarn add vite-plugin-node-polyfills -D
```

Create or update your `vite.config.ts`:

```typescript
import { defineConfig } from "vite";
import react from "@vitejs/plugin-react";
import { nodePolyfills } from "vite-plugin-node-polyfills";
import path from "path";

export default defineConfig({
  plugins: [react(), nodePolyfills()],
  resolve: {
    alias: {
      "@": path.resolve(__dirname, "./src"),
    },
  },
});
```

## 2. Para SDK Integration

### Set up the Para Provider

Create a file called `providers.tsx` in your `src` directory:

```typescript
import React from "react";
import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
import { Environment, ParaProvider } from "@getpara/react-sdk";
import "@getpara/react-sdk/styles.css";

const queryClient = new QueryClient();

interface ProvidersProps {
  children: React.ReactNode;
}

export function Providers({ children }: ProvidersProps) {
  return (
    <QueryClientProvider client={queryClient}>
      <ParaProvider
        paraClientConfig={{
          apiKey: import.meta.env.VITE_PARA_API_KEY || "",
          env: Environment.BETA,
        }}
      >
        {children}
      </ParaProvider>
    </QueryClientProvider>
  );
}
```

### Add TypeScript Environment Types

Create a file called `vite-env-d.ts` in your `src` directory:

```typescript
/// <reference types="vite/client" />
```

### Configure Environment Variables

Create a `.env.local` file in your project root:

```env
VITE_PARA_API_KEY=<your_api_key>
```

> 🔒 Never commit your API key to version control!

## 3. Creating the UI Components

### Update App Component

Modify your `App.tsx`:

```typescript
import React from "react";
import { Providers } from "./providers";
import { AppContent } from "./components/AppContent";

const App = () => {
  return (
    <Providers>
      <AppContent />
    </Providers>
  );
};

export default App;
```

### Create the Main Component

Create `AppContent.tsx` in `src/components/`:

```typescript
import React, { useState, useEffect } from "react";
import { useAccount, useWallet, useClient } from "@getpara/react-sdk";
import { ParaSolanaWeb3Signer } from "@getpara/solana-web3.js-v1-integration";
import { Connection, LAMPORTS_PER_SOL, PublicKey, Transaction } from "@solana/web3.js";
import { Actions, Swig, findSwigPda, createEd25519AuthorityInfo } from "@swig-wallet/classic";
import { LoginButton } from "./LoginButton";

export const AppContent: React.FC = () => {
  const { data: account } = useAccount();
  const { data: wallet } = useWallet();
  const [swigAddress, setSwigAddress] = useState<string | null>(null);
  const [solBalance, setSolBalance] = useState<number | null>(null);
  const [isCreatingSwig, setIsCreatingSwig] = useState(false);

  const para = useClient();
  const connection = new Connection("https://api.devnet.solana.com");

  const createSwigAccount = async () => {
    if (!wallet?.address || !para) return;
    setIsCreatingSwig(true);

    try {
      // Generate random ID for the Swig account
      const id = new Uint8Array(32);
      crypto.getRandomValues(id);

      const paraPubkey = new PublicKey(wallet.address);
      const [swigPdaAddress] = findSwigPda(id);

      // Create Para Solana signer
      const signer = new ParaSolanaWeb3Signer(para, connection, wallet.id);

      // Create root authority info
      const rootAuthorityInfo = createEd25519AuthorityInfo(paraPubkey);

      // Set up actions
      const rootActions = Actions.set().all().get();

      // Create the Swig creation instruction
      const createSwigInstruction = Swig.create({
        authorityInfo: rootAuthorityInfo,
        id,
        payer: paraPubkey,
        actions: rootActions,
      });

      // Build transaction
      const transaction = new Transaction();
      transaction.add(createSwigInstruction);
      transaction.feePayer = paraPubkey;

      // Get recent blockhash
      const { blockhash } = await connection.getLatestBlockhash();
      transaction.recentBlockhash = blockhash;

      // Sign transaction using Para's Solana signer
      const signedTransaction = await signer.signTransaction(transaction);

      // Send the signed transaction
      const signature = await connection.sendRawTransaction(signedTransaction.serialize());

      // Wait for confirmation
      await connection.confirmTransaction({
        signature,
        blockhash,
        lastValidBlockHeight: (await connection.getLatestBlockhash()).lastValidBlockHeight,
      });

      setSwigAddress(swigPdaAddress.toBase58());
      setIsCreatingSwig(false);

      console.log("Swig account created successfully!");
      console.log("Swig address:", swigPdaAddress.toBase58());
      console.log("Transaction signature:", signature);
    } catch (error) {
      console.error("Error in transaction signing:", error);
      setIsCreatingSwig(false);
    }
  };

  useEffect(() => {
    const fetchBalance = async () => {
      if (wallet?.address) {
        try {
          const balance = await connection.getBalance(new PublicKey(wallet.address));
          setSolBalance(balance / LAMPORTS_PER_SOL);
        } catch (e) {
          setSolBalance(null);
        }
      }
    };
    fetchBalance();
  }, [wallet?.address]);

  return (
    <div className="min-h-screen flex justify-center p-4">
      <div className="max-w-md w-full space-y-6 p-8">
        <div className="text-center">
          <h2 className="text-3xl font-extrabold text-gray-900">Para Solana Web3.js Example</h2>
          <p className="mt-2 text-sm text-gray-600">
            Using Para's Solana Web3.js integration for transaction signing
          </p>
        </div>
        {account?.isConnected && wallet && (
          <div className="text-center mb-4">
            <p className="text-green-700 font-medium">You are signed in!</p>
            <p className="text-sm text-gray-700">
              Wallet address:{" "}
              <span className="font-mono break-all">
                {para
                  ? para.getDisplayAddress(wallet.id, { truncate: false, addressType: wallet.type })
                  : wallet.id}
              </span>
            </p>
            {solBalance !== null && (
              <p className="text-sm text-gray-700">
                Balance: <span className="font-mono">{solBalance} SOL</span>
              </p>
            )}
            {swigAddress && (
              <p className="text-sm text-gray-700">
                Swig address: <span className="font-mono break-all">{swigAddress}</span>
              </p>
            )}
          </div>
        )}
        <div className="flex justify-center">
          <div className="w-full max-w-xs gap-4 flex flex-col">
            {account?.isConnected && (
              <button
                onClick={createSwigAccount}
                disabled={isCreatingSwig}
                className="w-full px-4 py-2 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:bg-blue-400"
              >
                {isCreatingSwig ? "Creating Swig..." : "Create Swig"}
              </button>
            )}
            <LoginButton />
          </div>
        </div>
      </div>
    </div>
  );
};
```

### Create the Login Button Component

Create `LoginButton.tsx` in `src/components/`:

```typescript
import React from "react";
import { ParaModal, useModal, OAuthMethod, useAccount, useLogout } from "@getpara/react-sdk";

export const LoginButton: React.FC = () => {
  const { openModal } = useModal();
  const { data: account } = useAccount();
  const { logoutAsync } = useLogout();

  const handleClick = () => {
    if (account?.isConnected) {
      logoutAsync();
    } else {
      openModal();
    }
  };

  return (
    <>
      <button
        onClick={handleClick}
        className={`w-full px-4 py-2 rounded-md ${
          account?.isConnected
            ? "bg-gray-200 text-gray-700 hover:bg-gray-300"
            : "bg-blue-600 text-white hover:bg-blue-700"
        }`}
      >
        {account?.isConnected ? "Sign out" : "Sign in with Para"}
      </button>

      <ParaModal
        appName="Para Modal Example"
        logo="https://onswig.com/raccoon-logo.svg"
        oAuthMethods={[OAuthMethod.GOOGLE, OAuthMethod.TWITTER, OAuthMethod.DISCORD]}
      />
    </>
  );
};
```

## 4. Understanding the Implementation

### Para Modal Integration

The Para modal handles:

* User authentication via OAuth providers
* Wallet creation and management
* Secure key storage

> 💡 Para abstracts away the complexity of wallet creation and management

### Swig Account Creation

The `createSwigAccount` function:

1. Generates a unique ID for the Swig account
2. Creates a Para Solana signer
3. Sets up root authority with full permissions
4. Builds and signs the transaction using Para's signer
5. Sends the transaction to create the Swig account

> 🔒 The Para-generated wallet becomes the root authority for the Swig account

### Important Notes

1. **Devnet SOL**: Before creating the Swig account, you need to send devnet SOL to the Para-generated wallet address.

2. **Error Handling**: The implementation includes proper error handling and loading states.

3. **Balance Display**: The UI shows the wallet's SOL balance and Swig address after creation.

## Running the Application

1. Start the development server:

```bash
yarn dev
```

2. Open your browser to the displayed URL (usually `http://localhost:5173`)

3. Click "Sign in with Para" to authenticate

4. After authentication, send some devnet SOL to your wallet address

5. Click "Create Swig" to create your Swig account

## Next Steps

Now that you have a Swig account with Para integration, you can:

* Implement additional Swig functionality (transfers, token management, etc.)
* Customize the Para modal appearance
* Add more OAuth providers
* Implement additional security features

For more information, check out:

* [Para Documentation](https://docs.getpara.com)
* [Swig SDK Documentation](/reference/typescript)
* [Example Source Code](https://github.com/anagrambuild/swig-sdk-dapp-examples/tree/main/apps/para-modal-example)


# 1. Creating a Swig
Source: https://build.onswig.com/tutorials/typescript/create

"A journey of a thousand steps starts with one Swig." - Somebody

Before we begin our quest lets make sure you have the basics ready so lets set up a basic project, if you have already done this, feel free to move on. If you have not finished step 0 in this tutorial please go back and run through that as we refer back and depend on this step.

Now that you have your environment all setup and ready to role, make a new file called `tutorial.ts`, make sure you are in the `examples/transfer` folder. Don't forget to start your validator with `bun start-validator`

```bash
mkdir tutorial && touch tutorial-1.ts
```

Open that file up in your favorite editor, or AI overlord super virtual reality googles. Lets make a function called `createSwigAccount`

## Example

```typescript
import {
  Keypair,
  LAMPORTS_PER_SOL,
  Connection,
} from '@solana/web3.js';

import {
  Actions,
  createSwig,
  Ed25519Authority,
  findSwigPda
} from "@swig-wallet/classic";

import chalk from 'chalk';

async function createSwigAccount(
  connection: Connection,
  user: Keypair,
) {
  try {
    const id = new Uint8Array(32);
    crypto.getRandomValues(id);
    const [swigAddress] = findSwigPda(id);
    const rootAuthority = Ed25519Authority.fromPublicKey(user.publicKey);
    const rootActions = Actions.set().manageAuthority().get();
    const tx = await createSwig(
      connection,
      id,
      rootAuthority,
      rootActions,
      user.publicKey,
      [user]
    );

    console.log(chalk.green("✓ Swig account created at:"), chalk.cyan(swigAddress.toBase58()));
    return swigAddress;
  } catch (error) {
    console.error(chalk.red("✗ Error creating Swig account:"), chalk.red(error));
    throw error;
  }
}

(async () => {
  console.log(chalk.blue("🚀 Starting tutorial"));
  const connection = new Connection('http://localhost:8899', 'confirmed');
  const userKeypair = Keypair.generate();
  let f = await connection.requestAirdrop(userKeypair.publicKey, 100 * LAMPORTS_PER_SOL);
  let blockhash = await connection.getLatestBlockhash();
  await connection.confirmTransaction({
    signature: f,
    blockhash: blockhash.blockhash,
    lastValidBlockHeight: blockhash.lastValidBlockHeight,
  })
  console.log(chalk.green("👤 User public key:"), chalk.cyan(userKeypair.publicKey.toBase58()));
  let swigAddress = await createSwigAccount(connection, userKeypair);
  await setTimeout(() => {
    console.log(chalk.green("\n✨ Everything looks good!"));
    console.log(chalk.yellow("🔍 Check out your transaction on Solana Explorer:"));
    console.log(chalk.cyan(`https://explorer.solana.com/address/${swigAddress.toBase58()}?cluster=custom&customUrl=http%3A%2F%2Flocalhost%3A8899`));
  }, 2000);
})();
```

Lets save this and get ready to run it, but before we do lets break it down step by step.

## 1. Import Required SDKs

```typescript
import { Connection, PublicKey, LAMPORTS_PER_SOL } from "@solana/web3.js";
import { 
  Actions, 
  createSwig, 
  Ed25519Authority, 
  findSwigPda 
} from "@swig-wallet/classic";
```

Imports Solana primitives and essential utilities from the Swig SDK.

## 2. Generate a Unique Swig ID

```typescript
//in the create swig function
const id = new Uint8Array(32);
crypto.getRandomValues(id);
```

Generates a secure 32-byte ID that uniquely identifies this Swig wallet instance. This ID is used to derive the PDA (Program Derived Address).

> 💡 This can really be anything, as long as it's globally unique. You can even use other public keys, strings, or a boring old number if needed.

## 3. Derive the Swig PDA

```typescript
const [swigAddress] = findSwigPda(id);
```

Computes the wallet's on-chain PDA using the generated ID. This is the unique address of the Swig account on Solana.

> 🧠 This is a standard Solana pattern—Swig just makes it easier.

## 4. Create the Root Role

Swig is role-based: it combines Authorities (who) and Actions (what) to determine permissions. This section builds the root role.

```typescript
const rootAuthority = Ed25519Authority.fromPublicKey(user.publicKey);
const rootActions = Actions.set().manageAuthority().get();
```

This sets up the root role. Since this is the root, it must have at least `manageAuthority()` or `all()`.

> ✅ `manageAuthority()` is restrictive but safe.
>
> 🚨 `all()` gives full control—use carefully in production.

You can find all available action types in the [Swig SDK docs](https://anagrambuild.github.io/swig-ts/enums/_swig-wallet_coder.Permission.html). New types may be added over time.

Swig supports multiple Authority types—this example uses `Ed25519Authority`, but others are available for different credentials or verification methods. These handle the Authentication half of Swig's model. You can find all the types of authorities on the [SDK Docs](https://anagrambuild.github.io/swig-ts/enums/_swig-wallet_coder.AuthorityType.html).

## 5. Create the Swig Account On-Chain

```typescript
const tx = await createSwig(
  connection,
  id,
  rootAuthority,
  rootActions,
  user.publicKey,
  [user]
);
```

Creates the Swig account by sending a transaction to the Solana blockchain. The transaction must be signed by the user. In this case the payer of the transaction and the rent is the user, but you can also have a different fee payer for transaction for an example see this.

## 6. Simulate a Funded User

```typescript
const userKeypair = Keypair.generate();
let f = await connection.requestAirdrop(userKeypair.publicKey, 100 * LAMPORTS_PER_SOL);
let blockhash = await connection.getLatestBlockhash();
await connection.confirmTransaction({
  signature: f,
  blockhash: blockhash.blockhash,
  lastValidBlockHeight: blockhash.lastValidBlockHeight,
});
```

Creates a fresh Keypair and airdrops some SOL from the local validator so it can pay for the transaction.

## 7. Connect to the Validator

```typescript
const connection = new Connection('http://localhost:8899', 'confirmed');
```

Creates a connection to the local Solana cluster. Ensure you've run:

```bash
//in the transfer folder
bun start-validator
```

This spins up a local testnet with the Swig programs deployed.

## 8. Log Success

```typescript
console.log(chalk.green("✓ Swig account created at:"), chalk.cyan(swigAddress.toBase58()));
```

Prints the address of the new Swig account in a colorized format.

## Ready to run it?

```bash
bun run ./tutorial-1.ts
```

Congratulations on your first Swig!


# 0. Environment Setup
Source: https://build.onswig.com/tutorials/typescript/env

"One man spends and hour cutting wood, another sharpens his axe for 50 minutes and chops wood for 10 minutes" - Somebody

Before you begin writing Swig-powered apps—like wallets, token transfers, or Telegram integrations—you need to set up your development environment to support real blockchain interactions using the Swig SDK.

This setup follows the official Swig TypeScript SDK and prepares you to build and run your own scripts inside the example workspace. You'll be writing new files in the same folder as the examples so you can easily compare your code to working references.

## Prerequisites

Before starting, make sure you have the following installed:

### Option A: Node.js + Yarn

* Node.js v16 or newer
* Yarn v3+

### Option B (Preferred): Bun

Bun provides better performance and a simpler setup. Install it with:

```bash
curl -fsSL https://bun.sh/install | bash
```

### Required Tools

Additionally, you'll need:

* Solana CLI
* Rust + Cargo

## Step 1: Clone and Install

First, clone the examples repository and install dependencies:

```bash
# Clone the repository
git clone https://github.com/anagrambuild/swig-ts.git

# Enter the project directory
cd swig-ts

# Install dependencies
bun install
```

## Step 2: Navigate to Examples

Move into the examples directory where you'll write your code:

```bash
cd examples/transfer
mkdir tutorial
```

This location is important because it:

* Provides access to working examples (`transfer-local.ts`, `mint.ts`, etc.)
* Uses shared tooling without extra configuration
* Allows side-by-side comparison with official samples

## Step 3: Start the Validator

Start a local Solana testnet for development:

```bash
bun start-validator
```

This command:

* Spins up a local Solana testnet
* Installs Swig programs into the testnet
* Creates a safe, reproducible environment for testing

> 💡 Keep the validator running in a separate terminal window. You only need to start it once per development session.

## Verifying Your Setup

To verify everything is working:

1. Check the validator:

```bash
solana config get
```

You should see the local network configuration.

## Common Issues

### Validator Won't Start

If the validator fails to start:

1. Check if another validator is running:

```bash
ps aux | grep solana-test-validator
```

2. Kill any existing processes:

```bash
pkill solana-test-validator
```

### Installation Problems

If you encounter installation issues:

1. Clear your package cache:

```bash
bun cache clean
```

2. Remove and reinstall dependencies:

```bash
rm -rf node_modules
bun install
```

### Port Conflicts

If you see port conflicts:

1. Check which process is using the port:

```bash
lsof -i :8899
```

2. Either kill the process or configure a different port in your settings.

## Development Tools

We recommend the following tools for the best development experience:

### Code Editor

* VS Code with extensions:
  * TypeScript and JavaScript Language Features
  * Solidity
  * Rust

### Browser Extensions

* Swig Wallet Extension (Coming Soon)
* Phantom Wallet
* Solflare Wallet

### Command Line Tools

* `solana-cli` for blockchain interaction
* `cargo` for Rust development
* `bun` for running TypeScript files


# Geting Started with Swig TS SDK 
Source: https://build.onswig.com/tutorials/typescript/index

"The beginning of wisdom is this, get wisdom and above all get knowledge" - Solomon

Welcome to the TypeScript SWIG SDK tutorial! This comprehensive guide will walk you through all the essential functions and features of the SWIG SDK, helping you understand how to integrate SWIG into your TypeScript applications.

<Tip>The tutorial code is available in the [swig-ts](https://github.com/anagrambuild/swig-ts) repository. You can find the code for each tutorial in the `examples/transfer/tutorial` folder.</Tip>

## What You'll Learn

In this tutorial, you'll learn how to:

* Set up your development environment for SWIG
* Create and manage SWIGs
* Manage authorities and permissions
* Interact with SWIG's core features
* Signing transactions with Swig

## Time Commitment

This tutorial is designed to be completed in approximately 30 minutes. Each section builds upon the previous one, providing a clear progression through the SDK's capabilities.

## Tutorial Scope

This guide focuses on creating and managing SWIGs using regular Solana keypair authorities. While this covers the most common use cases, SWIG supports other authority types as well.

## Tutorial Sections

Follow these tutorials in order for the best learning experience:

1. [Environment Setup](./env) - Set up your development environment
2. [Creating Your First SWIG](./create) - Learn how to create and initialize a SWIG
3. [Managing Authorities and Actions](./managing_authorities) - Learn how to manage authorities and actions
4. [Signing Transactions](./sign) - Learn how to sign transactions with Swig

Let's get started with building your first SWIG!


# 2. Managing Authorities and Actions
Source: https://build.onswig.com/tutorials/typescript/managing_authorities

"The road to heaven is paved with good role based access control." - Codex Walleticus

In this tutorial, we'll learn how to add multiple authorities to a Swig account with different permission sets. We'll create a root authority that can manage other authorities, then add two specialized authorities: one for SOL spending and another for token management.

## Prerequisites

Before starting this tutorial:

1. Make sure you're in the `examples/transfer/tutorial` directory
2. Ensure your local validator is running with:
   ```bash
   bun start-validator
   ```

## Quick Review

In [Tutorial 1](./tutorial-1.md), we learned how to create a basic Swig account. Now we'll expand on that by managing multiple authorities with different permissions.

```bash
mkdir tutorial && touch tutorial-2.ts
```

Open that file up in your favorite editor, or AI overlord super virtual reality googles. Lets make a function called `createSwigAccount`

## Example(note this is only the changed code)

```typescript
async function addNewAuthority(
  connection: Connection,
  rootUser: Keypair,
  newAuthority: Keypair,
  swigAddress: PublicKey,
  actions: any,
  description: string
) {
  try {
    // Fetch the Swig account
    const swig = await fetchSwig(connection, swigAddress);

    // Find the root role that can manage authorities
    const rootRole = swig.findRolesByEd25519SignerPk(rootUser.publicKey)[0];
    if (!rootRole) {
      throw new Error('Root role not found for authority');
    }

    // Create the instruction to add the new authority
    const addAuthorityIx = await addAuthorityInstruction(
      rootRole,
      rootUser.publicKey,
      createEd25519AuthorityInfo(newAuthority.publicKey),
      actions,
    );

    // Send and confirm the transaction
    const transaction = new Transaction().add(addAuthorityIx);
    await sendAndConfirmTransaction(connection, transaction, [rootUser]);
    console.log(chalk.green(`✓ New ${description} authority added:`), chalk.cyan(newAuthority.publicKey.toBase58()));
  } catch (error) {
    console.error(chalk.red(`✗ Error adding ${description} authority:`), chalk.red(error));
    throw error;
  }
}

(async () => {
  console.log(chalk.blue("🚀 Starting tutorial - Adding Multiple Authorities"));

  // Connect to local Solana network
  const connection = new Connection('http://localhost:8899', 'confirmed');

  // Create and fund the root user
  const rootUser = Keypair.generate();
  console.log(chalk.green("👤 Root user public key:"), chalk.cyan(rootUser.publicKey.toBase58()));

  let airdrop = await connection.requestAirdrop(rootUser.publicKey, 100 * LAMPORTS_PER_SOL);
  let blockhash = await connection.getLatestBlockhash();
  await connection.confirmTransaction({
    signature: airdrop,
    blockhash: blockhash.blockhash,
    lastValidBlockHeight: blockhash.lastValidBlockHeight,
  });

  // Create the Swig account
  console.log(chalk.yellow("\n📝 Creating Swig account..."));
  const swigAddress = await createSwigAccount(connection, rootUser);

  // Create the spending authority
  const spendingAuthority = Keypair.generate();
  console.log(chalk.green("\n👥 Spending authority public key:"), chalk.cyan(spendingAuthority.publicKey.toBase58()));

  // Create the token authority
  const tokenAuthority = Keypair.generate();
  console.log(chalk.green("👥 Token authority public key:"), chalk.cyan(tokenAuthority.publicKey.toBase58()));

  // Add some delay to ensure the Swig account is created
  await new Promise(resolve => setTimeout(resolve, 2000));

  // Add spending authority with SOL limit
  console.log(chalk.yellow("\n🔑 Adding spending authority..."));
  const spendingActions = Actions.set()
    .solLimit({ amount: BigInt(0.1 * LAMPORTS_PER_SOL) })
    .get();
  await addNewAuthority(connection, rootUser, spendingAuthority, swigAddress, spendingActions, "spending");

  // Add token authority with token management permissions
  console.log(chalk.yellow("\n🔑 Adding token authority..."));
  const tokenMint = Keypair.generate().publicKey; // Example token mint
  const tokenActions = Actions.set()
    .tokenLimit({ mint: tokenMint, amount: BigInt(1000000) })
    .get();
  await addNewAuthority(connection, rootUser, tokenAuthority, swigAddress, tokenActions, "token");

  // Verify the authorities were added
  const swig = await fetchSwig(connection, swigAddress);
  console.log(chalk.blue("\n📊 Authority Permissions:"));

  const spendingRole = swig.findRolesByEd25519SignerPk(spendingAuthority.publicKey)[0];
  console.log(chalk.yellow("Spending Authority:"));
  console.log("- Can spend SOL:", chalk.green(spendingRole.canSpendSol(BigInt(0.1 * LAMPORTS_PER_SOL))));
  console.log("- Can spend tokens:", chalk.red(spendingRole.canSpendToken(tokenMint, BigInt(1000000))));

  const tokenRole = swig.findRolesByEd25519SignerPk(tokenAuthority.publicKey)[0];
  console.log(chalk.yellow("\nToken Authority:"));
  console.log("- Can spend SOL:", chalk.red(tokenRole.canSpendSol(BigInt(0.1 * LAMPORTS_PER_SOL))));
  console.log("- Can spend tokens:", chalk.green(tokenRole.canSpendToken(tokenMint, BigInt(1000000))));

  await new Promise(resolve => setTimeout(resolve, 2000));
  console.log(chalk.green("\n✨ Tutorial completed successfully!"));
  console.log(chalk.yellow("🔍 Check out your transaction on Solana Explorer:"));
  console.log(chalk.cyan(`https://explorer.solana.com/address/${swigAddress}?cluster=custom&customUrl=http%3A%2F%2Flocalhost%3A8899`));
})();

```

## Code Breakdown

Let's examine the key parts of `tutorial-2.ts`:

### 1. Creating a Root Authority

```typescript
const rootActions = Actions.set().manageAuthority().get();
const tx = await createSwig(
  connection,
  id,
  rootAuthority,
  rootActions,
  user.publicKey,
  [user]
);
```

This creates a Swig account where the root authority has permission to manage other authorities. We specifically use `.manageAuthority()` to limit this authority to only managing other authorities.

### 2. Adding a SOL Spending Authority

Dont forget that the full list of actions an authority can have is [here](https://anagrambuild.github.io/swig-ts/enums/_swig-wallet_coder.Permission.html).

```typescript
const spendingActions = Actions.set()
  .solLimit({ amount: BigInt(0.1 * LAMPORTS_PER_SOL) })
  .get();

await addNewAuthority(
  connection,
  rootUser,
  spendingAuthority,
  swigAddress,
  spendingActions,
  "spending"
);
```

This creates an authority that:

* Can only spend SOL (no token permissions)
* Has a spending limit of 0.1 SOL
* Cannot manage other authorities

### 3. Adding a Token Authority

```typescript
const tokenMint = Keypair.generate().publicKey; // Example token mint
const tokenActions = Actions.set()
  .tokenLimit({ mint: tokenMint, amount: BigInt(1000000) })
  .get();

await addNewAuthority(
  connection,
  rootUser,
  tokenAuthority,
  swigAddress,
  tokenActions,
  "token"
);
```

This creates an authority that:

* Can only manage tokens for a specific mint
* Has a token spending limit of 1,000,000 units
* Cannot spend SOL or manage other authorities

## Understanding the Output

When you run the tutorial, you'll see:

1. The root user's public key
2. The Swig account address
3. Two new authority public keys
4. A permission summary showing what each authority can and cannot do

The tutorial provides links to view your transactions on Solana Explorer (using your local validator).

## Key Concepts

* **Root Authority**: An authority with management permissions that can add or remove other authorities
* **Specialized Authorities**: Authorities with specific, limited permissions (e.g., SOL spending or token management)
* **Permission Limits**:
  * SOL limits are set in lamports (1 SOL = 1,000,000,000 lamports)
  * Token limits are set based on the token's decimals
* **Action Sets**: Define what an authority can do using methods like:
  * `.manageAuthority()`
  * `.solLimit()`
  * `.tokenLimit()`

## Running the Tutorial

Execute the tutorial with:

```bash
bun tutorial-2.ts
```

You nailed it , first try!! You now have a multi authority Swig, free energy and perpetual motion next.


# 3. Signing with Swig
Source: https://build.onswig.com/tutorials/typescript/sign

"I came. I saw. I signed it with Swig." - Julius Caesar, probably

Now that we have our Swig account set up with proper authorities from the previous tutorials, let's explore how to sign transactions. If you haven't completed the previous tutorials, please go back and complete them first as we'll be building on those concepts.

Create a new file called `tutorial-3.ts` in your `examples/transfer/tutorial` directory:

```bash
touch tutorial-3.ts
```

## Example

```typescript
import {
  Keypair,
  LAMPORTS_PER_SOL,
  Connection,
  Transaction,
  sendAndConfirmTransaction,
  PublicKey,
} from '@solana/web3.js';

import {
  Actions,
  createSwig,
  Ed25519Authority,
  findSwigPda,
  addAuthorityInstruction,
  fetchSwig,
  createEd25519AuthorityInfo,
  signInstruction,
} from "@swig-wallet/classic";

import {
  TOKEN_PROGRAM_ID,
  ASSOCIATED_TOKEN_PROGRAM_ID,
  createMint,
  createAssociatedTokenAccount,
  mintTo,
  getAssociatedTokenAddress,
  getAccount,
  createTransferInstruction,
} from "@solana/spl-token";

import chalk from 'chalk';

async function createSwigAccount(
  connection: Connection,
  user: Keypair,
) {
  try {
    const id = new Uint8Array(32);
    crypto.getRandomValues(id);
    const [swigAddress] = findSwigPda(id);
    const rootAuthority = Ed25519Authority.fromPublicKey(user.publicKey);
    const rootActions = Actions.set().manageAuthority().get();
    const tx = await createSwig(
      connection,
      id,
      rootAuthority,
      rootActions,
      user.publicKey,
      [user]
    );

    console.log(chalk.green("✓ Swig account created at:"), chalk.cyan(swigAddress.toBase58()));
    return swigAddress;
  } catch (error) {
    console.error(chalk.red("✗ Error creating Swig account:"), chalk.red(error));
    throw error;
  }
}

async function addNewAuthority(
  connection: Connection,
  rootUser: Keypair,
  newAuthority: Keypair,
  swigAddress: PublicKey,
  actions: any,
  description: string
) {
  try {
    const swig = await fetchSwig(connection, swigAddress);
    const rootRole = swig.findRolesByEd25519SignerPk(rootUser.publicKey)[0];
    if (!rootRole) {
      throw new Error('Root role not found for authority');
    }

    const addAuthorityIx = await addAuthorityInstruction(
      rootRole,
      rootUser.publicKey,
      createEd25519AuthorityInfo(newAuthority.publicKey),
      actions,
    );

    const transaction = new Transaction().add(addAuthorityIx);
    await sendAndConfirmTransaction(connection, transaction, [rootUser]);
    console.log(chalk.green(`✓ New ${description} authority added:`), chalk.cyan(newAuthority.publicKey.toBase58()));
  } catch (error) {
    console.error(chalk.red(`✗ Error adding ${description} authority:`), chalk.red(error));
    throw error;
  }
}

async function displayTokenBalance(
  connection: Connection,
  tokenAccount: PublicKey,
  label: string
) {
  const account = await getAccount(connection, tokenAccount);
  console.log(chalk.yellow(`${label} token balance:`), chalk.cyan(account.amount.toString()));
}

(async () => {
  console.log(chalk.blue("🚀 Starting tutorial - Token Authority and Transfers"));

  // Connect to local Solana network
  const connection = new Connection('http://localhost:8899', 'confirmed');

  // Create and fund the root user
  const rootUser = Keypair.generate();
  console.log(chalk.green("👤 Root user public key:"), chalk.cyan(rootUser.publicKey.toBase58()));

  let airdrop = await connection.requestAirdrop(rootUser.publicKey, 100 * LAMPORTS_PER_SOL);
  let blockhash = await connection.getLatestBlockhash();
  await connection.confirmTransaction({
    signature: airdrop,
    blockhash: blockhash.blockhash,
    lastValidBlockHeight: blockhash.lastValidBlockHeight,
  });

  // Create the Swig account
  console.log(chalk.yellow("\n📝 Creating Swig account..."));
  const swigAddress = await createSwigAccount(connection, rootUser);

  // Create token mint
  console.log(chalk.yellow("\n💎 Creating token mint..."));
  const mintAuthority = Keypair.generate();
  const tokenMint = await createMint(
    connection,
    rootUser,
    mintAuthority.publicKey,
    null,
    0
  );
  console.log(chalk.green("✓ Token mint created:"), chalk.cyan(tokenMint.toBase58()));

  // Create token accounts
  console.log(chalk.yellow("\n💰 Creating token accounts..."));
  const swigTokenAccount = await createAssociatedTokenAccount(
    connection,
    rootUser,
    tokenMint,
    swigAddress,
    {},
    TOKEN_PROGRAM_ID,
    ASSOCIATED_TOKEN_PROGRAM_ID,
    true
  );
  console.log(chalk.green("✓ Swig token account created:"), chalk.cyan(swigTokenAccount.toBase58()));

  const recipientKeypair = Keypair.generate();
  const recipientTokenAccount = await createAssociatedTokenAccount(
    connection,
    rootUser,
    tokenMint,
    recipientKeypair.publicKey
  );
  console.log(chalk.green("✓ Recipient token account created:"), chalk.cyan(recipientTokenAccount.toBase58()));

  // Mint initial tokens to Swig account
  console.log(chalk.yellow("\n🏦 Minting tokens to Swig account..."));
  await mintTo(
    connection,
    rootUser,
    tokenMint,
    swigTokenAccount,
    mintAuthority,
    10
  );
  await displayTokenBalance(connection, swigTokenAccount, "Swig");
  await displayTokenBalance(connection, recipientTokenAccount, "Recipient");

  // Create token authority with permission to send exactly 10 tokens
  const tokenAuthority = Keypair.generate();
  console.log(chalk.green("\n👥 Token authority public key:"), chalk.cyan(tokenAuthority.publicKey.toBase58()));
  await connection.requestAirdrop(tokenAuthority.publicKey, 100 * LAMPORTS_PER_SOL);
  console.log(chalk.yellow("\n🔑 Adding token authority..."));
  const tokenActions = Actions.set()
    .tokenLimit({ mint: tokenMint, amount: BigInt(10) })
    .get();
  await addNewAuthority(connection, rootUser, tokenAuthority, swigAddress, tokenActions, "token");

  // Add some delay to ensure the authority is added
  await new Promise(resolve => setTimeout(resolve, 2000));

  // First transfer - should succeed
  console.log(chalk.yellow("\n💸 Attempting first transfer of 10 tokens..."));
  try {
    const swig = await fetchSwig(connection, swigAddress);
    const tokenRole = swig.findRolesByEd25519SignerPk(tokenAuthority.publicKey)[0];

    const transferIx = createTransferInstruction(
      swigTokenAccount,
      recipientTokenAccount,
      swigAddress,
      BigInt(10)
    );

    const signedTransfer = await signInstruction(
      tokenRole,
      tokenAuthority.publicKey,
      [transferIx]
    );

    const transaction = new Transaction().add(signedTransfer);
    await sendAndConfirmTransaction(connection, transaction, [tokenAuthority]);
    console.log(chalk.green("✓ First transfer successful!"));
    await displayTokenBalance(connection, swigTokenAccount, "Swig");
    await displayTokenBalance(connection, recipientTokenAccount, "Recipient");
  } catch (error) {
    console.error(chalk.red("✗ First transfer failed:"), chalk.red(error));
  }

  // Second transfer - should fail
  console.log(chalk.yellow("\n💸 Attempting second transfer (should fail)..."));
  try {
    const swig = await fetchSwig(connection, swigAddress);
    const tokenRole = swig.findRolesByEd25519SignerPk(tokenAuthority.publicKey)[0];

    const transferIx = createTransferInstruction(
      swigTokenAccount,
      recipientTokenAccount,
      swigAddress,
      BigInt(10)
    );

    const signedTransfer = await signInstruction(
      tokenRole,
      tokenAuthority.publicKey,
      [transferIx]
    );

    const transaction = new Transaction().add(signedTransfer);
    await sendAndConfirmTransaction(connection, transaction, [tokenAuthority], {
      skipPreflight: true,
    });
    console.error(chalk.red("✗ Second transfer unexpectedly succeeded!"));
  } catch (error) {
    console.log(chalk.green("✓ Second transfer failed as expected:"), "Authority has no remaining token allowance");
  }

  await displayTokenBalance(connection, swigTokenAccount, "Final Swig");
  await displayTokenBalance(connection, recipientTokenAccount, "Final Recipient");

  console.log(chalk.green("\n✨ Tutorial completed successfully!"));
  console.log(chalk.yellow("🔍 Check out your transaction on Solana Explorer:"));
  console.log(chalk.cyan(`https://explorer.solana.com/address/${swigAddress}?cluster=custom&customUrl=http%3A%2F%2Flocalhost%3A8899`));
})();
```

Let's break down how signing works with Swig.

## 1. Fetch the Swig Account

```typescript
const swig = await fetchSwig(connection, swigAddress);
```

First, we need to fetch the current state of our Swig account. This contains all the roles and their permissions that we set up in the previous tutorials.

## 2. Find the Appropriate Role

```typescript
const tokenRole = swig.findRolesByEd25519SignerPk(tokenAuthority.publicKey)[0];
```

We locate the role associated with our token authority. Remember from the previous tutorial that this role was created with specific token transfer limits.

> 💡 A single authority can have multiple roles. Always make sure you're using the correct role for your intended action.

## 3. Create the Instruction

```typescript
const transferIx = createTransferInstruction(
  swigTokenAccount,
  recipientTokenAccount,
  swigAddress,
  BigInt(10)
);
```

Create the instruction that needs to be signed. In this case, it's a token transfer instruction, but Swig can sign any type of instruction as long as the role has the appropriate permissions.

## 4. Sign the Instruction

```typescript
const signedTransfer = await signInstruction(
  tokenRole,
  tokenAuthority.publicKey,
  [transferIx]
);
```

This is where the magic happens. The `signInstruction` function:

1. Verifies that the role has permission to sign this type of instruction
2. Creates a signature using the authority's credentials
3. Wraps the original instruction with Swig's signing logic

> 🔒 Swig validates both the authority type and action permissions at this stage

## 5. Build and Send the Transaction

```typescript
const transaction = new Transaction().add(signedTransfer);
await sendAndConfirmTransaction(connection, transaction, [tokenAuthority]);
```

Finally, we build the transaction with our signed instruction and send it to the network. Note that the transaction still needs to be signed by the authority's keypair because they're the one paying for the transaction fees.

## Understanding Signature Verification

When the transaction reaches the Solana network, the Swig program will:

1. Extract the original instruction
2. Verify the authority's signature
3. Check that the role's permissions allow this action
4. Execute the instruction if all checks pass

> 🧠 This multi-step verification ensures that only authorized actions are performed

## Ready to try it?

Make sure you have:

1. Completed the previous tutorials
2. Have a running validator (`bun start-validator`)
3. Created a Swig account with appropriate authorities

Then run:

```bash
bun run ./tutorial-3.ts
```

The link at the end of the tutorial will take you to the swig on the Solana Explorer. You will see multiple transactions and there should be one failed which shows the negative case.


# Use Cases: Customers
Source: https://build.onswig.com/use-case-customers



Swig is built for developers. Our smart wallet tooling is allowing developers to quickly unlock both fundamental and advanced functionality for their end-users. We’re early, but we’re already powering a diverse set of use cases across payments, dApps, AI, cross-chain, and many more.

## **Payments**

Why build your payments use case on Swig:

* **Subscriptions:** Enable automatic, on-chain subscription payments that are configurable to your required payment cadence.
* **Pre-Set Spending Conditions:** Ensure that your users never get charged more than the amounts they expect to get charged.
* **Payment Streaming:** Enable micropayment streams of any kind.
* **Payment Speed:** Authorize transactions in \<800 milliseconds with Swig.
* **Configurable Payment Holds:** Allows you to configure settlement times on card payments based on your card’s needs. Set settlements to be real-time, on hold for 24 hours, or any other amount of time - whatever is required for your use case.

## **dApps**

Why build your dApp on Swig:

* **Granular Permissions:** Enables users to give your app specific permissions without giving you access to their whole wallet, which allows you to create more powerful experiences for your users with the permissions granted to the app while staying non-custodial.
* **Configurable & Automatic Transactions:** Powers functionality like automatic trading strategies, conditional transactions based on chain events, dollar-cost averaging, continuous transactions, and much more.
* **Session Keys:** Allows users to just approve once during a defined time period while using your app. Avoids the UX frictions of constant manual signing.
* **Gasless Transactions:** Integrate Swig’s paymaster to eliminate UX friction by covering gas fees for your users or enable them to pay gas fees with non-native tokens.
* **Social Sign In & Recovery:** Onboard non-crypto and crypto-native users without frictions associated with traditional wallet onboarding and seed recovery concerns.
* **Chain Abstraction:** Enables your app to operate across multiple SVM chains without UX frictions since users can operate across SVM chains with one Swig wallet.

## **AI**

Why build your AI use case on Swig:

* **AI Chat:** Easily create AI-powered chat-to-action functionality within your app that enables users conduct transactions in your app experience via a chat function. Users can type things like “buy 10 SOL next time the price drops below \$100” and your app handles the rest with Swig.
* **AI Swarms:** Use Swig’s role-based permissions architecture to enable AI swarm use cases for any app type. With Swig, you can configure multiple agents to each have different permissions and have them work together based on conditional logic.
* **Frictionless AI:** Leveraging session keys, agents can seamlessly execute several transactions within a defined period without needing to stop for constant approvals.
* **Much More…** the functionality that Swig offers on-chain agents can power an endless possibility of features. We encourage builders to get creative and let us know what you were able to build on Swig.

## **Cross-Chain**

Why “add Solana” to your app using Swig:

* **Sign SVM Transactions With EVM Keys:** Building on Swig allows your users to sign SVM transactions during their app experience without needing to leave their EVM wallet. This allows your app and your users to benefit from the power of Solana without creating any UX friction.
* **“Add Solana”:** For apps that are expanding their chain support to Solana, building their Solana use case on Swig from the start has allowed them to ensure the most robust Solana experience for their users while avoiding development headaches that come with working on an unfamiliar chain. Our docs can be exported as an MCP server so that non-Solana native developers can easily understand Swig and build powerful Solana use cases for their users.
* **UX Parity Across Chains:** If your app is multi-chain, you are likely using EVM smart wallet tools to power advanced experiences for your users when they interact with EVM protocols. But until now, you haven’t been able to provide them with experience parity when they interact with SVM protocols in your app. With Swig’s smart wallet functionality, you can close that parity gap to ensure your users have universal experiences across EVM and SVM chains.

## **And more…**

Swig’s primitives allow for an endless number of possibilities across any use case. In addition to payments, dApps, AI, and cross-chain use cases, Swig can power use cases such as custodians adding hot wallet functionality to their custody stack, exchanges building unique on-chain trading experiences, gaming apps reducing in-game UX frictions, and many more.

**We believe some of the most powerful use cases built on Swig have not even been imagined yet. If you are a developer and are interested in building something new on Solana, we encourage you to play around on Swig and see what Swig can enable you to create.**


# Use Cases: Partners
Source: https://build.onswig.com/use-case-partners



Swig’s smart wallet tooling helps embedded wallets, wallets, SVM L2s, and other partners better service their ecosystem of developers, which in turn helps them build better use cases for their users.

## **Wallets & Embedded Wallets**

Swig is a great fit as a partner to wallets & embedded wallets to help solve the needs of their developers:

* **Add Solana Smart Wallet Tooling:** Expose SVM smart wallet tooling to your ecosystem of developers building on your embedded wallet so that your platform continues to be where they build across multiple chains.
* **Custom Auth Flows:** Build custom authentication flows by combining Swig’s wallet SDK with your embedded wallet for your developers to leverage as they build.
* **Additional Auth Types:** For MPC wallets, your developers can use your wallet and leverage multiple different auth types beyond just MPC when combined with Swig.
* **Much More…** the functionality that Swig offers combined with your wallet can provide boundless benefits to developers and allow you to grow your ecosystem.

Let’s work together to empower developers building Solana use cases.

## **SVM L2s**

Swig can help SVM L2s build a robust ecosystem:

* **Build Better Apps:** Swig’s smart wallet functionality combined with the benefits of SVM offer developers with the tooling to create the most compelling apps. Ensuring your ecosystem of developers are building on Swig will set your chain up well for user adoption growth as users will be drawn to apps that have the advanced functionality that building on Swig can create.
* **Reduce Onboarding Frictions:** Swig’s cross-chain functionality enables developers to build apps that operate across multiple SVM chains without UX frictions since users can operate across SVM chains with one Swig wallet. This means that developers building on Swig will have an easier time bringing users to your chain.

Let’s work together to bring adoption to your chain.

## **And more…**

Swig’s primitives allow for an endless number of possibilities across any use case. We are powering use cases across payments, dApps, AI, cross-chain, custodians, exchanges, gaming apps and more. If you are looking to grow your ecosystems of developers and users, it’s very likely that partnering with Swig can help accelerate that.

Get in touch with our team at \[insert hyperlink to [info@onswig.com](mailto:info@onswig.com) email].