### Install Tenderly SDK with npm, yarn, or pnpm

Source: https://github.com/tenderly/tenderly-sdk/blob/master/README.md

Install the Tenderly SDK using your preferred package manager. This is the first step to integrating Tenderly's features into your project.

```bash
npm i @tenderly/sdk
```

```bash
yarn add @tenderly/sdk
```

```bash
pnpm add @tenderly/sdk
```

--------------------------------

### Retrieve and Filter Wallets using Tenderly SDK (TypeScript)

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This example shows how to retrieve wallets from your Tenderly project, with options for filtering. You can get a specific wallet by its address, retrieve all wallets, or filter wallets by tags or display names. The code initializes the Tenderly SDK and then uses `tenderly.wallets.get`, `tenderly.wallets.getAll`, and `tenderly.wallets.getBy` methods. Ensure the `TENDERLY_ACCESS_KEY` environment variable is set.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

// Get a specific wallet
const wallet = await tenderly.wallets.get('0xDBcB6Db1FFEaA10cd157F985a8543261250eFA46');
console.log('Wallet:', wallet?.address);

// Get all wallets
const allWallets = await tenderly.wallets.getAll();
console.log('Total wallets:', allWallets?.length);

// Filter by tags
const taggedWallets = await tenderly.wallets.getBy({
  tags: ['treasury', 'multisig']
});

// Filter by display names
const namedWallets = await tenderly.wallets.getBy({
  displayNames: ['My Test Wallet', 'Production Wallet']
});

console.log('Treasury wallets:', taggedWallets?.map(w => w.address));
```

--------------------------------

### Verify Multi-File Contracts with Dependencies using Tenderly SDK (TypeScript)

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This example demonstrates how to verify a smart contract that has multiple source files and dependencies, such as imported contracts or libraries. It requires all source files to be provided in the verification request. The code reads local files and includes them in the `solc.sources` object. Ensure the `TENDERLY_ACCESS_KEY` environment variable is set.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';
import { readFileSync } from 'fs';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.SEPOLIA
});

const contractAddress = '0x1234567890abcdef1234567890abcdef12345678';

const verified = await tenderly.contracts.verify(contractAddress, {
  config: { mode: 'public' },
  contractToVerify: 'contracts/MyContract.sol:MyContract',
  solc: {
    version: 'v0.8.18',
    sources: {
      'contracts/MyContract.sol': {
        content: readFileSync('./contracts/MyContract.sol', 'utf8')
      },
      'contracts/interfaces/IHelper.sol': {
        content: readFileSync('./contracts/interfaces/IHelper.sol', 'utf8')
      },
      '@openzeppelin/contracts/token/ERC20/IERC20.sol': {
        content: readFileSync('./node_modules/@openzeppelin/contracts/token/ERC20/IERC20.sol', 'utf8')
      }
    },
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      }
    }
  }
});

console.log('Multi-file contract verified:', verified?.address);
```

--------------------------------

### Verify Contracts with Linked Libraries using Tenderly SDK (TypeScript)

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This example shows how to verify a smart contract that utilizes linked libraries. When compiling with linked libraries, you must specify the addresses of these libraries in the `solc.settings.libraries` configuration. The code reads local contract and library source files and includes them in the `solc.sources` object. Ensure the `TENDERLY_ACCESS_KEY` environment variable is set.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';
import { readFileSync } from 'fs';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

const contractAddress = '0xabcdef1234567890abcdef1234567890abcdef12';

const verified = await tenderly.contracts.verify(contractAddress, {
  config: { mode: 'private' },
  contractToVerify: 'contracts/MyLibraryUser.sol:MyLibraryUser',
  solc: {
    version: 'v0.8.18',
    sources: {
      'contracts/MyLibraryUser.sol': {
        content: readFileSync('./contracts/MyLibraryUser.sol', 'utf8')
      },
      'contracts/libraries/MathLib.sol': {
        content: readFileSync('./contracts/libraries/MathLib.sol', 'utf8')
      }
    },
    settings: {
      optimizer: {
        enabled: true,
        runs: 200
      },
      libraries: {
        'contracts/libraries/MathLib.sol': {
          'MathLib': '0x1111222233334444555566667777888899990000'
        }
      }
    }
  }
});

console.log('Contract with libraries verified:', verified?.address);
```

--------------------------------

### Retrieve and Filter Contracts with Tenderly SDK

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This snippet demonstrates how to retrieve contracts from a Tenderly project. It shows how to get a specific contract by address, fetch all contracts, and filter contracts by tags or display names. Requires Tenderly SDK initialization with project and network details.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

// Get a specific contract
const contract = await tenderly.contracts.get('0x6b175474e89094c44da98b954eedeac495271d0f');
console.log('Contract address:', contract?.address);

// Get all contracts
const allContracts = await tenderly.contracts.getAll();
console.log('Total contracts:', allContracts?.length);

// Filter contracts by tags
const defiContracts = await tenderly.contracts.getBy({
  tags: ['defi', 'stablecoin']
});

// Filter by display names
const namedContracts = await tenderly.contracts.getBy({
  displayNames: ['DAI Stablecoin', 'USDC Token']
});

console.log('DeFi contracts:', defiContracts?.map(c => c.address));
```

--------------------------------

### Update Tenderly Wallets with Display Names and Tags

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This snippet shows how to update wallet display names and add tags to organize wallets within a Tenderly project. It demonstrates updating individual properties or both simultaneously. Ensure you have the Tenderly SDK installed and your access key configured.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

const walletAddress = '0xDBcB6Db1FFEaA10cd157F985a8543261250eFA46';

// Update display name only
const renamed = await tenderly.wallets.update(walletAddress, {
  displayName: 'Production Deployment Wallet'
});

// Add tags
await tenderly.wallets.update(walletAddress, {
  appendTags: ['production', 'deployer', 'critical']
});

// Update both
const updated = await tenderly.wallets.update(walletAddress, {
  displayName: 'Primary Treasury Wallet',
  appendTags: ['treasury', 'monitored']
});

console.log('Updated wallet:', updated?.displayName);
console.log('Tags:', updated?.tags);
```

--------------------------------

### Handle Tenderly SDK Errors with Typed Exceptions

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This example illustrates how to handle various errors that can occur when using the Tenderly SDK, such as invalid arguments, not found errors, compilation issues, and API errors. It uses specific error types provided by the SDK for precise error management.

```typescript
import {
  Tenderly,
  Network,
  InvalidArgumentsError,
  NotFoundError,
  CompilationError,
  BytecodeMismatchError,
  ApiError
} from '@tenderly/sdk';

try {
  const tenderly = new Tenderly({
    accessKey: process.env.TENDERLY_ACCESS_KEY,
    accountName: 'my-account',
    projectName: 'my-project',
    network: Network.MAINNET
  });

  const contract = await tenderly.contracts.get('0x1234567890abcdef1234567890abcdef12345678');
  console.log('Contract found:', contract?.address);

} catch (error) {
  if (error instanceof InvalidArgumentsError) {
    console.error('Invalid configuration:', error.message);
    console.error('Please check your access key, account name, and project name');
  } else if (error instanceof NotFoundError) {
    console.error('Contract not found:', error.message);
  } else if (error instanceof CompilationError) {
    console.error('Contract compilation failed:', error.message);
    console.error('Compilation errors:', error.details);
  } else if (error instanceof BytecodeMismatchError) {
    console.error('Bytecode mismatch during verification:', error.message);
    console.error('Similarity:', error.details?.similarity);
  } else if (error instanceof ApiError) {
    console.error('API error:', error.message);
    console.error('Status code:', error.statusCode);
  } else {
    console.error('Unexpected error:', error);
  }
}
```

--------------------------------

### Instantiate Tenderly SDK Instance

Source: https://github.com/tenderly/tenderly-sdk/blob/master/README.md

Initialize a new Tenderly SDK instance with your project credentials. It's recommended to use environment variables for sensitive data like access keys. This instance is used to interact with the Tenderly API.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderlyInstance = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: process.env.TENDERLY_ACCOUNT_NAME,
  projectName: process.env.TENDERLY_PROJECT_NAME,
  network: Network.MAINNET,
});
```

--------------------------------

### Initialize Tenderly SDK with Project Credentials (TypeScript)

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

Initializes the Tenderly SDK instance using project credentials, including access key, account name, project name, and target network. This instance is required for all subsequent SDK operations.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

// Access SDK features
const contracts = await tenderly.contracts.getAll();
const wallets = await tenderly.wallets.getAll();
```

--------------------------------

### Add Wallets for Monitoring using Tenderly SDK (TypeScript)

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This code snippet demonstrates how to add a wallet address to your Tenderly project for transaction tracking and analytics. It initializes the Tenderly SDK with your access key, account, project, and network. The `tenderly.wallets.add` method takes the wallet address and an optional display name. Ensure the `TENDERLY_ACCESS_KEY` environment variable is set.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.SEPOLIA
});

const walletAddress = '0xDBcB6Db1FFEaA10cd157F985a8543261250eFA46';

const wallet = await tenderly.wallets.add(walletAddress, {
  displayName: 'My Test Wallet'
});

console.log('Added wallet:', wallet?.address);
console.log('Display name:', wallet?.displayName);
console.log('Network:', wallet?.network);
```

--------------------------------

### Create Network-Specific Tenderly SDK Instances (TypeScript)

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

Demonstrates how to create derived Tenderly SDK instances for different networks from an existing instance. This is useful for multi-chain applications, allowing independent use of various networks.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const mainnetTenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

// Create instances for other networks
const sepoliaTenderly = mainnetTenderly.with({ network: Network.SEPOLIA });
const baseTenderly = mainnetTenderly.with({ network: Network.BASE });

// Use different networks independently
const mainnetContract = await mainnetTenderly.contracts.get('0x6b175474e89094c444da98b954eedeac495271d0f');
const sepoliaWallet = await sepoliaTenderly.wallets.add('0xDBcB6Db1FFEaA10cd157F985a8543261250eFA46');
```

--------------------------------

### Simulate Transaction with Tenderly SDK (JavaScript)

Source: https://github.com/tenderly/tenderly-sdk/blob/master/examples/simulateTransaction/README.md

This snippet demonstrates how to simulate a transaction using the `simulateTransaction` method from the Tenderly SDK. It requires the caller's address, the target contract address, the contract's ABI, and transaction details like `from`, `to`, `gas`, `gas_price`, `value`, and `input`. The `input` is encoded using the contract's ABI. It also specifies a `blockNumber` for the simulation. The output includes the simulated transaction details or an error message.

```jsx
const callerAddress = '0xDBcB6Db1FFEaA10cd157F985a8543261250eFA46';
const counterContract = '0x93Cc0A80DE37EC4A4F97240B9807CDdfB4a19fB1';

const counterContractAbiInterface = new Interface(counterContractAbi);
try {
  const transaction = await tenderly.simulator.simulateTransaction({
    transaction: {
      from: callerAddress,
      to: counterContract,
      gas: 20000000,
      gas_price: '19419609232',
      value: 0,
      input: counterContractAbiInterface.encodeFunctionData('inc', []),
    },
    blockNumber: 3237677,
  });

  console.log('Simulated transaction:', transaction);
} catch (error) {
  console.error('Error. Failed to simulate transaction: ', error);
}
```

--------------------------------

### Simulate Transaction Bundles with Tenderly SDK

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

Simulates multiple dependent transactions sequentially in a single simulation context using the Tenderly SDK. This allows testing complex transaction flows. It takes an array of transactions and optional state overrides as input and returns simulation results.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';
import { Interface } from 'ethers';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.SEPOLIA
});

const erc20Abi = [
  'function approve(address spender, uint256 amount) returns (bool)',
  'function transferFrom(address from, address to, uint256 amount) returns (bool)'
];
const tokenInterface = new Interface(erc20Abi);

const myTokenAddress = '0x912043e00a14a6b79f5e500c825b1439e812d7ce';
const fromWallet = '0x8d1d4e2b8b9b1b4b9e0d0d6d7c7c4e4e8d9d00e0';
const toWallet = '0xDBcB6Db1FFEaA10cd157F985a8543261250eFA46';

const simulations = await tenderly.simulator.simulateBundle({
  transactions: [
    {
      from: fromWallet,
      to: myTokenAddress,
      gas: 0,
      gas_price: '0',
      value: '0',
      input: tokenInterface.encodeFunctionData('approve', [toWallet, 1234567890])
    },
    {
      from: toWallet,
      to: myTokenAddress,
      gas: 0,
      gas_price: '0',
      value: '0',
      input: tokenInterface.encodeFunctionData('transferFrom', [fromWallet, toWallet, 1234567890])
    }
  ],
  blockNumber: 3262454,
  overrides: {
    [myTokenAddress]: {
      state: {
        [`_balances[${fromWallet}]`]: '1234567891'
      }
    }
  }
});

const totalGasUsed = simulations?.reduce((total, sim) => total + (sim.gasUsed || 0), 0);
console.log('Total gas used:', totalGasUsed);

simulations?.forEach((simulation, index) => {
  console.log(`Transaction ${index}:`, simulation.status ? 'success' : 'failed');
  console.log(`  Block: ${simulation.blockNumber}`);
  console.log(`  Gas used: ${simulation.gasUsed}`);
  console.log(`  Logs count: ${simulation.logs?.length || 0}`);
});
```

--------------------------------

### Verify Smart Contract Source Code with Tenderly SDK

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This snippet illustrates how to verify a smart contract's source code on Tenderly, enabling features like decoded transaction traces and source code display in the debugger. It requires contract address, verification configuration, and Solidity compiler details. Uses Node.js 'fs' module for reading source files.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';
import { readFileSync } from 'fs';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.SEPOLIA
});

const contractAddress = '0x8aaf9071e6c3129653b2dc39044c3b79c0bfcfbf';

try {
  const verifiedContract = await tenderly.contracts.verify(contractAddress, {
    config: {
      mode: 'public' // or 'private' for project-only verification
    },
    contractToVerify: 'Counter.sol:CounterWithLogs', // Fully qualified name
    solc: {
      version: 'v0.8.18',
      sources: {
        'Counter.sol': {
          content: readFileSync('./contracts/Counter.sol', 'utf8')
        }
      },
      settings: {
        optimizer: {
          enabled: false,
          runs: 200
        }
      }
    }
  });

  console.log('Contract verified:', verifiedContract?.address);
  console.log('Display name:', verifiedContract?.displayName);
} catch (error) {
  console.error('Verification failed:', error);
}
```

--------------------------------

### Simulate ERC20 Approve and TransferFrom with Tenderly SDK

Source: https://github.com/tenderly/tenderly-sdk/blob/master/examples/allowAndTransfer/README.md

This TypeScript code simulates a user approving another address to spend their ERC20 tokens using the 'approve' method, followed by the spender using 'transferFrom' to move the tokens. It utilizes the Tenderly SDK and includes state overrides to set the initial balance for the simulation. Dependencies include 'ethers' and the ERC20 token's ABI.

```typescript
    import { Interface } from 'ethers';
    import { myTokenAbi } from './myTokenAbi'; // ABI of the ERC20 token contract

    ... // Assume tenderly object is initialized

    const myTokenAddress = '0x912043e00a14a6b79f5e500c825b1439e812d7ce';
    const fromWalletAddress = '0x8d1d4e2b8b9b1b4b9e0d0d6d7c7c4e4e8d9d00e0';
    const toWalletAddress = '0xDBcB6Db1FFEaA10cd157F985a8543261250eFA46';

    const myTokenAbiInterface = new Interface(myTokenAbi);

    const simulations = await tenderly.simulator.simulateBundle({
      transactions: [
        {
          from: fromWalletAddress,
          to: myTokenAddress,
          gas: 0,
          gas_price: '0',
          value: 0,
          input: myTokenAbiInterface.encodeFunctionData('approve', [toWalletAddress, 1234567890]),
        },
        {
          from: toWalletAddress,
          to: myTokenAddress,
          gas: 0,
          gas_price: '0',
          value: 0,
          input: myTokenAbiInterface.encodeFunctionData('transferFrom',
            [
              fromWalletAddress,
              toWalletAddress,
              1234567890,
            ]),
        },
      ],
      blockNumber: 3262454,
      overrides: {
        [myTokenAddress]: {
          state: {
            [`_balances[${fromWalletAddress}]`]: '1234567891',
          },
        },
      },
    });

```

--------------------------------

### Add Contracts to Tenderly Project

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

Adds smart contracts to a Tenderly project for monitoring and debugging purposes. This enables transaction tracking, debugging, and gas profiling for the specified contract addresses. It requires a Tenderly SDK instance and contract address.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

// Add a verified contract (DAI)
const daiContract = await tenderly.contracts.add(
  '0x6b175474e89094c44da98b954eedeac495271d0f',
  { displayName: 'DAI Stablecoin' }
);

console.log('Added contract:', daiContract?.address);
console.log('Display name:', daiContract?.displayName);
console.log('Network:', daiContract?.network);

// Add an unverified contract
const unverifiedContract = await tenderly.contracts.add(
  '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe',
  { displayName: 'My Unverified Contract' }
);
```

--------------------------------

### Tenderly SDK: State Overrides for Simulation

Source: https://github.com/tenderly/tenderly-sdk/blob/master/examples/allowAndTransfer/README.md

This JavaScript snippet demonstrates how to use the 'overrides' argument within the Tenderly SDK's 'simulateBundle' function to modify contract state for simulations. It specifically shows how to set the balance of a sender address for an ERC20 token, enabling simulations of transactions that might not be possible with the current live blockchain state.

```javascript
overrides: {
        [myTokenAddress]: {
          state: {
            [`_balances[${fromWalletAddress}]`]: '1234567891',
          },
        },
      }
```

--------------------------------

### Fetch Project Contracts using Tenderly SDK

Source: https://github.com/tenderly/tenderly-sdk/blob/master/README.md

Retrieve all contracts associated with your Tenderly project. This function returns a list of contract objects, from which you can extract their addresses.

```typescript
const contracts = await tenderlyInstance.contracts.getAll();

console.log(contracts.map(contract => contract.address).join(', '));
// 0x63456...5689, 0x54j2...23890, 0x211e...289n
```

--------------------------------

### Simulate a Single Transaction with Tenderly SDK (TypeScript)

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

Executes a transaction simulation without broadcasting it to the network. This function provides details on gas usage, state changes, logs, and traces, allowing for pre-execution analysis.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';
import { Interface } from 'ethers';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.SEPOLIA
});

const counterAbi = [
  'function inc() public',
  'function count() public view returns (uint256)'
];
const counterInterface = new Interface(counterAbi);

const simulation = await tenderly.simulator.simulateTransaction({
  transaction: {
    from: '0xDBcB6Db1FFEaA10cd157F985a8543261250eFA46',
    to: '0x93Cc0A80DE37EC4A4F97240B9807CDdfB4a19fB1',
    gas: 20000000,
    gas_price: '19419609232',
    value: '0',
    input: counterInterface.encodeFunctionData('inc', [])
  },
  blockNumber: 3237677
});

console.log('Transaction status:', simulation?.status ? 'success' : 'failed');
console.log('Gas used:', simulation?.gasUsed);
console.log('Logs:', simulation?.logs);
console.log('Trace:', simulation?.trace);
```

--------------------------------

### Update Contract Metadata with Tenderly SDK

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This snippet shows how to update contract metadata, such as display names and tags, using the Tenderly SDK. It covers updating the display name, appending new tags, and performing both updates simultaneously. Requires an initialized Tenderly SDK instance.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

const contractAddress = '0x6b175474e89094c44da98b954eedeac495271d0f';

// Update display name
const updatedContract = await tenderly.contracts.update(contractAddress, {
  displayName: 'DAI Stablecoin Token'
});

// Add tags
await tenderly.contracts.update(contractAddress, {
  appendTags: ['erc20', 'stablecoin', 'defi']
});

// Update both display name and tags
const fullyUpdated = await tenderly.contracts.update(contractAddress, {
  displayName: 'MakerDAO DAI',
  appendTags: ['makerdao', 'tested']
});

console.log('Updated contract:', fullyUpdated?.displayName);
console.log('Tags:', fullyUpdated?.tags);
```

--------------------------------

### Remove Wallets from Tenderly Project

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This code demonstrates how to remove a wallet address from your Tenderly project, ceasing its monitoring. This is useful for cleaning up or decommissioning monitored addresses. Requires the Tenderly SDK and proper authentication.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.SEPOLIA
});

const walletAddress = '0xDBcB6Db1FFEaA10cd157F985a8543261250eFA46';

await tenderly.wallets.remove(walletAddress);
console.log('Wallet removed successfully');
```

--------------------------------

### Use State Overrides in Tenderly Simulations

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

Modifies contract state for simulation testing by temporarily changing contract storage, balances, or code. This enables testing scenarios that are difficult to set up on-chain. It requires a Tenderly SDK instance and transaction details.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';
import { Interface, parseEther } from 'ethers';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

const daiAddress = '0x6b175474e89094c44da98b954eedeac495271d0f';
const fakeWard = '0xe2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2e2';
const recipient = '0xe58b9ee93700a616b50509c8292977fa7a0f8ce1';

const daiAbi = [
  'function mint(address usr, uint256 wad)',
  'function approve(address usr, uint256 wad) returns (bool)'
];
const daiInterface = new Interface(daiAbi);

const simulations = await tenderly.simulator.simulateBundle({
  blockNumber: 17087831,
  transactions: [
    {
      from: fakeWard,
      to: daiAddress,
      gas: 0,
      gas_price: '0',
      value: '0',
      input: daiInterface.encodeFunctionData('mint', [recipient, parseEther('1000')])
    }
  ],
  overrides: {
    [daiAddress]: {
      state: {
        // Grant minting permissions by setting ward storage slot
        [`wards[${fakeWard}]`]: '0x0000000000000000000000000000000000000000000000000000000000000001'
      },
      balance: '5000000000000000000', // 5 ETH
      nonce: 100
    }
  }
});

console.log('Mint simulation:', simulations?.[0]?.status ? 'success' : 'failed');
console.log('Gas used:', simulations?.[0]?.gasUsed);
```

--------------------------------

### Remove Contract from Tenderly Project

Source: https://context7.com/tenderly/tenderly-sdk/llms.txt

This snippet demonstrates how to remove a contract from your Tenderly project using the SDK. It's useful for cleaning up projects by deleting contracts that are no longer needed for monitoring or debugging. Requires an initialized Tenderly SDK instance.

```typescript
import { Tenderly, Network } from '@tenderly/sdk';

const tenderly = new Tenderly({
  accessKey: process.env.TENDERLY_ACCESS_KEY,
  accountName: 'my-account',
  projectName: 'my-project',
  network: Network.MAINNET
});

const contractAddress = '0xde0B295669a9FD93d5F28D9Ec85E40f4cb697BAe';

await tenderly.contracts.remove(contractAddress);
console.log('Contract removed successfully');
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.